Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
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>
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 : : **/
25 : 0 : static 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 : 0 : prop = of_find_property(np, name, &length);
32 [ # # ]: 0 : if (!prop) {
33 : 0 : pr_err("%pOF: could not find property %s\n", np, name);
34 : 0 : return -EINVAL;
35 : : }
36 : :
37 : 0 : cells = length / sizeof(u32);
38 [ # # ]: 0 : if (cells == 1) {
39 : 0 : ret = of_property_read_u32(np, name, &result->typ);
40 : 0 : result->min = result->typ;
41 : 0 : result->max = result->typ;
42 [ # # ]: 0 : } else if (cells == 3) {
43 : 0 : ret = of_property_read_u32_array(np, name, &result->min, cells);
44 : : } else {
45 : 0 : pr_err("%pOF: illegal timing specification in %s\n", np, name);
46 : 0 : return -EINVAL;
47 : : }
48 : :
49 : 0 : return ret;
50 : : }
51 : :
52 : : /**
53 : : * of_parse_display_timing - parse display_timing entry from device_node
54 : : * @np: device_node with the properties
55 : : **/
56 : 0 : static int of_parse_display_timing(const struct device_node *np,
57 : : struct display_timing *dt)
58 : : {
59 : 0 : u32 val = 0;
60 : : int ret = 0;
61 : :
62 : 0 : memset(dt, 0, sizeof(*dt));
63 : :
64 : 0 : ret |= parse_timing_property(np, "hback-porch", &dt->hback_porch);
65 : 0 : ret |= parse_timing_property(np, "hfront-porch", &dt->hfront_porch);
66 : 0 : ret |= parse_timing_property(np, "hactive", &dt->hactive);
67 : 0 : ret |= parse_timing_property(np, "hsync-len", &dt->hsync_len);
68 : 0 : ret |= parse_timing_property(np, "vback-porch", &dt->vback_porch);
69 : 0 : ret |= parse_timing_property(np, "vfront-porch", &dt->vfront_porch);
70 : 0 : ret |= parse_timing_property(np, "vactive", &dt->vactive);
71 : 0 : ret |= parse_timing_property(np, "vsync-len", &dt->vsync_len);
72 : 0 : ret |= parse_timing_property(np, "clock-frequency", &dt->pixelclock);
73 : :
74 : 0 : dt->flags = 0;
75 [ # # ]: 0 : if (!of_property_read_u32(np, "vsync-active", &val))
76 [ # # ]: 0 : dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
77 : : DISPLAY_FLAGS_VSYNC_LOW;
78 [ # # ]: 0 : if (!of_property_read_u32(np, "hsync-active", &val))
79 [ # # ]: 0 : dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
80 : : DISPLAY_FLAGS_HSYNC_LOW;
81 [ # # ]: 0 : if (!of_property_read_u32(np, "de-active", &val))
82 [ # # ]: 0 : dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
83 : : DISPLAY_FLAGS_DE_LOW;
84 [ # # ]: 0 : if (!of_property_read_u32(np, "pixelclk-active", &val))
85 [ # # ]: 0 : dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
86 : : DISPLAY_FLAGS_PIXDATA_NEGEDGE;
87 : :
88 [ # # ]: 0 : if (!of_property_read_u32(np, "syncclk-active", &val))
89 [ # # ]: 0 : dt->flags |= val ? DISPLAY_FLAGS_SYNC_POSEDGE :
90 : : DISPLAY_FLAGS_SYNC_NEGEDGE;
91 [ # # ]: 0 : else if (dt->flags & (DISPLAY_FLAGS_PIXDATA_POSEDGE |
92 : : DISPLAY_FLAGS_PIXDATA_NEGEDGE))
93 [ # # ]: 0 : dt->flags |= dt->flags & DISPLAY_FLAGS_PIXDATA_POSEDGE ?
94 : : DISPLAY_FLAGS_SYNC_POSEDGE :
95 : : DISPLAY_FLAGS_SYNC_NEGEDGE;
96 : :
97 [ # # ]: 0 : if (of_property_read_bool(np, "interlaced"))
98 : 0 : dt->flags |= DISPLAY_FLAGS_INTERLACED;
99 [ # # ]: 0 : if (of_property_read_bool(np, "doublescan"))
100 : 0 : dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
101 [ # # ]: 0 : if (of_property_read_bool(np, "doubleclk"))
102 : 0 : dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
103 : :
104 [ # # ]: 0 : if (ret) {
105 : 0 : pr_err("%pOF: error reading timing properties\n", np);
106 : 0 : return -EINVAL;
107 : : }
108 : :
109 : : return 0;
110 : : }
111 : :
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 : : **/
118 : 0 : int 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 : : int ret;
123 : :
124 [ # # ]: 0 : if (!np)
125 : : return -EINVAL;
126 : :
127 : 0 : timing_np = of_get_child_by_name(np, name);
128 [ # # ]: 0 : if (!timing_np)
129 : : return -ENOENT;
130 : :
131 : 0 : ret = of_parse_display_timing(timing_np, dt);
132 : :
133 : 0 : of_node_put(timing_np);
134 : :
135 : 0 : return ret;
136 : : }
137 : : EXPORT_SYMBOL_GPL(of_get_display_timing);
138 : :
139 : : /**
140 : : * of_get_display_timings - parse all display_timing entries from a device_node
141 : : * @np: device_node with the subnodes
142 : : **/
143 : 0 : struct display_timings *of_get_display_timings(const struct device_node *np)
144 : : {
145 : : struct device_node *timings_np;
146 : : struct device_node *entry;
147 : : struct device_node *native_mode;
148 : : struct display_timings *disp;
149 : :
150 [ # # ]: 0 : if (!np)
151 : : return NULL;
152 : :
153 : 0 : timings_np = of_get_child_by_name(np, "display-timings");
154 [ # # ]: 0 : if (!timings_np) {
155 : 0 : pr_err("%pOF: could not find display-timings node\n", np);
156 : 0 : return NULL;
157 : : }
158 : :
159 : 0 : disp = kzalloc(sizeof(*disp), GFP_KERNEL);
160 [ # # ]: 0 : if (!disp) {
161 : 0 : pr_err("%pOF: could not allocate struct disp'\n", np);
162 : 0 : goto dispfail;
163 : : }
164 : :
165 : 0 : entry = of_parse_phandle(timings_np, "native-mode", 0);
166 : : /* assume first child as native mode if none provided */
167 [ # # ]: 0 : if (!entry)
168 : 0 : entry = of_get_next_child(timings_np, NULL);
169 : : /* if there is no child, it is useless to go on */
170 [ # # ]: 0 : if (!entry) {
171 : 0 : pr_err("%pOF: no timing specifications given\n", np);
172 : 0 : goto entryfail;
173 : : }
174 : :
175 : : pr_debug("%pOF: using %pOFn as default timing\n", np, entry);
176 : :
177 : : native_mode = entry;
178 : :
179 : 0 : disp->num_timings = of_get_child_count(timings_np);
180 [ # # ]: 0 : if (disp->num_timings == 0) {
181 : : /* should never happen, as entry was already found above */
182 : 0 : pr_err("%pOF: no timings specified\n", np);
183 : 0 : goto entryfail;
184 : : }
185 : :
186 : 0 : disp->timings = kcalloc(disp->num_timings,
187 : : sizeof(struct display_timing *),
188 : : GFP_KERNEL);
189 [ # # ]: 0 : if (!disp->timings) {
190 : 0 : pr_err("%pOF: could not allocate timings array\n", np);
191 : 0 : goto entryfail;
192 : : }
193 : :
194 : 0 : disp->num_timings = 0;
195 : 0 : disp->native_mode = 0;
196 : :
197 [ # # ]: 0 : for_each_child_of_node(timings_np, entry) {
198 : : struct display_timing *dt;
199 : : int r;
200 : :
201 : 0 : dt = kzalloc(sizeof(*dt), GFP_KERNEL);
202 [ # # ]: 0 : if (!dt) {
203 : 0 : pr_err("%pOF: could not allocate display_timing struct\n",
204 : : np);
205 : 0 : goto timingfail;
206 : : }
207 : :
208 : 0 : r = of_parse_display_timing(entry, dt);
209 [ # # ]: 0 : if (r) {
210 : : /*
211 : : * to not encourage wrong devicetrees, fail in case of
212 : : * an error
213 : : */
214 : 0 : pr_err("%pOF: error in timing %d\n",
215 : : np, disp->num_timings + 1);
216 : 0 : kfree(dt);
217 : 0 : goto timingfail;
218 : : }
219 : :
220 [ # # ]: 0 : if (native_mode == entry)
221 : 0 : disp->native_mode = disp->num_timings;
222 : :
223 : 0 : disp->timings[disp->num_timings] = dt;
224 : 0 : disp->num_timings++;
225 : : }
226 : 0 : 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 : 0 : of_node_put(native_mode);
232 : :
233 : : pr_debug("%pOF: got %d timings. Using timing #%d as default\n",
234 : : np, disp->num_timings,
235 : : disp->native_mode + 1);
236 : :
237 : 0 : return disp;
238 : :
239 : : timingfail:
240 : 0 : of_node_put(native_mode);
241 : 0 : display_timings_release(disp);
242 : : disp = NULL;
243 : : entryfail:
244 : 0 : kfree(disp);
245 : : dispfail:
246 : 0 : of_node_put(timings_np);
247 : 0 : return NULL;
248 : : }
249 : : EXPORT_SYMBOL_GPL(of_get_display_timings);
|
