blob: 171821ddd78de381a866e9912bece023a8fcaca5 [file] [log] [blame]
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +02001/*
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 **/
Steffen Trumtrarf5836622013-05-27 12:33:05 +000026static int parse_timing_property(const struct device_node *np, const char *name,
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020027 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/**
Tomi Valkeinenffa3fd22013-05-16 15:36:38 +030056 * of_parse_display_timing - parse display_timing entry from device_node
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020057 * @np: device_node with the properties
58 **/
Linus Torvalds2e17c5a2013-07-09 16:04:31 -070059static int of_parse_display_timing(const struct device_node *np,
Tomi Valkeinenfcf7e6e2013-05-16 15:29:06 +030060 struct display_timing *dt)
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020061{
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020062 u32 val = 0;
63 int ret = 0;
64
Tomi Valkeinenfcf7e6e2013-05-16 15:29:06 +030065 memset(dt, 0, sizeof(*dt));
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020066
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
Tomi Valkeinen06a33072013-03-12 10:26:45 +020077 dt->flags = 0;
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020078 if (!of_property_read_u32(np, "vsync-active", &val))
Tomi Valkeinen06a33072013-03-12 10:26:45 +020079 dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
80 DISPLAY_FLAGS_VSYNC_LOW;
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020081 if (!of_property_read_u32(np, "hsync-active", &val))
Tomi Valkeinen06a33072013-03-12 10:26:45 +020082 dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
83 DISPLAY_FLAGS_HSYNC_LOW;
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020084 if (!of_property_read_u32(np, "de-active", &val))
Tomi Valkeinen06a33072013-03-12 10:26:45 +020085 dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020086 DISPLAY_FLAGS_DE_LOW;
87 if (!of_property_read_u32(np, "pixelclk-active", &val))
Tomi Valkeinen06a33072013-03-12 10:26:45 +020088 dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020089 DISPLAY_FLAGS_PIXDATA_NEGEDGE;
90
91 if (of_property_read_bool(np, "interlaced"))
Tomi Valkeinen06a33072013-03-12 10:26:45 +020092 dt->flags |= DISPLAY_FLAGS_INTERLACED;
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020093 if (of_property_read_bool(np, "doublescan"))
Tomi Valkeinen06a33072013-03-12 10:26:45 +020094 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
Steffen Trumtrar2d178a42013-05-27 12:33:34 +000095 if (of_property_read_bool(np, "doubleclk"))
96 dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +020097
98 if (ret) {
99 pr_err("%s: error reading timing properties\n",
100 of_node_full_name(np));
Tomi Valkeinenfcf7e6e2013-05-16 15:29:06 +0300101 return -EINVAL;
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +0200102 }
103
Tomi Valkeinenfcf7e6e2013-05-16 15:29:06 +0300104 return 0;
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +0200105}
106
107/**
Tomi Valkeinenffa3fd22013-05-16 15:36:38 +0300108 * of_get_display_timing - parse a display_timing entry
109 * @np: device_node with the timing subnode
110 * @name: name of the timing node
111 * @dt: display_timing struct to fill
112 **/
113int of_get_display_timing(struct device_node *np, const char *name,
114 struct display_timing *dt)
115{
116 struct device_node *timing_np;
117
118 if (!np) {
119 pr_err("%s: no devicenode given\n", of_node_full_name(np));
120 return -EINVAL;
121 }
122
123 timing_np = of_find_node_by_name(np, name);
124 if (!timing_np) {
125 pr_err("%s: could not find node '%s'\n",
126 of_node_full_name(np), name);
127 return -ENOENT;
128 }
129
130 return of_parse_display_timing(timing_np, dt);
131}
132EXPORT_SYMBOL_GPL(of_get_display_timing);
133
134/**
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +0200135 * of_get_display_timings - parse all display_timing entries from a device_node
136 * @np: device_node with the subnodes
137 **/
138struct display_timings *of_get_display_timings(struct device_node *np)
139{
140 struct device_node *timings_np;
141 struct device_node *entry;
142 struct device_node *native_mode;
143 struct display_timings *disp;
144
145 if (!np) {
146 pr_err("%s: no devicenode given\n", of_node_full_name(np));
147 return NULL;
148 }
149
150 timings_np = of_find_node_by_name(np, "display-timings");
151 if (!timings_np) {
152 pr_err("%s: could not find display-timings node\n",
153 of_node_full_name(np));
154 return NULL;
155 }
156
157 disp = kzalloc(sizeof(*disp), GFP_KERNEL);
158 if (!disp) {
159 pr_err("%s: could not allocate struct disp'\n",
160 of_node_full_name(np));
161 goto dispfail;
162 }
163
164 entry = of_parse_phandle(timings_np, "native-mode", 0);
165 /* assume first child as native mode if none provided */
166 if (!entry)
167 entry = of_get_next_child(np, NULL);
168 /* if there is no child, it is useless to go on */
169 if (!entry) {
170 pr_err("%s: no timing specifications given\n",
171 of_node_full_name(np));
172 goto entryfail;
173 }
174
175 pr_debug("%s: using %s as default timing\n",
176 of_node_full_name(np), entry->name);
177
178 native_mode = entry;
179
180 disp->num_timings = of_get_child_count(timings_np);
181 if (disp->num_timings == 0) {
182 /* should never happen, as entry was already found above */
183 pr_err("%s: no timings specified\n", of_node_full_name(np));
184 goto entryfail;
185 }
186
187 disp->timings = kzalloc(sizeof(struct display_timing *) *
188 disp->num_timings, GFP_KERNEL);
189 if (!disp->timings) {
190 pr_err("%s: could not allocate timings array\n",
191 of_node_full_name(np));
192 goto entryfail;
193 }
194
195 disp->num_timings = 0;
196 disp->native_mode = 0;
197
198 for_each_child_of_node(timings_np, entry) {
199 struct display_timing *dt;
Tomi Valkeinenfcf7e6e2013-05-16 15:29:06 +0300200 int r;
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +0200201
Tomi Valkeinenfcf7e6e2013-05-16 15:29:06 +0300202 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +0200203 if (!dt) {
Tomi Valkeinenfcf7e6e2013-05-16 15:29:06 +0300204 pr_err("%s: could not allocate display_timing struct\n",
205 of_node_full_name(np));
206 goto timingfail;
207 }
208
Tomi Valkeinenffa3fd22013-05-16 15:36:38 +0300209 r = of_parse_display_timing(entry, dt);
Tomi Valkeinenfcf7e6e2013-05-16 15:29:06 +0300210 if (r) {
Steffen Trumtrarcc3f4142012-10-04 15:32:52 +0200211 /*
212 * to not encourage wrong devicetrees, fail in case of
213 * an error
214 */
215 pr_err("%s: error in timing %d\n",
216 of_node_full_name(np), disp->num_timings + 1);
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("%s: got %d timings. Using timing #%d as default\n",
234 of_node_full_name(np), disp->num_timings,
235 disp->native_mode + 1);
236
237 return disp;
238
239timingfail:
240 if (native_mode)
241 of_node_put(native_mode);
242 display_timings_release(disp);
243entryfail:
244 kfree(disp);
245dispfail:
246 of_node_put(timings_np);
247 return NULL;
248}
249EXPORT_SYMBOL_GPL(of_get_display_timings);
250
251/**
252 * of_display_timings_exist - check if a display-timings node is provided
253 * @np: device_node with the timing
254 **/
255int of_display_timings_exist(struct device_node *np)
256{
257 struct device_node *timings_np;
258
259 if (!np)
260 return -EINVAL;
261
262 timings_np = of_parse_phandle(np, "display-timings", 0);
263 if (!timings_np)
264 return -EINVAL;
265
266 of_node_put(timings_np);
267 return 1;
268}
269EXPORT_SYMBOL_GPL(of_display_timings_exist);