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