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_parse_display_timing - parse display_timing entry from device_node
57 * @np: device_node with the properties
59 static int of_parse_display_timing(struct device_node *np,
60 struct display_timing *dt)
65 memset(dt, 0, sizeof(*dt));
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);
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 :
87 if (!of_property_read_u32(np, "pixelclk-active", &val))
88 dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
89 DISPLAY_FLAGS_PIXDATA_NEGEDGE;
91 if (of_property_read_bool(np, "interlaced"))
92 dt->flags |= DISPLAY_FLAGS_INTERLACED;
93 if (of_property_read_bool(np, "doublescan"))
94 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
97 pr_err("%s: error reading timing properties\n",
98 of_node_full_name(np));
106 * of_get_display_timing - parse a display_timing entry
107 * @np: device_node with the timing subnode
108 * @name: name of the timing node
109 * @dt: display_timing struct to fill
111 int of_get_display_timing(struct device_node *np, const char *name,
112 struct display_timing *dt)
114 struct device_node *timing_np;
117 pr_err("%s: no devicenode given\n", of_node_full_name(np));
121 timing_np = of_find_node_by_name(np, name);
123 pr_err("%s: could not find node '%s'\n",
124 of_node_full_name(np), name);
128 return of_parse_display_timing(timing_np, dt);
130 EXPORT_SYMBOL_GPL(of_get_display_timing);
133 * of_get_display_timings - parse all display_timing entries from a device_node
134 * @np: device_node with the subnodes
136 struct display_timings *of_get_display_timings(struct device_node *np)
138 struct device_node *timings_np;
139 struct device_node *entry;
140 struct device_node *native_mode;
141 struct display_timings *disp;
144 pr_err("%s: no devicenode given\n", of_node_full_name(np));
148 timings_np = of_find_node_by_name(np, "display-timings");
150 pr_err("%s: could not find display-timings node\n",
151 of_node_full_name(np));
155 disp = kzalloc(sizeof(*disp), GFP_KERNEL);
157 pr_err("%s: could not allocate struct disp'\n",
158 of_node_full_name(np));
162 entry = of_parse_phandle(timings_np, "native-mode", 0);
163 /* assume first child as native mode if none provided */
165 entry = of_get_next_child(np, NULL);
166 /* if there is no child, it is useless to go on */
168 pr_err("%s: no timing specifications given\n",
169 of_node_full_name(np));
173 pr_debug("%s: using %s as default timing\n",
174 of_node_full_name(np), entry->name);
178 disp->num_timings = of_get_child_count(timings_np);
179 if (disp->num_timings == 0) {
180 /* should never happen, as entry was already found above */
181 pr_err("%s: no timings specified\n", of_node_full_name(np));
185 disp->timings = kzalloc(sizeof(struct display_timing *) *
186 disp->num_timings, GFP_KERNEL);
187 if (!disp->timings) {
188 pr_err("%s: could not allocate timings array\n",
189 of_node_full_name(np));
193 disp->num_timings = 0;
194 disp->native_mode = 0;
196 for_each_child_of_node(timings_np, entry) {
197 struct display_timing *dt;
200 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
202 pr_err("%s: could not allocate display_timing struct\n",
203 of_node_full_name(np));
207 r = of_parse_display_timing(entry, dt);
210 * to not encourage wrong devicetrees, fail in case of
213 pr_err("%s: error in timing %d\n",
214 of_node_full_name(np), disp->num_timings + 1);
218 if (native_mode == entry)
219 disp->native_mode = disp->num_timings;
221 disp->timings[disp->num_timings] = dt;
224 of_node_put(timings_np);
226 * native_mode points to the device_node returned by of_parse_phandle
227 * therefore call of_node_put on it
229 of_node_put(native_mode);
231 pr_debug("%s: got %d timings. Using timing #%d as default\n",
232 of_node_full_name(np), disp->num_timings,
233 disp->native_mode + 1);
239 of_node_put(native_mode);
240 display_timings_release(disp);
244 of_node_put(timings_np);
247 EXPORT_SYMBOL_GPL(of_get_display_timings);
250 * of_display_timings_exist - check if a display-timings node is provided
251 * @np: device_node with the timing
253 int of_display_timings_exist(struct device_node *np)
255 struct device_node *timings_np;
260 timings_np = of_parse_phandle(np, "display-timings", 0);
264 of_node_put(timings_np);
267 EXPORT_SYMBOL_GPL(of_display_timings_exist);