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(const 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 int of_parse_display_timing(const struct device_node *np,
60 struct display_timing *dt)
61{
62 u32 val = 0;
63 int ret = 0;
64
65 memset(dt, 0, sizeof(*dt));
66
67 ret |= parse_timing_property(np, "hback-porch", &dt->hback_porch);
68 ret |= parse_timing_property(np, "hfront-porch", &dt->hfront_porch);
69 ret |= parse_timing_property(np, "hactive", &dt->hactive);
70 ret |= parse_timing_property(np, "hsync-len", &dt->hsync_len);
71 ret |= parse_timing_property(np, "vback-porch", &dt->vback_porch);
72 ret |= parse_timing_property(np, "vfront-porch", &dt->vfront_porch);
73 ret |= parse_timing_property(np, "vactive", &dt->vactive);
74 ret |= parse_timing_property(np, "vsync-len", &dt->vsync_len);
75 ret |= parse_timing_property(np, "clock-frequency", &dt->pixelclock);
76
77 dt->flags = 0;
78 if (!of_property_read_u32(np, "vsync-active", &val))
79 dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
80 DISPLAY_FLAGS_VSYNC_LOW;
81 if (!of_property_read_u32(np, "hsync-active", &val))
82 dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
83 DISPLAY_FLAGS_HSYNC_LOW;
84 if (!of_property_read_u32(np, "de-active", &val))
85 dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
86 DISPLAY_FLAGS_DE_LOW;
87 if (!of_property_read_u32(np, "pixelclk-active", &val))
88 dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
89 DISPLAY_FLAGS_PIXDATA_NEGEDGE;
90
91 if (of_property_read_bool(np, "interlaced"))
92 dt->flags |= DISPLAY_FLAGS_INTERLACED;
93 if (of_property_read_bool(np, "doublescan"))
94 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
95 if (of_property_read_bool(np, "doubleclk"))
96 dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
97
98 if (ret) {
99 pr_err("%s: error reading timing properties\n",
100 of_node_full_name(np));
101 return -EINVAL;
102 }
103
104 return 0;
105}
106
107
108
109
110
111
112
113int of_get_display_timing(struct device_node *np, const char *name,
114 struct display_timing *dt)
115{
116 struct device_node *timing_np;
117
118 if (!np)
119 return -EINVAL;
120
121 timing_np = of_get_child_by_name(np, name);
122 if (!timing_np) {
123 pr_err("%s: could not find node '%s'\n",
124 of_node_full_name(np), name);
125 return -ENOENT;
126 }
127
128 return of_parse_display_timing(timing_np, dt);
129}
130EXPORT_SYMBOL_GPL(of_get_display_timing);
131
132
133
134
135
136struct display_timings *of_get_display_timings(struct device_node *np)
137{
138 struct device_node *timings_np;
139 struct device_node *entry;
140 struct device_node *native_mode;
141 struct display_timings *disp;
142
143 if (!np)
144 return NULL;
145
146 timings_np = of_get_child_by_name(np, "display-timings");
147 if (!timings_np) {
148 pr_err("%s: could not find display-timings node\n",
149 of_node_full_name(np));
150 return NULL;
151 }
152
153 disp = kzalloc(sizeof(*disp), GFP_KERNEL);
154 if (!disp) {
155 pr_err("%s: could not allocate struct disp'\n",
156 of_node_full_name(np));
157 goto dispfail;
158 }
159
160 entry = of_parse_phandle(timings_np, "native-mode", 0);
161
162 if (!entry)
163 entry = of_get_next_child(timings_np, NULL);
164
165 if (!entry) {
166 pr_err("%s: no timing specifications given\n",
167 of_node_full_name(np));
168 goto entryfail;
169 }
170
171 pr_debug("%s: using %s as default timing\n",
172 of_node_full_name(np), entry->name);
173
174 native_mode = entry;
175
176 disp->num_timings = of_get_child_count(timings_np);
177 if (disp->num_timings == 0) {
178
179 pr_err("%s: no timings specified\n", of_node_full_name(np));
180 goto entryfail;
181 }
182
183 disp->timings = kzalloc(sizeof(struct display_timing *) *
184 disp->num_timings, GFP_KERNEL);
185 if (!disp->timings) {
186 pr_err("%s: could not allocate timings array\n",
187 of_node_full_name(np));
188 goto entryfail;
189 }
190
191 disp->num_timings = 0;
192 disp->native_mode = 0;
193
194 for_each_child_of_node(timings_np, entry) {
195 struct display_timing *dt;
196 int r;
197
198 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
199 if (!dt) {
200 pr_err("%s: could not allocate display_timing struct\n",
201 of_node_full_name(np));
202 goto timingfail;
203 }
204
205 r = of_parse_display_timing(entry, dt);
206 if (r) {
207
208
209
210
211 pr_err("%s: error in timing %d\n",
212 of_node_full_name(np), disp->num_timings + 1);
213 goto timingfail;
214 }
215
216 if (native_mode == entry)
217 disp->native_mode = disp->num_timings;
218
219 disp->timings[disp->num_timings] = dt;
220 disp->num_timings++;
221 }
222 of_node_put(timings_np);
223
224
225
226
227 of_node_put(native_mode);
228
229 pr_debug("%s: got %d timings. Using timing #%d as default\n",
230 of_node_full_name(np), disp->num_timings,
231 disp->native_mode + 1);
232
233 return disp;
234
235timingfail:
236 if (native_mode)
237 of_node_put(native_mode);
238 display_timings_release(disp);
239entryfail:
240 kfree(disp);
241dispfail:
242 of_node_put(timings_np);
243 return NULL;
244}
245EXPORT_SYMBOL_GPL(of_get_display_timings);
246
247
248
249
250
251int of_display_timings_exist(struct device_node *np)
252{
253 struct device_node *timings_np;
254
255 if (!np)
256 return -EINVAL;
257
258 timings_np = of_parse_phandle(np, "display-timings", 0);
259 if (!timings_np)
260 return -EINVAL;
261
262 of_node_put(timings_np);
263 return 1;
264}
265EXPORT_SYMBOL_GPL(of_display_timings_exist);
266