1
2
3
4
5
6
7
8
9
10#include <linux/export.h>
11#include <linux/of.h>
12#include <linux/slab.h>
13#include <video/display_timing.h>
14#include <video/of_display_timing.h>
15
16
17
18
19
20
21
22
23
24
25
26static int parse_timing_property(struct device_node *np, const char *name,
27 struct timing_entry *result)
28{
29 struct property *prop;
30 int length, cells, ret;
31
32 prop = of_find_property(np, name, &length);
33 if (!prop) {
34 pr_err("%s: could not find property %s\n",
35 of_node_full_name(np), name);
36 return -EINVAL;
37 }
38
39 cells = length / sizeof(u32);
40 if (cells == 1) {
41 ret = of_property_read_u32(np, name, &result->typ);
42 result->min = result->typ;
43 result->max = result->typ;
44 } else if (cells == 3) {
45 ret = of_property_read_u32_array(np, name, &result->min, cells);
46 } else {
47 pr_err("%s: illegal timing specification in %s\n",
48 of_node_full_name(np), name);
49 return -EINVAL;
50 }
51
52 return ret;
53}
54
55
56
57
58
59static struct display_timing *of_get_display_timing(struct device_node *np)
60{
61 struct display_timing *dt;
62 u32 val = 0;
63 int ret = 0;
64
65 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
66 if (!dt) {
67 pr_err("%s: could not allocate display_timing struct\n",
68 of_node_full_name(np));
69 return NULL;
70 }
71
72 ret |= parse_timing_property(np, "hback-porch", &dt->hback_porch);
73 ret |= parse_timing_property(np, "hfront-porch", &dt->hfront_porch);
74 ret |= parse_timing_property(np, "hactive", &dt->hactive);
75 ret |= parse_timing_property(np, "hsync-len", &dt->hsync_len);
76 ret |= parse_timing_property(np, "vback-porch", &dt->vback_porch);
77 ret |= parse_timing_property(np, "vfront-porch", &dt->vfront_porch);
78 ret |= parse_timing_property(np, "vactive", &dt->vactive);
79 ret |= parse_timing_property(np, "vsync-len", &dt->vsync_len);
80 ret |= parse_timing_property(np, "clock-frequency", &dt->pixelclock);
81
82 dt->dmt_flags = 0;
83 dt->data_flags = 0;
84 if (!of_property_read_u32(np, "vsync-active", &val))
85 dt->dmt_flags |= val ? VESA_DMT_VSYNC_HIGH :
86 VESA_DMT_VSYNC_LOW;
87 if (!of_property_read_u32(np, "hsync-active", &val))
88 dt->dmt_flags |= val ? VESA_DMT_HSYNC_HIGH :
89 VESA_DMT_HSYNC_LOW;
90 if (!of_property_read_u32(np, "de-active", &val))
91 dt->data_flags |= val ? DISPLAY_FLAGS_DE_HIGH :
92 DISPLAY_FLAGS_DE_LOW;
93 if (!of_property_read_u32(np, "pixelclk-active", &val))
94 dt->data_flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
95 DISPLAY_FLAGS_PIXDATA_NEGEDGE;
96
97 if (of_property_read_bool(np, "interlaced"))
98 dt->data_flags |= DISPLAY_FLAGS_INTERLACED;
99 if (of_property_read_bool(np, "doublescan"))
100 dt->data_flags |= DISPLAY_FLAGS_DOUBLESCAN;
101
102 if (ret) {
103 pr_err("%s: error reading timing properties\n",
104 of_node_full_name(np));
105 kfree(dt);
106 return NULL;
107 }
108
109 return dt;
110}
111
112
113
114
115
116struct display_timings *of_get_display_timings(struct device_node *np)
117{
118 struct device_node *timings_np;
119 struct device_node *entry;
120 struct device_node *native_mode;
121 struct display_timings *disp;
122
123 if (!np) {
124 pr_err("%s: no devicenode given\n", of_node_full_name(np));
125 return NULL;
126 }
127
128 timings_np = of_find_node_by_name(np, "display-timings");
129 if (!timings_np) {
130 pr_err("%s: could not find display-timings node\n",
131 of_node_full_name(np));
132 return NULL;
133 }
134
135 disp = kzalloc(sizeof(*disp), GFP_KERNEL);
136 if (!disp) {
137 pr_err("%s: could not allocate struct disp'\n",
138 of_node_full_name(np));
139 goto dispfail;
140 }
141
142 entry = of_parse_phandle(timings_np, "native-mode", 0);
143
144 if (!entry)
145 entry = of_get_next_child(np, NULL);
146
147 if (!entry) {
148 pr_err("%s: no timing specifications given\n",
149 of_node_full_name(np));
150 goto entryfail;
151 }
152
153 pr_debug("%s: using %s as default timing\n",
154 of_node_full_name(np), entry->name);
155
156 native_mode = entry;
157
158 disp->num_timings = of_get_child_count(timings_np);
159 if (disp->num_timings == 0) {
160
161 pr_err("%s: no timings specified\n", of_node_full_name(np));
162 goto entryfail;
163 }
164
165 disp->timings = kzalloc(sizeof(struct display_timing *) *
166 disp->num_timings, GFP_KERNEL);
167 if (!disp->timings) {
168 pr_err("%s: could not allocate timings array\n",
169 of_node_full_name(np));
170 goto entryfail;
171 }
172
173 disp->num_timings = 0;
174 disp->native_mode = 0;
175
176 for_each_child_of_node(timings_np, entry) {
177 struct display_timing *dt;
178
179 dt = of_get_display_timing(entry);
180 if (!dt) {
181
182
183
184
185 pr_err("%s: error in timing %d\n",
186 of_node_full_name(np), disp->num_timings + 1);
187 goto timingfail;
188 }
189
190 if (native_mode == entry)
191 disp->native_mode = disp->num_timings;
192
193 disp->timings[disp->num_timings] = dt;
194 disp->num_timings++;
195 }
196 of_node_put(timings_np);
197
198
199
200
201 of_node_put(native_mode);
202
203 pr_debug("%s: got %d timings. Using timing #%d as default\n",
204 of_node_full_name(np), disp->num_timings,
205 disp->native_mode + 1);
206
207 return disp;
208
209timingfail:
210 if (native_mode)
211 of_node_put(native_mode);
212 display_timings_release(disp);
213entryfail:
214 kfree(disp);
215dispfail:
216 of_node_put(timings_np);
217 return NULL;
218}
219EXPORT_SYMBOL_GPL(of_get_display_timings);
220
221
222
223
224
225int of_display_timings_exist(struct device_node *np)
226{
227 struct device_node *timings_np;
228
229 if (!np)
230 return -EINVAL;
231
232 timings_np = of_parse_phandle(np, "display-timings", 0);
233 if (!timings_np)
234 return -EINVAL;
235
236 of_node_put(timings_np);
237 return 1;
238}
239EXPORT_SYMBOL_GPL(of_display_timings_exist);
240