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(const 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(const struct device_node *np,
60 struct display_timing *dt)
64 #if defined(CONFIG_FB_ROCKCHIP)
65 struct property *prop;
69 memset(dt, 0, sizeof(*dt));
71 ret |= parse_timing_property(np, "hback-porch", &dt->hback_porch);
72 ret |= parse_timing_property(np, "hfront-porch", &dt->hfront_porch);
73 ret |= parse_timing_property(np, "hactive", &dt->hactive);
74 ret |= parse_timing_property(np, "hsync-len", &dt->hsync_len);
75 ret |= parse_timing_property(np, "vback-porch", &dt->vback_porch);
76 ret |= parse_timing_property(np, "vfront-porch", &dt->vfront_porch);
77 ret |= parse_timing_property(np, "vactive", &dt->vactive);
78 ret |= parse_timing_property(np, "vsync-len", &dt->vsync_len);
79 ret |= parse_timing_property(np, "clock-frequency", &dt->pixelclock);
82 if (!of_property_read_u32(np, "vsync-active", &val))
83 dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
84 DISPLAY_FLAGS_VSYNC_LOW;
85 if (!of_property_read_u32(np, "hsync-active", &val))
86 dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
87 DISPLAY_FLAGS_HSYNC_LOW;
88 if (!of_property_read_u32(np, "de-active", &val))
89 dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
91 if (!of_property_read_u32(np, "pixelclk-active", &val))
92 dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
93 DISPLAY_FLAGS_PIXDATA_NEGEDGE;
95 if (of_property_read_bool(np, "interlaced"))
96 dt->flags |= DISPLAY_FLAGS_INTERLACED;
97 if (of_property_read_bool(np, "doublescan"))
98 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
99 if (of_property_read_bool(np, "doubleclk"))
100 dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
101 #if defined(CONFIG_FB_ROCKCHIP)
102 if (!of_property_read_u32(np, "swap-rg", &val))
103 dt->flags |= val ? DISPLAY_FLAGS_SWAP_RG : 0;
104 if (!of_property_read_u32(np, "swap-gb", &val))
105 dt->flags |= val ? DISPLAY_FLAGS_SWAP_GB : 0;
106 if (!of_property_read_u32(np, "swap-rb", &val))
107 dt->flags |= val ? DISPLAY_FLAGS_SWAP_RB : 0;
108 if (!of_property_read_u32(np, "screen-type", &val))
109 dt->screen_type = val;
110 if (!of_property_read_u32(np, "lvds-format", &val))
111 dt->lvds_format = val;
112 if (!of_property_read_u32(np, "out-face", &val))
114 if (!of_property_read_u32(np, "color-mode", &val))
115 dt->color_mode = val;
116 prop = of_find_property(np, "dsp-lut", &length);
118 dt->dsp_lut = kzalloc(length, GFP_KERNEL);
120 ret = of_property_read_u32_array(np,
121 "dsp-lut", dt->dsp_lut, length >> 2);
123 prop = of_find_property(np, "cabc-lut", &length);
125 dt->cabc_lut = kzalloc(length, GFP_KERNEL);
127 ret = of_property_read_u32_array(np,
133 prop = of_find_property(np, "cabc-gamma-base", &length);
135 dt->cabc_gamma_base = kzalloc(length, GFP_KERNEL);
136 if (dt->cabc_gamma_base)
137 ret = of_property_read_u32_array(np,
145 pr_err("%s: error reading timing properties\n",
146 of_node_full_name(np));
154 * of_get_display_timing - parse a display_timing entry
155 * @np: device_node with the timing subnode
156 * @name: name of the timing node
157 * @dt: display_timing struct to fill
159 int of_get_display_timing(struct device_node *np, const char *name,
160 struct display_timing *dt)
162 struct device_node *timing_np;
167 timing_np = of_get_child_by_name(np, name);
169 pr_err("%s: could not find node '%s'\n",
170 of_node_full_name(np), name);
174 return of_parse_display_timing(timing_np, dt);
176 EXPORT_SYMBOL_GPL(of_get_display_timing);
179 * of_get_display_timings - parse all display_timing entries from a device_node
180 * @np: device_node with the subnodes
182 struct display_timings *of_get_display_timings(struct device_node *np)
184 struct device_node *timings_np;
185 struct device_node *entry;
186 struct device_node *native_mode;
187 struct display_timings *disp;
192 timings_np = of_get_child_by_name(np, "display-timings");
194 pr_err("%s: could not find display-timings node\n",
195 of_node_full_name(np));
199 disp = kzalloc(sizeof(*disp), GFP_KERNEL);
201 pr_err("%s: could not allocate struct disp'\n",
202 of_node_full_name(np));
206 entry = of_parse_phandle(timings_np, "native-mode", 0);
207 /* assume first child as native mode if none provided */
209 entry = of_get_next_child(timings_np, NULL);
210 /* if there is no child, it is useless to go on */
212 pr_err("%s: no timing specifications given\n",
213 of_node_full_name(np));
217 pr_debug("%s: using %s as default timing\n",
218 of_node_full_name(np), entry->name);
222 disp->num_timings = of_get_child_count(timings_np);
223 if (disp->num_timings == 0) {
224 /* should never happen, as entry was already found above */
225 pr_err("%s: no timings specified\n", of_node_full_name(np));
229 disp->timings = kzalloc(sizeof(struct display_timing *) *
230 disp->num_timings, GFP_KERNEL);
231 if (!disp->timings) {
232 pr_err("%s: could not allocate timings array\n",
233 of_node_full_name(np));
237 disp->num_timings = 0;
238 disp->native_mode = 0;
240 for_each_child_of_node(timings_np, entry) {
241 struct display_timing *dt;
244 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
246 pr_err("%s: could not allocate display_timing struct\n",
247 of_node_full_name(np));
251 r = of_parse_display_timing(entry, dt);
254 * to not encourage wrong devicetrees, fail in case of
257 pr_err("%s: error in timing %d\n",
258 of_node_full_name(np), disp->num_timings + 1);
263 if (native_mode == entry)
264 disp->native_mode = disp->num_timings;
266 disp->timings[disp->num_timings] = dt;
269 of_node_put(timings_np);
271 * native_mode points to the device_node returned by of_parse_phandle
272 * therefore call of_node_put on it
274 of_node_put(native_mode);
276 pr_debug("%s: got %d timings. Using timing #%d as default\n",
277 of_node_full_name(np), disp->num_timings,
278 disp->native_mode + 1);
283 of_node_put(native_mode);
284 display_timings_release(disp);
289 of_node_put(timings_np);
292 EXPORT_SYMBOL_GPL(of_get_display_timings);
295 * of_display_timings_exist - check if a display-timings node is provided
296 * @np: device_node with the timing
298 int of_display_timings_exist(struct device_node *np)
300 struct device_node *timings_np;
305 timings_np = of_parse_phandle(np, "display-timings", 0);
309 of_node_put(timings_np);
312 EXPORT_SYMBOL_GPL(of_display_timings_exist);