1 /* 2 * Copyright (c) 2011 The Chromium OS Authors. 3 * See file CREDITS for list of people who contributed to this 4 * project. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation; either version 2 of 9 * the License, or (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 19 * MA 02111-1307 USA 20 */ 21 22 #include <common.h> 23 #include <serial.h> 24 #include <libfdt.h> 25 #include <fdtdec.h> 26 27 #include <asm/gpio.h> 28 29 DECLARE_GLOBAL_DATA_PTR; 30 31 /* 32 * Here are the type we know about. One day we might allow drivers to 33 * register. For now we just put them here. The COMPAT macro allows us to 34 * turn this into a sparse list later, and keeps the ID with the name. 35 */ 36 #define COMPAT(id, name) name 37 static const char * const compat_names[COMPAT_COUNT] = { 38 COMPAT(UNKNOWN, "<none>"), 39 COMPAT(NVIDIA_TEGRA20_USB, "nvidia,tegra20-ehci"), 40 COMPAT(NVIDIA_TEGRA20_I2C, "nvidia,tegra20-i2c"), 41 COMPAT(NVIDIA_TEGRA20_DVC, "nvidia,tegra20-i2c-dvc"), 42 COMPAT(NVIDIA_TEGRA20_EMC, "nvidia,tegra20-emc"), 43 COMPAT(NVIDIA_TEGRA20_EMC_TABLE, "nvidia,tegra20-emc-table"), 44 COMPAT(NVIDIA_TEGRA20_KBC, "nvidia,tegra20-kbc"), 45 COMPAT(NVIDIA_TEGRA20_NAND, "nvidia,tegra20-nand"), 46 COMPAT(NVIDIA_TEGRA20_PWM, "nvidia,tegra20-pwm"), 47 COMPAT(NVIDIA_TEGRA20_DC, "nvidia,tegra20-dc"), 48 COMPAT(NVIDIA_TEGRA20_SFLASH, "nvidia,tegra20-sflash"), 49 COMPAT(SMSC_LAN9215, "smsc,lan9215"), 50 COMPAT(SAMSUNG_EXYNOS5_SROMC, "samsung,exynos-sromc"), 51 COMPAT(SAMSUNG_S3C2440_I2C, "samsung,s3c2440-i2c"), 52 COMPAT(SAMSUNG_EXYNOS5_SOUND, "samsung,exynos-sound"), 53 COMPAT(WOLFSON_WM8994_CODEC, "wolfson,wm8994-codec"), 54 COMPAT(SAMSUNG_EXYNOS_SPI, "samsung,exynos-spi"), 55 COMPAT(SAMSUNG_EXYNOS_EHCI, "samsung,exynos-ehci"), 56 COMPAT(SAMSUNG_EXYNOS_USB_PHY, "samsung,exynos-usb-phy"), 57 COMPAT(MAXIM_MAX77686_PMIC, "maxim,max77686_pmic"), 58 }; 59 60 const char *fdtdec_get_compatible(enum fdt_compat_id id) 61 { 62 /* We allow reading of the 'unknown' ID for testing purposes */ 63 assert(id >= 0 && id < COMPAT_COUNT); 64 return compat_names[id]; 65 } 66 67 fdt_addr_t fdtdec_get_addr(const void *blob, int node, 68 const char *prop_name) 69 { 70 const fdt_addr_t *cell; 71 int len; 72 73 debug("%s: %s: ", __func__, prop_name); 74 cell = fdt_getprop(blob, node, prop_name, &len); 75 if (cell && (len == sizeof(fdt_addr_t) || 76 len == sizeof(fdt_addr_t) * 2)) { 77 fdt_addr_t addr = fdt_addr_to_cpu(*cell); 78 79 debug("%p\n", (void *)addr); 80 return addr; 81 } 82 debug("(not found)\n"); 83 return FDT_ADDR_T_NONE; 84 } 85 86 s32 fdtdec_get_int(const void *blob, int node, const char *prop_name, 87 s32 default_val) 88 { 89 const s32 *cell; 90 int len; 91 92 debug("%s: %s: ", __func__, prop_name); 93 cell = fdt_getprop(blob, node, prop_name, &len); 94 if (cell && len >= sizeof(s32)) { 95 s32 val = fdt32_to_cpu(cell[0]); 96 97 debug("%#x (%d)\n", val, val); 98 return val; 99 } 100 debug("(not found)\n"); 101 return default_val; 102 } 103 104 uint64_t fdtdec_get_uint64(const void *blob, int node, const char *prop_name, 105 uint64_t default_val) 106 { 107 const uint64_t *cell64; 108 int length; 109 110 cell64 = fdt_getprop(blob, node, prop_name, &length); 111 if (!cell64 || length < sizeof(*cell64)) 112 return default_val; 113 114 return fdt64_to_cpu(*cell64); 115 } 116 117 int fdtdec_get_is_enabled(const void *blob, int node) 118 { 119 const char *cell; 120 121 /* 122 * It should say "okay", so only allow that. Some fdts use "ok" but 123 * this is a bug. Please fix your device tree source file. See here 124 * for discussion: 125 * 126 * http://www.mail-archive.com/u-boot@lists.denx.de/msg71598.html 127 */ 128 cell = fdt_getprop(blob, node, "status", NULL); 129 if (cell) 130 return 0 == strcmp(cell, "okay"); 131 return 1; 132 } 133 134 enum fdt_compat_id fdtdec_lookup(const void *blob, int node) 135 { 136 enum fdt_compat_id id; 137 138 /* Search our drivers */ 139 for (id = COMPAT_UNKNOWN; id < COMPAT_COUNT; id++) 140 if (0 == fdt_node_check_compatible(blob, node, 141 compat_names[id])) 142 return id; 143 return COMPAT_UNKNOWN; 144 } 145 146 int fdtdec_next_compatible(const void *blob, int node, 147 enum fdt_compat_id id) 148 { 149 return fdt_node_offset_by_compatible(blob, node, compat_names[id]); 150 } 151 152 int fdtdec_next_compatible_subnode(const void *blob, int node, 153 enum fdt_compat_id id, int *depthp) 154 { 155 do { 156 node = fdt_next_node(blob, node, depthp); 157 } while (*depthp > 1); 158 159 /* If this is a direct subnode, and compatible, return it */ 160 if (*depthp == 1 && 0 == fdt_node_check_compatible( 161 blob, node, compat_names[id])) 162 return node; 163 164 return -FDT_ERR_NOTFOUND; 165 } 166 167 int fdtdec_next_alias(const void *blob, const char *name, 168 enum fdt_compat_id id, int *upto) 169 { 170 #define MAX_STR_LEN 20 171 char str[MAX_STR_LEN + 20]; 172 int node, err; 173 174 /* snprintf() is not available */ 175 assert(strlen(name) < MAX_STR_LEN); 176 sprintf(str, "%.*s%d", MAX_STR_LEN, name, *upto); 177 node = fdt_path_offset(blob, str); 178 if (node < 0) 179 return node; 180 err = fdt_node_check_compatible(blob, node, compat_names[id]); 181 if (err < 0) 182 return err; 183 if (err) 184 return -FDT_ERR_NOTFOUND; 185 (*upto)++; 186 return node; 187 } 188 189 int fdtdec_find_aliases_for_id(const void *blob, const char *name, 190 enum fdt_compat_id id, int *node_list, int maxcount) 191 { 192 memset(node_list, '\0', sizeof(*node_list) * maxcount); 193 194 return fdtdec_add_aliases_for_id(blob, name, id, node_list, maxcount); 195 } 196 197 /* TODO: Can we tighten this code up a little? */ 198 int fdtdec_add_aliases_for_id(const void *blob, const char *name, 199 enum fdt_compat_id id, int *node_list, int maxcount) 200 { 201 int name_len = strlen(name); 202 int nodes[maxcount]; 203 int num_found = 0; 204 int offset, node; 205 int alias_node; 206 int count; 207 int i, j; 208 209 /* find the alias node if present */ 210 alias_node = fdt_path_offset(blob, "/aliases"); 211 212 /* 213 * start with nothing, and we can assume that the root node can't 214 * match 215 */ 216 memset(nodes, '\0', sizeof(nodes)); 217 218 /* First find all the compatible nodes */ 219 for (node = count = 0; node >= 0 && count < maxcount;) { 220 node = fdtdec_next_compatible(blob, node, id); 221 if (node >= 0) 222 nodes[count++] = node; 223 } 224 if (node >= 0) 225 debug("%s: warning: maxcount exceeded with alias '%s'\n", 226 __func__, name); 227 228 /* Now find all the aliases */ 229 for (offset = fdt_first_property_offset(blob, alias_node); 230 offset > 0; 231 offset = fdt_next_property_offset(blob, offset)) { 232 const struct fdt_property *prop; 233 const char *path; 234 int number; 235 int found; 236 237 node = 0; 238 prop = fdt_get_property_by_offset(blob, offset, NULL); 239 path = fdt_string(blob, fdt32_to_cpu(prop->nameoff)); 240 if (prop->len && 0 == strncmp(path, name, name_len)) 241 node = fdt_path_offset(blob, prop->data); 242 if (node <= 0) 243 continue; 244 245 /* Get the alias number */ 246 number = simple_strtoul(path + name_len, NULL, 10); 247 if (number < 0 || number >= maxcount) { 248 debug("%s: warning: alias '%s' is out of range\n", 249 __func__, path); 250 continue; 251 } 252 253 /* Make sure the node we found is actually in our list! */ 254 found = -1; 255 for (j = 0; j < count; j++) 256 if (nodes[j] == node) { 257 found = j; 258 break; 259 } 260 261 if (found == -1) { 262 debug("%s: warning: alias '%s' points to a node " 263 "'%s' that is missing or is not compatible " 264 " with '%s'\n", __func__, path, 265 fdt_get_name(blob, node, NULL), 266 compat_names[id]); 267 continue; 268 } 269 270 /* 271 * Add this node to our list in the right place, and mark 272 * it as done. 273 */ 274 if (fdtdec_get_is_enabled(blob, node)) { 275 if (node_list[number]) { 276 debug("%s: warning: alias '%s' requires that " 277 "a node be placed in the list in a " 278 "position which is already filled by " 279 "node '%s'\n", __func__, path, 280 fdt_get_name(blob, node, NULL)); 281 continue; 282 } 283 node_list[number] = node; 284 if (number >= num_found) 285 num_found = number + 1; 286 } 287 nodes[found] = 0; 288 } 289 290 /* Add any nodes not mentioned by an alias */ 291 for (i = j = 0; i < maxcount; i++) { 292 if (!node_list[i]) { 293 for (; j < maxcount; j++) 294 if (nodes[j] && 295 fdtdec_get_is_enabled(blob, nodes[j])) 296 break; 297 298 /* Have we run out of nodes to add? */ 299 if (j == maxcount) 300 break; 301 302 assert(!node_list[i]); 303 node_list[i] = nodes[j++]; 304 if (i >= num_found) 305 num_found = i + 1; 306 } 307 } 308 309 return num_found; 310 } 311 312 int fdtdec_check_fdt(void) 313 { 314 /* 315 * We must have an FDT, but we cannot panic() yet since the console 316 * is not ready. So for now, just assert(). Boards which need an early 317 * FDT (prior to console ready) will need to make their own 318 * arrangements and do their own checks. 319 */ 320 assert(!fdtdec_prepare_fdt()); 321 return 0; 322 } 323 324 /* 325 * This function is a little odd in that it accesses global data. At some 326 * point if the architecture board.c files merge this will make more sense. 327 * Even now, it is common code. 328 */ 329 int fdtdec_prepare_fdt(void) 330 { 331 if (((uintptr_t)gd->fdt_blob & 3) || fdt_check_header(gd->fdt_blob)) { 332 printf("No valid FDT found - please append one to U-Boot " 333 "binary, use u-boot-dtb.bin or define " 334 "CONFIG_OF_EMBED\n"); 335 return -1; 336 } 337 return 0; 338 } 339 340 int fdtdec_lookup_phandle(const void *blob, int node, const char *prop_name) 341 { 342 const u32 *phandle; 343 int lookup; 344 345 debug("%s: %s\n", __func__, prop_name); 346 phandle = fdt_getprop(blob, node, prop_name, NULL); 347 if (!phandle) 348 return -FDT_ERR_NOTFOUND; 349 350 lookup = fdt_node_offset_by_phandle(blob, fdt32_to_cpu(*phandle)); 351 return lookup; 352 } 353 354 /** 355 * Look up a property in a node and check that it has a minimum length. 356 * 357 * @param blob FDT blob 358 * @param node node to examine 359 * @param prop_name name of property to find 360 * @param min_len minimum property length in bytes 361 * @param err 0 if ok, or -FDT_ERR_NOTFOUND if the property is not 362 found, or -FDT_ERR_BADLAYOUT if not enough data 363 * @return pointer to cell, which is only valid if err == 0 364 */ 365 static const void *get_prop_check_min_len(const void *blob, int node, 366 const char *prop_name, int min_len, int *err) 367 { 368 const void *cell; 369 int len; 370 371 debug("%s: %s\n", __func__, prop_name); 372 cell = fdt_getprop(blob, node, prop_name, &len); 373 if (!cell) 374 *err = -FDT_ERR_NOTFOUND; 375 else if (len < min_len) 376 *err = -FDT_ERR_BADLAYOUT; 377 else 378 *err = 0; 379 return cell; 380 } 381 382 int fdtdec_get_int_array(const void *blob, int node, const char *prop_name, 383 u32 *array, int count) 384 { 385 const u32 *cell; 386 int i, err = 0; 387 388 debug("%s: %s\n", __func__, prop_name); 389 cell = get_prop_check_min_len(blob, node, prop_name, 390 sizeof(u32) * count, &err); 391 if (!err) { 392 for (i = 0; i < count; i++) 393 array[i] = fdt32_to_cpu(cell[i]); 394 } 395 return err; 396 } 397 398 const u32 *fdtdec_locate_array(const void *blob, int node, 399 const char *prop_name, int count) 400 { 401 const u32 *cell; 402 int err; 403 404 cell = get_prop_check_min_len(blob, node, prop_name, 405 sizeof(u32) * count, &err); 406 return err ? NULL : cell; 407 } 408 409 int fdtdec_get_bool(const void *blob, int node, const char *prop_name) 410 { 411 const s32 *cell; 412 int len; 413 414 debug("%s: %s\n", __func__, prop_name); 415 cell = fdt_getprop(blob, node, prop_name, &len); 416 return cell != NULL; 417 } 418 419 /** 420 * Decode a list of GPIOs from an FDT. This creates a list of GPIOs with no 421 * terminating item. 422 * 423 * @param blob FDT blob to use 424 * @param node Node to look at 425 * @param prop_name Node property name 426 * @param gpio Array of gpio elements to fill from FDT. This will be 427 * untouched if either 0 or an error is returned 428 * @param max_count Maximum number of elements allowed 429 * @return number of GPIOs read if ok, -FDT_ERR_BADLAYOUT if max_count would 430 * be exceeded, or -FDT_ERR_NOTFOUND if the property is missing. 431 */ 432 int fdtdec_decode_gpios(const void *blob, int node, const char *prop_name, 433 struct fdt_gpio_state *gpio, int max_count) 434 { 435 const struct fdt_property *prop; 436 const u32 *cell; 437 const char *name; 438 int len, i; 439 440 debug("%s: %s\n", __func__, prop_name); 441 assert(max_count > 0); 442 prop = fdt_get_property(blob, node, prop_name, &len); 443 if (!prop) { 444 debug("%s: property '%s' missing\n", __func__, prop_name); 445 return -FDT_ERR_NOTFOUND; 446 } 447 448 /* We will use the name to tag the GPIO */ 449 name = fdt_string(blob, fdt32_to_cpu(prop->nameoff)); 450 cell = (u32 *)prop->data; 451 len /= sizeof(u32) * 3; /* 3 cells per GPIO record */ 452 if (len > max_count) { 453 debug(" %s: too many GPIOs / cells for " 454 "property '%s'\n", __func__, prop_name); 455 return -FDT_ERR_BADLAYOUT; 456 } 457 458 /* Read out the GPIO data from the cells */ 459 for (i = 0; i < len; i++, cell += 3) { 460 gpio[i].gpio = fdt32_to_cpu(cell[1]); 461 gpio[i].flags = fdt32_to_cpu(cell[2]); 462 gpio[i].name = name; 463 } 464 465 return len; 466 } 467 468 int fdtdec_decode_gpio(const void *blob, int node, const char *prop_name, 469 struct fdt_gpio_state *gpio) 470 { 471 int err; 472 473 debug("%s: %s\n", __func__, prop_name); 474 gpio->gpio = FDT_GPIO_NONE; 475 gpio->name = NULL; 476 err = fdtdec_decode_gpios(blob, node, prop_name, gpio, 1); 477 return err == 1 ? 0 : err; 478 } 479 480 int fdtdec_get_gpio(struct fdt_gpio_state *gpio) 481 { 482 int val; 483 484 if (!fdt_gpio_isvalid(gpio)) 485 return -1; 486 487 val = gpio_get_value(gpio->gpio); 488 return gpio->flags & FDT_GPIO_ACTIVE_LOW ? val ^ 1 : val; 489 } 490 491 int fdtdec_set_gpio(struct fdt_gpio_state *gpio, int val) 492 { 493 if (!fdt_gpio_isvalid(gpio)) 494 return -1; 495 496 val = gpio->flags & FDT_GPIO_ACTIVE_LOW ? val ^ 1 : val; 497 return gpio_set_value(gpio->gpio, val); 498 } 499 500 int fdtdec_setup_gpio(struct fdt_gpio_state *gpio) 501 { 502 /* 503 * Return success if there is no GPIO defined. This is used for 504 * optional GPIOs) 505 */ 506 if (!fdt_gpio_isvalid(gpio)) 507 return 0; 508 509 if (gpio_request(gpio->gpio, gpio->name)) 510 return -1; 511 return 0; 512 } 513 514 int fdtdec_get_byte_array(const void *blob, int node, const char *prop_name, 515 u8 *array, int count) 516 { 517 const u8 *cell; 518 int err; 519 520 cell = get_prop_check_min_len(blob, node, prop_name, count, &err); 521 if (!err) 522 memcpy(array, cell, count); 523 return err; 524 } 525 526 const u8 *fdtdec_locate_byte_array(const void *blob, int node, 527 const char *prop_name, int count) 528 { 529 const u8 *cell; 530 int err; 531 532 cell = get_prop_check_min_len(blob, node, prop_name, count, &err); 533 if (err) 534 return NULL; 535 return cell; 536 } 537 538 int fdtdec_get_config_int(const void *blob, const char *prop_name, 539 int default_val) 540 { 541 int config_node; 542 543 debug("%s: %s\n", __func__, prop_name); 544 config_node = fdt_path_offset(blob, "/config"); 545 if (config_node < 0) 546 return default_val; 547 return fdtdec_get_int(blob, config_node, prop_name, default_val); 548 } 549 550 int fdtdec_get_config_bool(const void *blob, const char *prop_name) 551 { 552 int config_node; 553 const void *prop; 554 555 debug("%s: %s\n", __func__, prop_name); 556 config_node = fdt_path_offset(blob, "/config"); 557 if (config_node < 0) 558 return 0; 559 prop = fdt_get_property(blob, config_node, prop_name, NULL); 560 561 return prop != NULL; 562 } 563 564 char *fdtdec_get_config_string(const void *blob, const char *prop_name) 565 { 566 const char *nodep; 567 int nodeoffset; 568 int len; 569 570 debug("%s: %s\n", __func__, prop_name); 571 nodeoffset = fdt_path_offset(blob, "/config"); 572 if (nodeoffset < 0) 573 return NULL; 574 575 nodep = fdt_getprop(blob, nodeoffset, prop_name, &len); 576 if (!nodep) 577 return NULL; 578 579 return (char *)nodep; 580 } 581 582 int fdtdec_decode_region(const void *blob, int node, 583 const char *prop_name, void **ptrp, size_t *size) 584 { 585 const fdt_addr_t *cell; 586 int len; 587 588 debug("%s: %s\n", __func__, prop_name); 589 cell = fdt_getprop(blob, node, prop_name, &len); 590 if (!cell || (len != sizeof(fdt_addr_t) * 2)) 591 return -1; 592 593 *ptrp = (void *)fdt_addr_to_cpu(*cell); 594 *size = fdt_size_to_cpu(cell[1]); 595 debug("%s: size=%zx\n", __func__, *size); 596 return 0; 597 } 598