Commit | Line | Data |
---|---|---|
cc3f414c ST |
1 | /* |
2 | * OF helpers for parsing display timings | |
3 | * | |
4 | * Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix | |
5 | * | |
6 | * based on of_videomode.c by Sascha Hauer <s.hauer@pengutronix.de> | |
7 | * | |
8 | * This file is released under the GPLv2 | |
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 | * parse_timing_property - parse timing_entry from device_node | |
18 | * @np: device_node with the property | |
19 | * @name: name of the property | |
20 | * @result: will be set to the return value | |
21 | * | |
22 | * DESCRIPTION: | |
23 | * Every display_timing can be specified with either just the typical value or | |
24 | * a range consisting of min/typ/max. This function helps handling this | |
25 | **/ | |
f5836623 | 26 | static int parse_timing_property(const struct device_node *np, const char *name, |
cc3f414c ST |
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 | * of_get_display_timing - parse display_timing entry from device_node | |
57 | * @np: device_node with the properties | |
58 | **/ | |
f5836623 ST |
59 | static struct display_timing *of_get_display_timing(const struct device_node |
60 | *np) | |
cc3f414c ST |
61 | { |
62 | struct display_timing *dt; | |
63 | u32 val = 0; | |
64 | int ret = 0; | |
65 | ||
66 | dt = kzalloc(sizeof(*dt), GFP_KERNEL); | |
67 | if (!dt) { | |
68 | pr_err("%s: could not allocate display_timing struct\n", | |
69 | of_node_full_name(np)); | |
70 | return NULL; | |
71 | } | |
72 | ||
73 | ret |= parse_timing_property(np, "hback-porch", &dt->hback_porch); | |
74 | ret |= parse_timing_property(np, "hfront-porch", &dt->hfront_porch); | |
75 | ret |= parse_timing_property(np, "hactive", &dt->hactive); | |
76 | ret |= parse_timing_property(np, "hsync-len", &dt->hsync_len); | |
77 | ret |= parse_timing_property(np, "vback-porch", &dt->vback_porch); | |
78 | ret |= parse_timing_property(np, "vfront-porch", &dt->vfront_porch); | |
79 | ret |= parse_timing_property(np, "vactive", &dt->vactive); | |
80 | ret |= parse_timing_property(np, "vsync-len", &dt->vsync_len); | |
81 | ret |= parse_timing_property(np, "clock-frequency", &dt->pixelclock); | |
82 | ||
06a33079 | 83 | dt->flags = 0; |
cc3f414c | 84 | if (!of_property_read_u32(np, "vsync-active", &val)) |
06a33079 TV |
85 | dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH : |
86 | DISPLAY_FLAGS_VSYNC_LOW; | |
cc3f414c | 87 | if (!of_property_read_u32(np, "hsync-active", &val)) |
06a33079 TV |
88 | dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH : |
89 | DISPLAY_FLAGS_HSYNC_LOW; | |
cc3f414c | 90 | if (!of_property_read_u32(np, "de-active", &val)) |
06a33079 | 91 | dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH : |
cc3f414c ST |
92 | DISPLAY_FLAGS_DE_LOW; |
93 | if (!of_property_read_u32(np, "pixelclk-active", &val)) | |
06a33079 | 94 | dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE : |
cc3f414c ST |
95 | DISPLAY_FLAGS_PIXDATA_NEGEDGE; |
96 | ||
97 | if (of_property_read_bool(np, "interlaced")) | |
06a33079 | 98 | dt->flags |= DISPLAY_FLAGS_INTERLACED; |
cc3f414c | 99 | if (of_property_read_bool(np, "doublescan")) |
06a33079 | 100 | dt->flags |= DISPLAY_FLAGS_DOUBLESCAN; |
2d178a4a ST |
101 | if (of_property_read_bool(np, "doubleclk")) |
102 | dt->flags |= DISPLAY_FLAGS_DOUBLECLK; | |
cc3f414c ST |
103 | |
104 | if (ret) { | |
105 | pr_err("%s: error reading timing properties\n", | |
106 | of_node_full_name(np)); | |
107 | kfree(dt); | |
108 | return NULL; | |
109 | } | |
110 | ||
111 | return dt; | |
112 | } | |
113 | ||
114 | /** | |
115 | * of_get_display_timings - parse all display_timing entries from a device_node | |
116 | * @np: device_node with the subnodes | |
117 | **/ | |
118 | struct display_timings *of_get_display_timings(struct device_node *np) | |
119 | { | |
120 | struct device_node *timings_np; | |
121 | struct device_node *entry; | |
122 | struct device_node *native_mode; | |
123 | struct display_timings *disp; | |
124 | ||
125 | if (!np) { | |
126 | pr_err("%s: no devicenode given\n", of_node_full_name(np)); | |
127 | return NULL; | |
128 | } | |
129 | ||
130 | timings_np = of_find_node_by_name(np, "display-timings"); | |
131 | if (!timings_np) { | |
132 | pr_err("%s: could not find display-timings node\n", | |
133 | of_node_full_name(np)); | |
134 | return NULL; | |
135 | } | |
136 | ||
137 | disp = kzalloc(sizeof(*disp), GFP_KERNEL); | |
138 | if (!disp) { | |
139 | pr_err("%s: could not allocate struct disp'\n", | |
140 | of_node_full_name(np)); | |
141 | goto dispfail; | |
142 | } | |
143 | ||
144 | entry = of_parse_phandle(timings_np, "native-mode", 0); | |
145 | /* assume first child as native mode if none provided */ | |
146 | if (!entry) | |
147 | entry = of_get_next_child(np, NULL); | |
148 | /* if there is no child, it is useless to go on */ | |
149 | if (!entry) { | |
150 | pr_err("%s: no timing specifications given\n", | |
151 | of_node_full_name(np)); | |
152 | goto entryfail; | |
153 | } | |
154 | ||
155 | pr_debug("%s: using %s as default timing\n", | |
156 | of_node_full_name(np), entry->name); | |
157 | ||
158 | native_mode = entry; | |
159 | ||
160 | disp->num_timings = of_get_child_count(timings_np); | |
161 | if (disp->num_timings == 0) { | |
162 | /* should never happen, as entry was already found above */ | |
163 | pr_err("%s: no timings specified\n", of_node_full_name(np)); | |
164 | goto entryfail; | |
165 | } | |
166 | ||
167 | disp->timings = kzalloc(sizeof(struct display_timing *) * | |
168 | disp->num_timings, GFP_KERNEL); | |
169 | if (!disp->timings) { | |
170 | pr_err("%s: could not allocate timings array\n", | |
171 | of_node_full_name(np)); | |
172 | goto entryfail; | |
173 | } | |
174 | ||
175 | disp->num_timings = 0; | |
176 | disp->native_mode = 0; | |
177 | ||
178 | for_each_child_of_node(timings_np, entry) { | |
179 | struct display_timing *dt; | |
180 | ||
181 | dt = of_get_display_timing(entry); | |
182 | if (!dt) { | |
183 | /* | |
184 | * to not encourage wrong devicetrees, fail in case of | |
185 | * an error | |
186 | */ | |
187 | pr_err("%s: error in timing %d\n", | |
188 | of_node_full_name(np), disp->num_timings + 1); | |
189 | goto timingfail; | |
190 | } | |
191 | ||
192 | if (native_mode == entry) | |
193 | disp->native_mode = disp->num_timings; | |
194 | ||
195 | disp->timings[disp->num_timings] = dt; | |
196 | disp->num_timings++; | |
197 | } | |
198 | of_node_put(timings_np); | |
199 | /* | |
200 | * native_mode points to the device_node returned by of_parse_phandle | |
201 | * therefore call of_node_put on it | |
202 | */ | |
203 | of_node_put(native_mode); | |
204 | ||
205 | pr_debug("%s: got %d timings. Using timing #%d as default\n", | |
206 | of_node_full_name(np), disp->num_timings, | |
207 | disp->native_mode + 1); | |
208 | ||
209 | return disp; | |
210 | ||
211 | timingfail: | |
212 | if (native_mode) | |
213 | of_node_put(native_mode); | |
214 | display_timings_release(disp); | |
215 | entryfail: | |
216 | kfree(disp); | |
217 | dispfail: | |
218 | of_node_put(timings_np); | |
219 | return NULL; | |
220 | } | |
221 | EXPORT_SYMBOL_GPL(of_get_display_timings); | |
222 | ||
223 | /** | |
224 | * of_display_timings_exist - check if a display-timings node is provided | |
225 | * @np: device_node with the timing | |
226 | **/ | |
227 | int of_display_timings_exist(struct device_node *np) | |
228 | { | |
229 | struct device_node *timings_np; | |
230 | ||
231 | if (!np) | |
232 | return -EINVAL; | |
233 | ||
234 | timings_np = of_parse_phandle(np, "display-timings", 0); | |
235 | if (!timings_np) | |
236 | return -EINVAL; | |
237 | ||
238 | of_node_put(timings_np); | |
239 | return 1; | |
240 | } | |
241 | EXPORT_SYMBOL_GPL(of_display_timings_exist); |