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_u32(np, "syncclk-active", &val)) 92 dt->flags |= val ? DISPLAY_FLAGS_SYNC_POSEDGE : 93 DISPLAY_FLAGS_SYNC_NEGEDGE; 94 else if (dt->flags & (DISPLAY_FLAGS_PIXDATA_POSEDGE | 95 DISPLAY_FLAGS_PIXDATA_NEGEDGE)) 96 dt->flags |= dt->flags & DISPLAY_FLAGS_PIXDATA_POSEDGE ? 97 DISPLAY_FLAGS_SYNC_POSEDGE : 98 DISPLAY_FLAGS_SYNC_NEGEDGE; 99 100 if (of_property_read_bool(np, "interlaced")) 101 dt->flags |= DISPLAY_FLAGS_INTERLACED; 102 if (of_property_read_bool(np, "doublescan")) 103 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN; 104 if (of_property_read_bool(np, "doubleclk")) 105 dt->flags |= DISPLAY_FLAGS_DOUBLECLK; 106 107 if (ret) { 108 pr_err("%s: error reading timing properties\n", 109 of_node_full_name(np)); 110 return -EINVAL; 111 } 112 113 return 0; 114 } 115 116 /** 117 * of_get_display_timing - parse a display_timing entry 118 * @np: device_node with the timing subnode 119 * @name: name of the timing node 120 * @dt: display_timing struct to fill 121 **/ 122 int of_get_display_timing(const struct device_node *np, const char *name, 123 struct display_timing *dt) 124 { 125 struct device_node *timing_np; 126 127 if (!np) 128 return -EINVAL; 129 130 timing_np = of_get_child_by_name(np, name); 131 if (!timing_np) { 132 pr_err("%s: could not find node '%s'\n", 133 of_node_full_name(np), name); 134 return -ENOENT; 135 } 136 137 return of_parse_display_timing(timing_np, dt); 138 } 139 EXPORT_SYMBOL_GPL(of_get_display_timing); 140 141 /** 142 * of_get_display_timings - parse all display_timing entries from a device_node 143 * @np: device_node with the subnodes 144 **/ 145 struct display_timings *of_get_display_timings(const struct device_node *np) 146 { 147 struct device_node *timings_np; 148 struct device_node *entry; 149 struct device_node *native_mode; 150 struct display_timings *disp; 151 152 if (!np) 153 return NULL; 154 155 timings_np = of_get_child_by_name(np, "display-timings"); 156 if (!timings_np) { 157 pr_err("%s: could not find display-timings node\n", 158 of_node_full_name(np)); 159 return NULL; 160 } 161 162 disp = kzalloc(sizeof(*disp), GFP_KERNEL); 163 if (!disp) { 164 pr_err("%s: could not allocate struct disp'\n", 165 of_node_full_name(np)); 166 goto dispfail; 167 } 168 169 entry = of_parse_phandle(timings_np, "native-mode", 0); 170 /* assume first child as native mode if none provided */ 171 if (!entry) 172 entry = of_get_next_child(timings_np, NULL); 173 /* if there is no child, it is useless to go on */ 174 if (!entry) { 175 pr_err("%s: no timing specifications given\n", 176 of_node_full_name(np)); 177 goto entryfail; 178 } 179 180 pr_debug("%s: using %s as default timing\n", 181 of_node_full_name(np), entry->name); 182 183 native_mode = entry; 184 185 disp->num_timings = of_get_child_count(timings_np); 186 if (disp->num_timings == 0) { 187 /* should never happen, as entry was already found above */ 188 pr_err("%s: no timings specified\n", of_node_full_name(np)); 189 goto entryfail; 190 } 191 192 disp->timings = kzalloc(sizeof(struct display_timing *) * 193 disp->num_timings, GFP_KERNEL); 194 if (!disp->timings) { 195 pr_err("%s: could not allocate timings array\n", 196 of_node_full_name(np)); 197 goto entryfail; 198 } 199 200 disp->num_timings = 0; 201 disp->native_mode = 0; 202 203 for_each_child_of_node(timings_np, entry) { 204 struct display_timing *dt; 205 int r; 206 207 dt = kzalloc(sizeof(*dt), GFP_KERNEL); 208 if (!dt) { 209 pr_err("%s: could not allocate display_timing struct\n", 210 of_node_full_name(np)); 211 goto timingfail; 212 } 213 214 r = of_parse_display_timing(entry, dt); 215 if (r) { 216 /* 217 * to not encourage wrong devicetrees, fail in case of 218 * an error 219 */ 220 pr_err("%s: error in timing %d\n", 221 of_node_full_name(np), disp->num_timings + 1); 222 kfree(dt); 223 goto timingfail; 224 } 225 226 if (native_mode == entry) 227 disp->native_mode = disp->num_timings; 228 229 disp->timings[disp->num_timings] = dt; 230 disp->num_timings++; 231 } 232 of_node_put(timings_np); 233 /* 234 * native_mode points to the device_node returned by of_parse_phandle 235 * therefore call of_node_put on it 236 */ 237 of_node_put(native_mode); 238 239 pr_debug("%s: got %d timings. Using timing #%d as default\n", 240 of_node_full_name(np), disp->num_timings, 241 disp->native_mode + 1); 242 243 return disp; 244 245 timingfail: 246 of_node_put(native_mode); 247 display_timings_release(disp); 248 disp = NULL; 249 entryfail: 250 kfree(disp); 251 dispfail: 252 of_node_put(timings_np); 253 return NULL; 254 } 255 EXPORT_SYMBOL_GPL(of_get_display_timings); 256 257 /** 258 * of_display_timings_exist - check if a display-timings node is provided 259 * @np: device_node with the timing 260 **/ 261 int of_display_timings_exist(const struct device_node *np) 262 { 263 struct device_node *timings_np; 264 265 if (!np) 266 return -EINVAL; 267 268 timings_np = of_parse_phandle(np, "display-timings", 0); 269 if (!timings_np) 270 return -EINVAL; 271 272 of_node_put(timings_np); 273 return 1; 274 } 275 EXPORT_SYMBOL_GPL(of_display_timings_exist); 276