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