Merge branch 'drm-next' of git://people.freedesktop.org/~airlied/linux
[firefly-linux-kernel-4.4.55.git] / drivers / video / of_display_timing.c
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  **/
26 static 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  **/
59 static 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_bool(np, "interlaced"))
92                 dt->flags |= DISPLAY_FLAGS_INTERLACED;
93         if (of_property_read_bool(np, "doublescan"))
94                 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
95         if (of_property_read_bool(np, "doubleclk"))
96                 dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
97
98         if (ret) {
99                 pr_err("%s: error reading timing properties\n",
100                         of_node_full_name(np));
101                 return -EINVAL;
102         }
103
104         return 0;
105 }
106
107 /**
108  * 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  **/
113 int 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 }
132 EXPORT_SYMBOL_GPL(of_get_display_timing);
133
134 /**
135  * of_get_display_timings - parse all display_timing entries from a device_node
136  * @np: device_node with the subnodes
137  **/
138 struct 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;
200                 int r;
201
202                 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
203                 if (!dt) {
204                         pr_err("%s: could not allocate display_timing struct\n",
205                                         of_node_full_name(np));
206                         goto timingfail;
207                 }
208
209                 r = of_parse_display_timing(entry, dt);
210                 if (r) {
211                         /*
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
239 timingfail:
240         if (native_mode)
241                 of_node_put(native_mode);
242         display_timings_release(disp);
243 entryfail:
244         kfree(disp);
245 dispfail:
246         of_node_put(timings_np);
247         return NULL;
248 }
249 EXPORT_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  **/
255 int 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 }
269 EXPORT_SYMBOL_GPL(of_display_timings_exist);