2 * OF helpers for parsing display timings
4 * Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix
6 * based on of_videomode.c by Sascha Hauer <s.hauer@pengutronix.de>
8 * This file is released under the GPLv2
10 #include <linux/export.h>
12 #include <linux/slab.h>
13 #include <video/display_timing.h>
14 #include <video/of_display_timing.h>
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
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
26 static int parse_timing_property(struct device_node
*np
, const char *name
,
27 struct timing_entry
*result
)
29 struct property
*prop
;
30 int length
, cells
, ret
;
32 prop
= of_find_property(np
, name
, &length
);
34 pr_err("%s: could not find property %s\n",
35 of_node_full_name(np
), name
);
39 cells
= length
/ sizeof(u32
);
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
);
47 pr_err("%s: illegal timing specification in %s\n",
48 of_node_full_name(np
), name
);
56 * of_get_display_timing - parse display_timing entry from device_node
57 * @np: device_node with the properties
59 static struct display_timing
*of_get_display_timing(struct device_node
*np
)
61 struct display_timing
*dt
;
65 dt
= kzalloc(sizeof(*dt
), GFP_KERNEL
);
67 pr_err("%s: could not allocate display_timing struct\n",
68 of_node_full_name(np
));
72 ret
|= parse_timing_property(np
, "hback-porch", &dt
->hback_porch
);
73 ret
|= parse_timing_property(np
, "hfront-porch", &dt
->hfront_porch
);
74 ret
|= parse_timing_property(np
, "hactive", &dt
->hactive
);
75 ret
|= parse_timing_property(np
, "hsync-len", &dt
->hsync_len
);
76 ret
|= parse_timing_property(np
, "vback-porch", &dt
->vback_porch
);
77 ret
|= parse_timing_property(np
, "vfront-porch", &dt
->vfront_porch
);
78 ret
|= parse_timing_property(np
, "vactive", &dt
->vactive
);
79 ret
|= parse_timing_property(np
, "vsync-len", &dt
->vsync_len
);
80 ret
|= parse_timing_property(np
, "clock-frequency", &dt
->pixelclock
);
83 if (!of_property_read_u32(np
, "vsync-active", &val
))
84 dt
->flags
|= val
? DISPLAY_FLAGS_VSYNC_HIGH
:
85 DISPLAY_FLAGS_VSYNC_LOW
;
86 if (!of_property_read_u32(np
, "hsync-active", &val
))
87 dt
->flags
|= val
? DISPLAY_FLAGS_HSYNC_HIGH
:
88 DISPLAY_FLAGS_HSYNC_LOW
;
89 if (!of_property_read_u32(np
, "de-active", &val
))
90 dt
->flags
|= val
? DISPLAY_FLAGS_DE_HIGH
:
92 if (!of_property_read_u32(np
, "pixelclk-active", &val
))
93 dt
->flags
|= val
? DISPLAY_FLAGS_PIXDATA_POSEDGE
:
94 DISPLAY_FLAGS_PIXDATA_NEGEDGE
;
96 if (of_property_read_bool(np
, "interlaced"))
97 dt
->flags
|= DISPLAY_FLAGS_INTERLACED
;
98 if (of_property_read_bool(np
, "doublescan"))
99 dt
->flags
|= DISPLAY_FLAGS_DOUBLESCAN
;
102 pr_err("%s: error reading timing properties\n",
103 of_node_full_name(np
));
112 * of_get_display_timings - parse all display_timing entries from a device_node
113 * @np: device_node with the subnodes
115 struct display_timings
*of_get_display_timings(struct device_node
*np
)
117 struct device_node
*timings_np
;
118 struct device_node
*entry
;
119 struct device_node
*native_mode
;
120 struct display_timings
*disp
;
123 pr_err("%s: no devicenode given\n", of_node_full_name(np
));
127 timings_np
= of_find_node_by_name(np
, "display-timings");
129 pr_err("%s: could not find display-timings node\n",
130 of_node_full_name(np
));
134 disp
= kzalloc(sizeof(*disp
), GFP_KERNEL
);
136 pr_err("%s: could not allocate struct disp'\n",
137 of_node_full_name(np
));
141 entry
= of_parse_phandle(timings_np
, "native-mode", 0);
142 /* assume first child as native mode if none provided */
144 entry
= of_get_next_child(np
, NULL
);
145 /* if there is no child, it is useless to go on */
147 pr_err("%s: no timing specifications given\n",
148 of_node_full_name(np
));
152 pr_debug("%s: using %s as default timing\n",
153 of_node_full_name(np
), entry
->name
);
157 disp
->num_timings
= of_get_child_count(timings_np
);
158 if (disp
->num_timings
== 0) {
159 /* should never happen, as entry was already found above */
160 pr_err("%s: no timings specified\n", of_node_full_name(np
));
164 disp
->timings
= kzalloc(sizeof(struct display_timing
*) *
165 disp
->num_timings
, GFP_KERNEL
);
166 if (!disp
->timings
) {
167 pr_err("%s: could not allocate timings array\n",
168 of_node_full_name(np
));
172 disp
->num_timings
= 0;
173 disp
->native_mode
= 0;
175 for_each_child_of_node(timings_np
, entry
) {
176 struct display_timing
*dt
;
178 dt
= of_get_display_timing(entry
);
181 * to not encourage wrong devicetrees, fail in case of
184 pr_err("%s: error in timing %d\n",
185 of_node_full_name(np
), disp
->num_timings
+ 1);
189 if (native_mode
== entry
)
190 disp
->native_mode
= disp
->num_timings
;
192 disp
->timings
[disp
->num_timings
] = dt
;
195 of_node_put(timings_np
);
197 * native_mode points to the device_node returned by of_parse_phandle
198 * therefore call of_node_put on it
200 of_node_put(native_mode
);
202 pr_debug("%s: got %d timings. Using timing #%d as default\n",
203 of_node_full_name(np
), disp
->num_timings
,
204 disp
->native_mode
+ 1);
210 of_node_put(native_mode
);
211 display_timings_release(disp
);
215 of_node_put(timings_np
);
218 EXPORT_SYMBOL_GPL(of_get_display_timings
);
221 * of_display_timings_exist - check if a display-timings node is provided
222 * @np: device_node with the timing
224 int of_display_timings_exist(struct device_node
*np
)
226 struct device_node
*timings_np
;
231 timings_np
= of_parse_phandle(np
, "display-timings", 0);
235 of_node_put(timings_np
);
238 EXPORT_SYMBOL_GPL(of_display_timings_exist
);