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("%pOF: could not find property %s\n", np, name); 35 return -EINVAL; 36 } 37 38 cells = length / sizeof(u32); 39 if (cells == 1) { 40 ret = of_property_read_u32(np, name, &result->typ); 41 result->min = result->typ; 42 result->max = result->typ; 43 } else if (cells == 3) { 44 ret = of_property_read_u32_array(np, name, &result->min, cells); 45 } else { 46 pr_err("%pOF: illegal timing specification in %s\n", np, name); 47 return -EINVAL; 48 } 49 50 return ret; 51 } 52 53 /** 54 * of_parse_display_timing - parse display_timing entry from device_node 55 * @np: device_node with the properties 56 **/ 57 static int of_parse_display_timing(const struct device_node *np, 58 struct display_timing *dt) 59 { 60 u32 val = 0; 61 int ret = 0; 62 63 memset(dt, 0, sizeof(*dt)); 64 65 ret |= parse_timing_property(np, "hback-porch", &dt->hback_porch); 66 ret |= parse_timing_property(np, "hfront-porch", &dt->hfront_porch); 67 ret |= parse_timing_property(np, "hactive", &dt->hactive); 68 ret |= parse_timing_property(np, "hsync-len", &dt->hsync_len); 69 ret |= parse_timing_property(np, "vback-porch", &dt->vback_porch); 70 ret |= parse_timing_property(np, "vfront-porch", &dt->vfront_porch); 71 ret |= parse_timing_property(np, "vactive", &dt->vactive); 72 ret |= parse_timing_property(np, "vsync-len", &dt->vsync_len); 73 ret |= parse_timing_property(np, "clock-frequency", &dt->pixelclock); 74 75 dt->flags = 0; 76 if (!of_property_read_u32(np, "vsync-active", &val)) 77 dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH : 78 DISPLAY_FLAGS_VSYNC_LOW; 79 if (!of_property_read_u32(np, "hsync-active", &val)) 80 dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH : 81 DISPLAY_FLAGS_HSYNC_LOW; 82 if (!of_property_read_u32(np, "de-active", &val)) 83 dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH : 84 DISPLAY_FLAGS_DE_LOW; 85 if (!of_property_read_u32(np, "pixelclk-active", &val)) 86 dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE : 87 DISPLAY_FLAGS_PIXDATA_NEGEDGE; 88 89 if (!of_property_read_u32(np, "syncclk-active", &val)) 90 dt->flags |= val ? DISPLAY_FLAGS_SYNC_POSEDGE : 91 DISPLAY_FLAGS_SYNC_NEGEDGE; 92 else if (dt->flags & (DISPLAY_FLAGS_PIXDATA_POSEDGE | 93 DISPLAY_FLAGS_PIXDATA_NEGEDGE)) 94 dt->flags |= dt->flags & DISPLAY_FLAGS_PIXDATA_POSEDGE ? 95 DISPLAY_FLAGS_SYNC_POSEDGE : 96 DISPLAY_FLAGS_SYNC_NEGEDGE; 97 98 if (of_property_read_bool(np, "interlaced")) 99 dt->flags |= DISPLAY_FLAGS_INTERLACED; 100 if (of_property_read_bool(np, "doublescan")) 101 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN; 102 if (of_property_read_bool(np, "doubleclk")) 103 dt->flags |= DISPLAY_FLAGS_DOUBLECLK; 104 105 if (ret) { 106 pr_err("%pOF: error reading timing properties\n", np); 107 return -EINVAL; 108 } 109 110 return 0; 111 } 112 113 /** 114 * of_get_display_timing - parse a display_timing entry 115 * @np: device_node with the timing subnode 116 * @name: name of the timing node 117 * @dt: display_timing struct to fill 118 **/ 119 int of_get_display_timing(const struct device_node *np, const char *name, 120 struct display_timing *dt) 121 { 122 struct device_node *timing_np; 123 124 if (!np) 125 return -EINVAL; 126 127 timing_np = of_get_child_by_name(np, name); 128 if (!timing_np) { 129 pr_err("%pOF: could not find node '%s'\n", np, name); 130 return -ENOENT; 131 } 132 133 return of_parse_display_timing(timing_np, dt); 134 } 135 EXPORT_SYMBOL_GPL(of_get_display_timing); 136 137 /** 138 * of_get_display_timings - parse all display_timing entries from a device_node 139 * @np: device_node with the subnodes 140 **/ 141 struct display_timings *of_get_display_timings(const struct device_node *np) 142 { 143 struct device_node *timings_np; 144 struct device_node *entry; 145 struct device_node *native_mode; 146 struct display_timings *disp; 147 148 if (!np) 149 return NULL; 150 151 timings_np = of_get_child_by_name(np, "display-timings"); 152 if (!timings_np) { 153 pr_err("%pOF: could not find display-timings node\n", np); 154 return NULL; 155 } 156 157 disp = kzalloc(sizeof(*disp), GFP_KERNEL); 158 if (!disp) { 159 pr_err("%pOF: could not allocate struct disp'\n", np); 160 goto dispfail; 161 } 162 163 entry = of_parse_phandle(timings_np, "native-mode", 0); 164 /* assume first child as native mode if none provided */ 165 if (!entry) 166 entry = of_get_next_child(timings_np, NULL); 167 /* if there is no child, it is useless to go on */ 168 if (!entry) { 169 pr_err("%pOF: no timing specifications given\n", np); 170 goto entryfail; 171 } 172 173 pr_debug("%pOF: using %pOFn as default timing\n", np, entry); 174 175 native_mode = entry; 176 177 disp->num_timings = of_get_child_count(timings_np); 178 if (disp->num_timings == 0) { 179 /* should never happen, as entry was already found above */ 180 pr_err("%pOF: no timings specified\n", np); 181 goto entryfail; 182 } 183 184 disp->timings = kcalloc(disp->num_timings, 185 sizeof(struct display_timing *), 186 GFP_KERNEL); 187 if (!disp->timings) { 188 pr_err("%pOF: could not allocate timings array\n", np); 189 goto entryfail; 190 } 191 192 disp->num_timings = 0; 193 disp->native_mode = 0; 194 195 for_each_child_of_node(timings_np, entry) { 196 struct display_timing *dt; 197 int r; 198 199 dt = kzalloc(sizeof(*dt), GFP_KERNEL); 200 if (!dt) { 201 pr_err("%pOF: could not allocate display_timing struct\n", 202 np); 203 goto timingfail; 204 } 205 206 r = of_parse_display_timing(entry, dt); 207 if (r) { 208 /* 209 * to not encourage wrong devicetrees, fail in case of 210 * an error 211 */ 212 pr_err("%pOF: error in timing %d\n", 213 np, disp->num_timings + 1); 214 kfree(dt); 215 goto timingfail; 216 } 217 218 if (native_mode == entry) 219 disp->native_mode = disp->num_timings; 220 221 disp->timings[disp->num_timings] = dt; 222 disp->num_timings++; 223 } 224 of_node_put(timings_np); 225 /* 226 * native_mode points to the device_node returned by of_parse_phandle 227 * therefore call of_node_put on it 228 */ 229 of_node_put(native_mode); 230 231 pr_debug("%pOF: got %d timings. Using timing #%d as default\n", 232 np, disp->num_timings, 233 disp->native_mode + 1); 234 235 return disp; 236 237 timingfail: 238 of_node_put(native_mode); 239 display_timings_release(disp); 240 disp = NULL; 241 entryfail: 242 kfree(disp); 243 dispfail: 244 of_node_put(timings_np); 245 return NULL; 246 } 247 EXPORT_SYMBOL_GPL(of_get_display_timings); 248