Loading...
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 **/
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 * of_parse_display_timing - parse display_timing entry from device_node
54 * @np: device_node with the properties
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 * 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 **/
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 int ret;
123
124 if (!np)
125 return -EINVAL;
126
127 timing_np = of_get_child_by_name(np, name);
128 if (!timing_np)
129 return -ENOENT;
130
131 ret = of_parse_display_timing(timing_np, dt);
132
133 of_node_put(timing_np);
134
135 return ret;
136}
137EXPORT_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 **/
143struct 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 if (!np)
151 return NULL;
152
153 timings_np = of_get_child_by_name(np, "display-timings");
154 if (!timings_np) {
155 pr_err("%pOF: could not find display-timings node\n", np);
156 return NULL;
157 }
158
159 disp = kzalloc(sizeof(*disp), GFP_KERNEL);
160 if (!disp) {
161 pr_err("%pOF: could not allocate struct disp'\n", np);
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)
168 entry = of_get_next_child(timings_np, NULL);
169 /* if there is no child, it is useless to go on */
170 if (!entry) {
171 pr_err("%pOF: no timing specifications given\n", np);
172 goto entryfail;
173 }
174
175 pr_debug("%pOF: using %pOFn as default timing\n", np, entry);
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 */
182 pr_err("%pOF: no timings specified\n", np);
183 goto entryfail;
184 }
185
186 disp->timings = kcalloc(disp->num_timings,
187 sizeof(struct display_timing *),
188 GFP_KERNEL);
189 if (!disp->timings) {
190 pr_err("%pOF: could not allocate timings array\n", np);
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;
199 int r;
200
201 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
202 if (!dt) {
203 pr_err("%pOF: could not allocate display_timing struct\n",
204 np);
205 goto timingfail;
206 }
207
208 r = of_parse_display_timing(entry, dt);
209 if (r) {
210 /*
211 * to not encourage wrong devicetrees, fail in case of
212 * an error
213 */
214 pr_err("%pOF: error in timing %d\n",
215 np, disp->num_timings + 1);
216 kfree(dt);
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
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 return disp;
238
239timingfail:
240 of_node_put(native_mode);
241 display_timings_release(disp);
242 disp = NULL;
243entryfail:
244 kfree(disp);
245dispfail:
246 of_node_put(timings_np);
247 return NULL;
248}
249EXPORT_SYMBOL_GPL(of_get_display_timings);
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 **/
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 * of_parse_display_timing - parse display_timing entry from device_node
57 * @np: device_node with the properties
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_u32(np, "syncclk-active", &val))
92 dt->flags |= val ? DISPLAY_FLAGS_SYNC_POSEDGE :
93 DISPLAY_FLAGS_SYNC_NEGEDGE;
94 else if (dt->flags & (DISPLAY_FLAGS_PIXDATA_POSEDGE |
95 DISPLAY_FLAGS_PIXDATA_NEGEDGE))
96 dt->flags |= dt->flags & DISPLAY_FLAGS_PIXDATA_POSEDGE ?
97 DISPLAY_FLAGS_SYNC_POSEDGE :
98 DISPLAY_FLAGS_SYNC_NEGEDGE;
99
100 if (of_property_read_bool(np, "interlaced"))
101 dt->flags |= DISPLAY_FLAGS_INTERLACED;
102 if (of_property_read_bool(np, "doublescan"))
103 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
104 if (of_property_read_bool(np, "doubleclk"))
105 dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
106
107 if (ret) {
108 pr_err("%s: error reading timing properties\n",
109 of_node_full_name(np));
110 return -EINVAL;
111 }
112
113 return 0;
114}
115
116/**
117 * of_get_display_timing - parse a display_timing entry
118 * @np: device_node with the timing subnode
119 * @name: name of the timing node
120 * @dt: display_timing struct to fill
121 **/
122int of_get_display_timing(const struct device_node *np, const char *name,
123 struct display_timing *dt)
124{
125 struct device_node *timing_np;
126
127 if (!np)
128 return -EINVAL;
129
130 timing_np = of_get_child_by_name(np, name);
131 if (!timing_np) {
132 pr_err("%s: could not find node '%s'\n",
133 of_node_full_name(np), name);
134 return -ENOENT;
135 }
136
137 return of_parse_display_timing(timing_np, dt);
138}
139EXPORT_SYMBOL_GPL(of_get_display_timing);
140
141/**
142 * of_get_display_timings - parse all display_timing entries from a device_node
143 * @np: device_node with the subnodes
144 **/
145struct display_timings *of_get_display_timings(const struct device_node *np)
146{
147 struct device_node *timings_np;
148 struct device_node *entry;
149 struct device_node *native_mode;
150 struct display_timings *disp;
151
152 if (!np)
153 return NULL;
154
155 timings_np = of_get_child_by_name(np, "display-timings");
156 if (!timings_np) {
157 pr_err("%s: could not find display-timings node\n",
158 of_node_full_name(np));
159 return NULL;
160 }
161
162 disp = kzalloc(sizeof(*disp), GFP_KERNEL);
163 if (!disp) {
164 pr_err("%s: could not allocate struct disp'\n",
165 of_node_full_name(np));
166 goto dispfail;
167 }
168
169 entry = of_parse_phandle(timings_np, "native-mode", 0);
170 /* assume first child as native mode if none provided */
171 if (!entry)
172 entry = of_get_next_child(timings_np, NULL);
173 /* if there is no child, it is useless to go on */
174 if (!entry) {
175 pr_err("%s: no timing specifications given\n",
176 of_node_full_name(np));
177 goto entryfail;
178 }
179
180 pr_debug("%s: using %s as default timing\n",
181 of_node_full_name(np), entry->name);
182
183 native_mode = entry;
184
185 disp->num_timings = of_get_child_count(timings_np);
186 if (disp->num_timings == 0) {
187 /* should never happen, as entry was already found above */
188 pr_err("%s: no timings specified\n", of_node_full_name(np));
189 goto entryfail;
190 }
191
192 disp->timings = kzalloc(sizeof(struct display_timing *) *
193 disp->num_timings, GFP_KERNEL);
194 if (!disp->timings) {
195 pr_err("%s: could not allocate timings array\n",
196 of_node_full_name(np));
197 goto entryfail;
198 }
199
200 disp->num_timings = 0;
201 disp->native_mode = 0;
202
203 for_each_child_of_node(timings_np, entry) {
204 struct display_timing *dt;
205 int r;
206
207 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
208 if (!dt) {
209 pr_err("%s: could not allocate display_timing struct\n",
210 of_node_full_name(np));
211 goto timingfail;
212 }
213
214 r = of_parse_display_timing(entry, dt);
215 if (r) {
216 /*
217 * to not encourage wrong devicetrees, fail in case of
218 * an error
219 */
220 pr_err("%s: error in timing %d\n",
221 of_node_full_name(np), disp->num_timings + 1);
222 kfree(dt);
223 goto timingfail;
224 }
225
226 if (native_mode == entry)
227 disp->native_mode = disp->num_timings;
228
229 disp->timings[disp->num_timings] = dt;
230 disp->num_timings++;
231 }
232 of_node_put(timings_np);
233 /*
234 * native_mode points to the device_node returned by of_parse_phandle
235 * therefore call of_node_put on it
236 */
237 of_node_put(native_mode);
238
239 pr_debug("%s: got %d timings. Using timing #%d as default\n",
240 of_node_full_name(np), disp->num_timings,
241 disp->native_mode + 1);
242
243 return disp;
244
245timingfail:
246 of_node_put(native_mode);
247 display_timings_release(disp);
248 disp = NULL;
249entryfail:
250 kfree(disp);
251dispfail:
252 of_node_put(timings_np);
253 return NULL;
254}
255EXPORT_SYMBOL_GPL(of_get_display_timings);
256
257/**
258 * of_display_timings_exist - check if a display-timings node is provided
259 * @np: device_node with the timing
260 **/
261int of_display_timings_exist(const struct device_node *np)
262{
263 struct device_node *timings_np;
264
265 if (!np)
266 return -EINVAL;
267
268 timings_np = of_parse_phandle(np, "display-timings", 0);
269 if (!timings_np)
270 return -EINVAL;
271
272 of_node_put(timings_np);
273 return 1;
274}
275EXPORT_SYMBOL_GPL(of_display_timings_exist);