Commit | Line | Data |
---|---|---|
55716d26 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
cc3f414c ST |
2 | /* |
3 | * OF helpers for parsing display timings | |
4 | * | |
5 | * Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix | |
6 | * | |
7 | * based on of_videomode.c by Sascha Hauer <s.hauer@pengutronix.de> | |
cc3f414c ST |
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 | * parse_timing_property - parse timing_entry from device_node | |
17 | * @np: device_node with the property | |
18 | * @name: name of the property | |
19 | * @result: will be set to the return value | |
20 | * | |
21 | * DESCRIPTION: | |
22 | * Every display_timing can be specified with either just the typical value or | |
23 | * a range consisting of min/typ/max. This function helps handling this | |
24 | **/ | |
f5836623 | 25 | static int parse_timing_property(const struct device_node *np, const char *name, |
cc3f414c ST |
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) { | |
6d7e6533 | 33 | pr_err("%pOF: could not find property %s\n", np, name); |
cc3f414c ST |
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 { | |
6d7e6533 | 45 | pr_err("%pOF: illegal timing specification in %s\n", np, name); |
cc3f414c ST |
46 | return -EINVAL; |
47 | } | |
48 | ||
49 | return ret; | |
50 | } | |
51 | ||
52 | /** | |
ffa3fd21 | 53 | * of_parse_display_timing - parse display_timing entry from device_node |
cc3f414c ST |
54 | * @np: device_node with the properties |
55 | **/ | |
2e17c5a9 | 56 | static int of_parse_display_timing(const struct device_node *np, |
fcf7e6e5 | 57 | struct display_timing *dt) |
cc3f414c | 58 | { |
cc3f414c ST |
59 | u32 val = 0; |
60 | int ret = 0; | |
61 | ||
fcf7e6e5 | 62 | memset(dt, 0, sizeof(*dt)); |
cc3f414c ST |
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 | ||
06a33079 | 74 | dt->flags = 0; |
cc3f414c | 75 | if (!of_property_read_u32(np, "vsync-active", &val)) |
06a33079 TV |
76 | dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH : |
77 | DISPLAY_FLAGS_VSYNC_LOW; | |
cc3f414c | 78 | if (!of_property_read_u32(np, "hsync-active", &val)) |
06a33079 TV |
79 | dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH : |
80 | DISPLAY_FLAGS_HSYNC_LOW; | |
cc3f414c | 81 | if (!of_property_read_u32(np, "de-active", &val)) |
06a33079 | 82 | dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH : |
cc3f414c ST |
83 | DISPLAY_FLAGS_DE_LOW; |
84 | if (!of_property_read_u32(np, "pixelclk-active", &val)) | |
06a33079 | 85 | dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE : |
cc3f414c ST |
86 | DISPLAY_FLAGS_PIXDATA_NEGEDGE; |
87 | ||
bd9642b9 PU |
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 | ||
cc3f414c | 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) { | |
6d7e6533 | 105 | pr_err("%pOF: error reading timing properties\n", np); |
fcf7e6e5 | 106 | return -EINVAL; |
cc3f414c ST |
107 | } |
108 | ||
fcf7e6e5 | 109 | return 0; |
cc3f414c ST |
110 | } |
111 | ||
ffa3fd21 TV |
112 | /** |
113 | * of_get_display_timing - parse a display_timing entry | |
114 | * @np: device_node with the timing subnode | |
115 | * @name: name of the timing node | |
116 | * @dt: display_timing struct to fill | |
117 | **/ | |
f5a000c9 | 118 | int of_get_display_timing(const struct device_node *np, const char *name, |
ffa3fd21 TV |
119 | struct display_timing *dt) |
120 | { | |
121 | struct device_node *timing_np; | |
4faba50e | 122 | int ret; |
ffa3fd21 | 123 | |
dc42715f | 124 | if (!np) |
ffa3fd21 | 125 | return -EINVAL; |
ffa3fd21 | 126 | |
60119a1d | 127 | timing_np = of_get_child_by_name(np, name); |
892e8ba3 | 128 | if (!timing_np) |
ffa3fd21 | 129 | return -ENOENT; |
ffa3fd21 | 130 | |
4faba50e DA |
131 | ret = of_parse_display_timing(timing_np, dt); |
132 | ||
133 | of_node_put(timing_np); | |
134 | ||
135 | return ret; | |
ffa3fd21 TV |
136 | } |
137 | EXPORT_SYMBOL_GPL(of_get_display_timing); | |
138 | ||
cc3f414c ST |
139 | /** |
140 | * of_get_display_timings - parse all display_timing entries from a device_node | |
141 | * @np: device_node with the subnodes | |
142 | **/ | |
f5a000c9 | 143 | struct display_timings *of_get_display_timings(const struct device_node *np) |
cc3f414c ST |
144 | { |
145 | struct device_node *timings_np; | |
146 | struct device_node *entry; | |
147 | struct device_node *native_mode; | |
148 | struct display_timings *disp; | |
149 | ||
dc42715f | 150 | if (!np) |
cc3f414c | 151 | return NULL; |
cc3f414c | 152 | |
60119a1d | 153 | timings_np = of_get_child_by_name(np, "display-timings"); |
cc3f414c | 154 | if (!timings_np) { |
6d7e6533 | 155 | pr_err("%pOF: could not find display-timings node\n", np); |
cc3f414c ST |
156 | return NULL; |
157 | } | |
158 | ||
159 | disp = kzalloc(sizeof(*disp), GFP_KERNEL); | |
160 | if (!disp) { | |
6d7e6533 | 161 | pr_err("%pOF: could not allocate struct disp'\n", np); |
cc3f414c ST |
162 | goto dispfail; |
163 | } | |
164 | ||
165 | entry = of_parse_phandle(timings_np, "native-mode", 0); | |
166 | /* assume first child as native mode if none provided */ | |
167 | if (!entry) | |
80c68c1e | 168 | entry = of_get_next_child(timings_np, NULL); |
cc3f414c ST |
169 | /* if there is no child, it is useless to go on */ |
170 | if (!entry) { | |
6d7e6533 | 171 | pr_err("%pOF: no timing specifications given\n", np); |
cc3f414c ST |
172 | goto entryfail; |
173 | } | |
174 | ||
5c63e407 | 175 | pr_debug("%pOF: using %pOFn as default timing\n", np, entry); |
cc3f414c ST |
176 | |
177 | native_mode = entry; | |
178 | ||
179 | disp->num_timings = of_get_child_count(timings_np); | |
180 | if (disp->num_timings == 0) { | |
181 | /* should never happen, as entry was already found above */ | |
6d7e6533 | 182 | pr_err("%pOF: no timings specified\n", np); |
cc3f414c ST |
183 | goto entryfail; |
184 | } | |
185 | ||
6396bb22 KC |
186 | disp->timings = kcalloc(disp->num_timings, |
187 | sizeof(struct display_timing *), | |
188 | GFP_KERNEL); | |
cc3f414c | 189 | if (!disp->timings) { |
6d7e6533 | 190 | pr_err("%pOF: could not allocate timings array\n", np); |
cc3f414c ST |
191 | goto entryfail; |
192 | } | |
193 | ||
194 | disp->num_timings = 0; | |
195 | disp->native_mode = 0; | |
196 | ||
197 | for_each_child_of_node(timings_np, entry) { | |
198 | struct display_timing *dt; | |
fcf7e6e5 | 199 | int r; |
cc3f414c | 200 | |
fcf7e6e5 | 201 | dt = kzalloc(sizeof(*dt), GFP_KERNEL); |
cc3f414c | 202 | if (!dt) { |
6d7e6533 RH |
203 | pr_err("%pOF: could not allocate display_timing struct\n", |
204 | np); | |
fcf7e6e5 TV |
205 | goto timingfail; |
206 | } | |
207 | ||
ffa3fd21 | 208 | r = of_parse_display_timing(entry, dt); |
fcf7e6e5 | 209 | if (r) { |
cc3f414c ST |
210 | /* |
211 | * to not encourage wrong devicetrees, fail in case of | |
212 | * an error | |
213 | */ | |
6d7e6533 RH |
214 | pr_err("%pOF: error in timing %d\n", |
215 | np, disp->num_timings + 1); | |
d663baba | 216 | kfree(dt); |
cc3f414c ST |
217 | goto timingfail; |
218 | } | |
219 | ||
220 | if (native_mode == entry) | |
221 | disp->native_mode = disp->num_timings; | |
222 | ||
223 | disp->timings[disp->num_timings] = dt; | |
224 | disp->num_timings++; | |
225 | } | |
226 | of_node_put(timings_np); | |
227 | /* | |
228 | * native_mode points to the device_node returned by of_parse_phandle | |
229 | * therefore call of_node_put on it | |
230 | */ | |
231 | of_node_put(native_mode); | |
232 | ||
6d7e6533 RH |
233 | pr_debug("%pOF: got %d timings. Using timing #%d as default\n", |
234 | np, disp->num_timings, | |
cc3f414c ST |
235 | disp->native_mode + 1); |
236 | ||
237 | return disp; | |
238 | ||
239 | timingfail: | |
68ecfe2f | 240 | of_node_put(native_mode); |
cc3f414c | 241 | display_timings_release(disp); |
62795a0d | 242 | disp = NULL; |
cc3f414c ST |
243 | entryfail: |
244 | kfree(disp); | |
245 | dispfail: | |
246 | of_node_put(timings_np); | |
247 | return NULL; | |
248 | } | |
249 | EXPORT_SYMBOL_GPL(of_get_display_timings); |