1 /* 2 * Procedures for creating, accessing and interpreting the device tree. 3 * 4 * Paul Mackerras August 1996. 5 * Copyright (C) 1996-2005 Paul Mackerras. 6 * 7 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner. 8 * {engebret|bergner}@us.ibm.com 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * as published by the Free Software Foundation; either version 13 * 2 of the License, or (at your option) any later version. 14 */ 15 16 #undef DEBUG 17 18 #include <stdarg.h> 19 #include <linux/kernel.h> 20 #include <linux/string.h> 21 #include <linux/init.h> 22 #include <linux/threads.h> 23 #include <linux/spinlock.h> 24 #include <linux/types.h> 25 #include <linux/pci.h> 26 #include <linux/stringify.h> 27 #include <linux/delay.h> 28 #include <linux/initrd.h> 29 #include <linux/bitops.h> 30 #include <linux/module.h> 31 #include <linux/kexec.h> 32 #include <linux/debugfs.h> 33 #include <linux/irq.h> 34 35 #include <asm/prom.h> 36 #include <asm/rtas.h> 37 #include <asm/lmb.h> 38 #include <asm/page.h> 39 #include <asm/processor.h> 40 #include <asm/irq.h> 41 #include <asm/io.h> 42 #include <asm/kdump.h> 43 #include <asm/smp.h> 44 #include <asm/system.h> 45 #include <asm/mmu.h> 46 #include <asm/pgtable.h> 47 #include <asm/pci.h> 48 #include <asm/iommu.h> 49 #include <asm/btext.h> 50 #include <asm/sections.h> 51 #include <asm/machdep.h> 52 #include <asm/pSeries_reconfig.h> 53 #include <asm/pci-bridge.h> 54 #include <asm/kexec.h> 55 56 #ifdef DEBUG 57 #define DBG(fmt...) printk(KERN_ERR fmt) 58 #else 59 #define DBG(fmt...) 60 #endif 61 62 63 static int __initdata dt_root_addr_cells; 64 static int __initdata dt_root_size_cells; 65 66 #ifdef CONFIG_PPC64 67 int __initdata iommu_is_off; 68 int __initdata iommu_force_on; 69 unsigned long tce_alloc_start, tce_alloc_end; 70 #endif 71 72 typedef u32 cell_t; 73 74 #if 0 75 static struct boot_param_header *initial_boot_params __initdata; 76 #else 77 struct boot_param_header *initial_boot_params; 78 #endif 79 80 static struct device_node *allnodes = NULL; 81 82 /* use when traversing tree through the allnext, child, sibling, 83 * or parent members of struct device_node. 84 */ 85 static DEFINE_RWLOCK(devtree_lock); 86 87 /* export that to outside world */ 88 struct device_node *of_chosen; 89 90 static inline char *find_flat_dt_string(u32 offset) 91 { 92 return ((char *)initial_boot_params) + 93 initial_boot_params->off_dt_strings + offset; 94 } 95 96 /** 97 * This function is used to scan the flattened device-tree, it is 98 * used to extract the memory informations at boot before we can 99 * unflatten the tree 100 */ 101 int __init of_scan_flat_dt(int (*it)(unsigned long node, 102 const char *uname, int depth, 103 void *data), 104 void *data) 105 { 106 unsigned long p = ((unsigned long)initial_boot_params) + 107 initial_boot_params->off_dt_struct; 108 int rc = 0; 109 int depth = -1; 110 111 do { 112 u32 tag = *((u32 *)p); 113 char *pathp; 114 115 p += 4; 116 if (tag == OF_DT_END_NODE) { 117 depth --; 118 continue; 119 } 120 if (tag == OF_DT_NOP) 121 continue; 122 if (tag == OF_DT_END) 123 break; 124 if (tag == OF_DT_PROP) { 125 u32 sz = *((u32 *)p); 126 p += 8; 127 if (initial_boot_params->version < 0x10) 128 p = _ALIGN(p, sz >= 8 ? 8 : 4); 129 p += sz; 130 p = _ALIGN(p, 4); 131 continue; 132 } 133 if (tag != OF_DT_BEGIN_NODE) { 134 printk(KERN_WARNING "Invalid tag %x scanning flattened" 135 " device tree !\n", tag); 136 return -EINVAL; 137 } 138 depth++; 139 pathp = (char *)p; 140 p = _ALIGN(p + strlen(pathp) + 1, 4); 141 if ((*pathp) == '/') { 142 char *lp, *np; 143 for (lp = NULL, np = pathp; *np; np++) 144 if ((*np) == '/') 145 lp = np+1; 146 if (lp != NULL) 147 pathp = lp; 148 } 149 rc = it(p, pathp, depth, data); 150 if (rc != 0) 151 break; 152 } while(1); 153 154 return rc; 155 } 156 157 unsigned long __init of_get_flat_dt_root(void) 158 { 159 unsigned long p = ((unsigned long)initial_boot_params) + 160 initial_boot_params->off_dt_struct; 161 162 while(*((u32 *)p) == OF_DT_NOP) 163 p += 4; 164 BUG_ON (*((u32 *)p) != OF_DT_BEGIN_NODE); 165 p += 4; 166 return _ALIGN(p + strlen((char *)p) + 1, 4); 167 } 168 169 /** 170 * This function can be used within scan_flattened_dt callback to get 171 * access to properties 172 */ 173 void* __init of_get_flat_dt_prop(unsigned long node, const char *name, 174 unsigned long *size) 175 { 176 unsigned long p = node; 177 178 do { 179 u32 tag = *((u32 *)p); 180 u32 sz, noff; 181 const char *nstr; 182 183 p += 4; 184 if (tag == OF_DT_NOP) 185 continue; 186 if (tag != OF_DT_PROP) 187 return NULL; 188 189 sz = *((u32 *)p); 190 noff = *((u32 *)(p + 4)); 191 p += 8; 192 if (initial_boot_params->version < 0x10) 193 p = _ALIGN(p, sz >= 8 ? 8 : 4); 194 195 nstr = find_flat_dt_string(noff); 196 if (nstr == NULL) { 197 printk(KERN_WARNING "Can't find property index" 198 " name !\n"); 199 return NULL; 200 } 201 if (strcmp(name, nstr) == 0) { 202 if (size) 203 *size = sz; 204 return (void *)p; 205 } 206 p += sz; 207 p = _ALIGN(p, 4); 208 } while(1); 209 } 210 211 int __init of_flat_dt_is_compatible(unsigned long node, const char *compat) 212 { 213 const char* cp; 214 unsigned long cplen, l; 215 216 cp = of_get_flat_dt_prop(node, "compatible", &cplen); 217 if (cp == NULL) 218 return 0; 219 while (cplen > 0) { 220 if (strncasecmp(cp, compat, strlen(compat)) == 0) 221 return 1; 222 l = strlen(cp) + 1; 223 cp += l; 224 cplen -= l; 225 } 226 227 return 0; 228 } 229 230 static void *__init unflatten_dt_alloc(unsigned long *mem, unsigned long size, 231 unsigned long align) 232 { 233 void *res; 234 235 *mem = _ALIGN(*mem, align); 236 res = (void *)*mem; 237 *mem += size; 238 239 return res; 240 } 241 242 static unsigned long __init unflatten_dt_node(unsigned long mem, 243 unsigned long *p, 244 struct device_node *dad, 245 struct device_node ***allnextpp, 246 unsigned long fpsize) 247 { 248 struct device_node *np; 249 struct property *pp, **prev_pp = NULL; 250 char *pathp; 251 u32 tag; 252 unsigned int l, allocl; 253 int has_name = 0; 254 int new_format = 0; 255 256 tag = *((u32 *)(*p)); 257 if (tag != OF_DT_BEGIN_NODE) { 258 printk("Weird tag at start of node: %x\n", tag); 259 return mem; 260 } 261 *p += 4; 262 pathp = (char *)*p; 263 l = allocl = strlen(pathp) + 1; 264 *p = _ALIGN(*p + l, 4); 265 266 /* version 0x10 has a more compact unit name here instead of the full 267 * path. we accumulate the full path size using "fpsize", we'll rebuild 268 * it later. We detect this because the first character of the name is 269 * not '/'. 270 */ 271 if ((*pathp) != '/') { 272 new_format = 1; 273 if (fpsize == 0) { 274 /* root node: special case. fpsize accounts for path 275 * plus terminating zero. root node only has '/', so 276 * fpsize should be 2, but we want to avoid the first 277 * level nodes to have two '/' so we use fpsize 1 here 278 */ 279 fpsize = 1; 280 allocl = 2; 281 } else { 282 /* account for '/' and path size minus terminal 0 283 * already in 'l' 284 */ 285 fpsize += l; 286 allocl = fpsize; 287 } 288 } 289 290 291 np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl, 292 __alignof__(struct device_node)); 293 if (allnextpp) { 294 memset(np, 0, sizeof(*np)); 295 np->full_name = ((char*)np) + sizeof(struct device_node); 296 if (new_format) { 297 char *p = np->full_name; 298 /* rebuild full path for new format */ 299 if (dad && dad->parent) { 300 strcpy(p, dad->full_name); 301 #ifdef DEBUG 302 if ((strlen(p) + l + 1) != allocl) { 303 DBG("%s: p: %d, l: %d, a: %d\n", 304 pathp, (int)strlen(p), l, allocl); 305 } 306 #endif 307 p += strlen(p); 308 } 309 *(p++) = '/'; 310 memcpy(p, pathp, l); 311 } else 312 memcpy(np->full_name, pathp, l); 313 prev_pp = &np->properties; 314 **allnextpp = np; 315 *allnextpp = &np->allnext; 316 if (dad != NULL) { 317 np->parent = dad; 318 /* we temporarily use the next field as `last_child'*/ 319 if (dad->next == 0) 320 dad->child = np; 321 else 322 dad->next->sibling = np; 323 dad->next = np; 324 } 325 kref_init(&np->kref); 326 } 327 while(1) { 328 u32 sz, noff; 329 char *pname; 330 331 tag = *((u32 *)(*p)); 332 if (tag == OF_DT_NOP) { 333 *p += 4; 334 continue; 335 } 336 if (tag != OF_DT_PROP) 337 break; 338 *p += 4; 339 sz = *((u32 *)(*p)); 340 noff = *((u32 *)((*p) + 4)); 341 *p += 8; 342 if (initial_boot_params->version < 0x10) 343 *p = _ALIGN(*p, sz >= 8 ? 8 : 4); 344 345 pname = find_flat_dt_string(noff); 346 if (pname == NULL) { 347 printk("Can't find property name in list !\n"); 348 break; 349 } 350 if (strcmp(pname, "name") == 0) 351 has_name = 1; 352 l = strlen(pname) + 1; 353 pp = unflatten_dt_alloc(&mem, sizeof(struct property), 354 __alignof__(struct property)); 355 if (allnextpp) { 356 if (strcmp(pname, "linux,phandle") == 0) { 357 np->node = *((u32 *)*p); 358 if (np->linux_phandle == 0) 359 np->linux_phandle = np->node; 360 } 361 if (strcmp(pname, "ibm,phandle") == 0) 362 np->linux_phandle = *((u32 *)*p); 363 pp->name = pname; 364 pp->length = sz; 365 pp->value = (void *)*p; 366 *prev_pp = pp; 367 prev_pp = &pp->next; 368 } 369 *p = _ALIGN((*p) + sz, 4); 370 } 371 /* with version 0x10 we may not have the name property, recreate 372 * it here from the unit name if absent 373 */ 374 if (!has_name) { 375 char *p = pathp, *ps = pathp, *pa = NULL; 376 int sz; 377 378 while (*p) { 379 if ((*p) == '@') 380 pa = p; 381 if ((*p) == '/') 382 ps = p + 1; 383 p++; 384 } 385 if (pa < ps) 386 pa = p; 387 sz = (pa - ps) + 1; 388 pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz, 389 __alignof__(struct property)); 390 if (allnextpp) { 391 pp->name = "name"; 392 pp->length = sz; 393 pp->value = pp + 1; 394 *prev_pp = pp; 395 prev_pp = &pp->next; 396 memcpy(pp->value, ps, sz - 1); 397 ((char *)pp->value)[sz - 1] = 0; 398 DBG("fixed up name for %s -> %s\n", pathp, 399 (char *)pp->value); 400 } 401 } 402 if (allnextpp) { 403 *prev_pp = NULL; 404 np->name = of_get_property(np, "name", NULL); 405 np->type = of_get_property(np, "device_type", NULL); 406 407 if (!np->name) 408 np->name = "<NULL>"; 409 if (!np->type) 410 np->type = "<NULL>"; 411 } 412 while (tag == OF_DT_BEGIN_NODE) { 413 mem = unflatten_dt_node(mem, p, np, allnextpp, fpsize); 414 tag = *((u32 *)(*p)); 415 } 416 if (tag != OF_DT_END_NODE) { 417 printk("Weird tag at end of node: %x\n", tag); 418 return mem; 419 } 420 *p += 4; 421 return mem; 422 } 423 424 static int __init early_parse_mem(char *p) 425 { 426 if (!p) 427 return 1; 428 429 memory_limit = PAGE_ALIGN(memparse(p, &p)); 430 DBG("memory limit = 0x%lx\n", memory_limit); 431 432 return 0; 433 } 434 early_param("mem", early_parse_mem); 435 436 /* 437 * The device tree may be allocated below our memory limit, or inside the 438 * crash kernel region for kdump. If so, move it out now. 439 */ 440 static void move_device_tree(void) 441 { 442 unsigned long start, size; 443 void *p; 444 445 DBG("-> move_device_tree\n"); 446 447 start = __pa(initial_boot_params); 448 size = initial_boot_params->totalsize; 449 450 if ((memory_limit && (start + size) > memory_limit) || 451 overlaps_crashkernel(start, size)) { 452 p = __va(lmb_alloc_base(size, PAGE_SIZE, lmb.rmo_size)); 453 memcpy(p, initial_boot_params, size); 454 initial_boot_params = (struct boot_param_header *)p; 455 DBG("Moved device tree to 0x%p\n", p); 456 } 457 458 DBG("<- move_device_tree\n"); 459 } 460 461 /** 462 * unflattens the device-tree passed by the firmware, creating the 463 * tree of struct device_node. It also fills the "name" and "type" 464 * pointers of the nodes so the normal device-tree walking functions 465 * can be used (this used to be done by finish_device_tree) 466 */ 467 void __init unflatten_device_tree(void) 468 { 469 unsigned long start, mem, size; 470 struct device_node **allnextp = &allnodes; 471 472 DBG(" -> unflatten_device_tree()\n"); 473 474 /* First pass, scan for size */ 475 start = ((unsigned long)initial_boot_params) + 476 initial_boot_params->off_dt_struct; 477 size = unflatten_dt_node(0, &start, NULL, NULL, 0); 478 size = (size | 3) + 1; 479 480 DBG(" size is %lx, allocating...\n", size); 481 482 /* Allocate memory for the expanded device tree */ 483 mem = lmb_alloc(size + 4, __alignof__(struct device_node)); 484 mem = (unsigned long) __va(mem); 485 486 ((u32 *)mem)[size / 4] = 0xdeadbeef; 487 488 DBG(" unflattening %lx...\n", mem); 489 490 /* Second pass, do actual unflattening */ 491 start = ((unsigned long)initial_boot_params) + 492 initial_boot_params->off_dt_struct; 493 unflatten_dt_node(mem, &start, NULL, &allnextp, 0); 494 if (*((u32 *)start) != OF_DT_END) 495 printk(KERN_WARNING "Weird tag at end of tree: %08x\n", *((u32 *)start)); 496 if (((u32 *)mem)[size / 4] != 0xdeadbeef) 497 printk(KERN_WARNING "End of tree marker overwritten: %08x\n", 498 ((u32 *)mem)[size / 4] ); 499 *allnextp = NULL; 500 501 /* Get pointer to OF "/chosen" node for use everywhere */ 502 of_chosen = of_find_node_by_path("/chosen"); 503 if (of_chosen == NULL) 504 of_chosen = of_find_node_by_path("/chosen@0"); 505 506 DBG(" <- unflatten_device_tree()\n"); 507 } 508 509 /* 510 * ibm,pa-features is a per-cpu property that contains a string of 511 * attribute descriptors, each of which has a 2 byte header plus up 512 * to 254 bytes worth of processor attribute bits. First header 513 * byte specifies the number of bytes following the header. 514 * Second header byte is an "attribute-specifier" type, of which 515 * zero is the only currently-defined value. 516 * Implementation: Pass in the byte and bit offset for the feature 517 * that we are interested in. The function will return -1 if the 518 * pa-features property is missing, or a 1/0 to indicate if the feature 519 * is supported/not supported. Note that the bit numbers are 520 * big-endian to match the definition in PAPR. 521 */ 522 static struct ibm_pa_feature { 523 unsigned long cpu_features; /* CPU_FTR_xxx bit */ 524 unsigned int cpu_user_ftrs; /* PPC_FEATURE_xxx bit */ 525 unsigned char pabyte; /* byte number in ibm,pa-features */ 526 unsigned char pabit; /* bit number (big-endian) */ 527 unsigned char invert; /* if 1, pa bit set => clear feature */ 528 } ibm_pa_features[] __initdata = { 529 {0, PPC_FEATURE_HAS_MMU, 0, 0, 0}, 530 {0, PPC_FEATURE_HAS_FPU, 0, 1, 0}, 531 {CPU_FTR_SLB, 0, 0, 2, 0}, 532 {CPU_FTR_CTRL, 0, 0, 3, 0}, 533 {CPU_FTR_NOEXECUTE, 0, 0, 6, 0}, 534 {CPU_FTR_NODSISRALIGN, 0, 1, 1, 1}, 535 #if 0 536 /* put this back once we know how to test if firmware does 64k IO */ 537 {CPU_FTR_CI_LARGE_PAGE, 0, 1, 2, 0}, 538 #endif 539 {CPU_FTR_REAL_LE, PPC_FEATURE_TRUE_LE, 5, 0, 0}, 540 }; 541 542 static void __init scan_features(unsigned long node, unsigned char *ftrs, 543 unsigned long tablelen, 544 struct ibm_pa_feature *fp, 545 unsigned long ft_size) 546 { 547 unsigned long i, len, bit; 548 549 /* find descriptor with type == 0 */ 550 for (;;) { 551 if (tablelen < 3) 552 return; 553 len = 2 + ftrs[0]; 554 if (tablelen < len) 555 return; /* descriptor 0 not found */ 556 if (ftrs[1] == 0) 557 break; 558 tablelen -= len; 559 ftrs += len; 560 } 561 562 /* loop over bits we know about */ 563 for (i = 0; i < ft_size; ++i, ++fp) { 564 if (fp->pabyte >= ftrs[0]) 565 continue; 566 bit = (ftrs[2 + fp->pabyte] >> (7 - fp->pabit)) & 1; 567 if (bit ^ fp->invert) { 568 cur_cpu_spec->cpu_features |= fp->cpu_features; 569 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftrs; 570 } else { 571 cur_cpu_spec->cpu_features &= ~fp->cpu_features; 572 cur_cpu_spec->cpu_user_features &= ~fp->cpu_user_ftrs; 573 } 574 } 575 } 576 577 static void __init check_cpu_pa_features(unsigned long node) 578 { 579 unsigned char *pa_ftrs; 580 unsigned long tablelen; 581 582 pa_ftrs = of_get_flat_dt_prop(node, "ibm,pa-features", &tablelen); 583 if (pa_ftrs == NULL) 584 return; 585 586 scan_features(node, pa_ftrs, tablelen, 587 ibm_pa_features, ARRAY_SIZE(ibm_pa_features)); 588 } 589 590 static struct feature_property { 591 const char *name; 592 u32 min_value; 593 unsigned long cpu_feature; 594 unsigned long cpu_user_ftr; 595 } feature_properties[] __initdata = { 596 #ifdef CONFIG_ALTIVEC 597 {"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC}, 598 {"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC}, 599 #endif /* CONFIG_ALTIVEC */ 600 #ifdef CONFIG_PPC64 601 {"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP}, 602 {"ibm,purr", 1, CPU_FTR_PURR, 0}, 603 {"ibm,spurr", 1, CPU_FTR_SPURR, 0}, 604 #endif /* CONFIG_PPC64 */ 605 }; 606 607 static void __init check_cpu_feature_properties(unsigned long node) 608 { 609 unsigned long i; 610 struct feature_property *fp = feature_properties; 611 const u32 *prop; 612 613 for (i = 0; i < ARRAY_SIZE(feature_properties); ++i, ++fp) { 614 prop = of_get_flat_dt_prop(node, fp->name, NULL); 615 if (prop && *prop >= fp->min_value) { 616 cur_cpu_spec->cpu_features |= fp->cpu_feature; 617 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr; 618 } 619 } 620 } 621 622 static int __init early_init_dt_scan_cpus(unsigned long node, 623 const char *uname, int depth, 624 void *data) 625 { 626 static int logical_cpuid = 0; 627 char *type = of_get_flat_dt_prop(node, "device_type", NULL); 628 const u32 *prop; 629 const u32 *intserv; 630 int i, nthreads; 631 unsigned long len; 632 int found = 0; 633 634 /* We are scanning "cpu" nodes only */ 635 if (type == NULL || strcmp(type, "cpu") != 0) 636 return 0; 637 638 /* Get physical cpuid */ 639 intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len); 640 if (intserv) { 641 nthreads = len / sizeof(int); 642 } else { 643 intserv = of_get_flat_dt_prop(node, "reg", NULL); 644 nthreads = 1; 645 } 646 647 /* 648 * Now see if any of these threads match our boot cpu. 649 * NOTE: This must match the parsing done in smp_setup_cpu_maps. 650 */ 651 for (i = 0; i < nthreads; i++) { 652 /* 653 * version 2 of the kexec param format adds the phys cpuid of 654 * booted proc. 655 */ 656 if (initial_boot_params && initial_boot_params->version >= 2) { 657 if (intserv[i] == 658 initial_boot_params->boot_cpuid_phys) { 659 found = 1; 660 break; 661 } 662 } else { 663 /* 664 * Check if it's the boot-cpu, set it's hw index now, 665 * unfortunately this format did not support booting 666 * off secondary threads. 667 */ 668 if (of_get_flat_dt_prop(node, 669 "linux,boot-cpu", NULL) != NULL) { 670 found = 1; 671 break; 672 } 673 } 674 675 #ifdef CONFIG_SMP 676 /* logical cpu id is always 0 on UP kernels */ 677 logical_cpuid++; 678 #endif 679 } 680 681 if (found) { 682 DBG("boot cpu: logical %d physical %d\n", logical_cpuid, 683 intserv[i]); 684 boot_cpuid = logical_cpuid; 685 set_hard_smp_processor_id(boot_cpuid, intserv[i]); 686 687 /* 688 * PAPR defines "logical" PVR values for cpus that 689 * meet various levels of the architecture: 690 * 0x0f000001 Architecture version 2.04 691 * 0x0f000002 Architecture version 2.05 692 * If the cpu-version property in the cpu node contains 693 * such a value, we call identify_cpu again with the 694 * logical PVR value in order to use the cpu feature 695 * bits appropriate for the architecture level. 696 * 697 * A POWER6 partition in "POWER6 architected" mode 698 * uses the 0x0f000002 PVR value; in POWER5+ mode 699 * it uses 0x0f000001. 700 */ 701 prop = of_get_flat_dt_prop(node, "cpu-version", NULL); 702 if (prop && (*prop & 0xff000000) == 0x0f000000) 703 identify_cpu(0, *prop); 704 } 705 706 check_cpu_feature_properties(node); 707 check_cpu_pa_features(node); 708 709 #ifdef CONFIG_PPC_PSERIES 710 if (nthreads > 1) 711 cur_cpu_spec->cpu_features |= CPU_FTR_SMT; 712 else 713 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT; 714 #endif 715 716 return 0; 717 } 718 719 static int __init early_init_dt_scan_chosen(unsigned long node, 720 const char *uname, int depth, void *data) 721 { 722 unsigned long *lprop; 723 u32 *prop; 724 unsigned long l; 725 char *p; 726 727 DBG("search \"chosen\", depth: %d, uname: %s\n", depth, uname); 728 729 if (depth != 1 || 730 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0)) 731 return 0; 732 733 #ifdef CONFIG_PPC64 734 /* check if iommu is forced on or off */ 735 if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL) 736 iommu_is_off = 1; 737 if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL) 738 iommu_force_on = 1; 739 #endif 740 741 /* mem=x on the command line is the preferred mechanism */ 742 lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL); 743 if (lprop) 744 memory_limit = *lprop; 745 746 #ifdef CONFIG_PPC64 747 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL); 748 if (lprop) 749 tce_alloc_start = *lprop; 750 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL); 751 if (lprop) 752 tce_alloc_end = *lprop; 753 #endif 754 755 #ifdef CONFIG_KEXEC 756 lprop = (u64*)of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL); 757 if (lprop) 758 crashk_res.start = *lprop; 759 760 lprop = (u64*)of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL); 761 if (lprop) 762 crashk_res.end = crashk_res.start + *lprop - 1; 763 #endif 764 765 #ifdef CONFIG_BLK_DEV_INITRD 766 DBG("Looking for initrd properties... "); 767 prop = of_get_flat_dt_prop(node, "linux,initrd-start", &l); 768 if (prop) { 769 initrd_start = (unsigned long)__va(of_read_ulong(prop, l/4)); 770 prop = of_get_flat_dt_prop(node, "linux,initrd-end", &l); 771 if (prop) { 772 initrd_end = (unsigned long)__va(of_read_ulong(prop, l/4)); 773 initrd_below_start_ok = 1; 774 } else { 775 initrd_start = 0; 776 } 777 } 778 DBG("initrd_start=0x%lx initrd_end=0x%lx\n", initrd_start, initrd_end); 779 #endif /* CONFIG_BLK_DEV_INITRD */ 780 781 /* Retreive command line */ 782 p = of_get_flat_dt_prop(node, "bootargs", &l); 783 if (p != NULL && l > 0) 784 strlcpy(cmd_line, p, min((int)l, COMMAND_LINE_SIZE)); 785 786 #ifdef CONFIG_CMDLINE 787 if (p == NULL || l == 0 || (l == 1 && (*p) == 0)) 788 strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE); 789 #endif /* CONFIG_CMDLINE */ 790 791 DBG("Command line is: %s\n", cmd_line); 792 793 /* break now */ 794 return 1; 795 } 796 797 static int __init early_init_dt_scan_root(unsigned long node, 798 const char *uname, int depth, void *data) 799 { 800 u32 *prop; 801 802 if (depth != 0) 803 return 0; 804 805 prop = of_get_flat_dt_prop(node, "#size-cells", NULL); 806 dt_root_size_cells = (prop == NULL) ? 1 : *prop; 807 DBG("dt_root_size_cells = %x\n", dt_root_size_cells); 808 809 prop = of_get_flat_dt_prop(node, "#address-cells", NULL); 810 dt_root_addr_cells = (prop == NULL) ? 2 : *prop; 811 DBG("dt_root_addr_cells = %x\n", dt_root_addr_cells); 812 813 /* break now */ 814 return 1; 815 } 816 817 static unsigned long __init dt_mem_next_cell(int s, cell_t **cellp) 818 { 819 cell_t *p = *cellp; 820 821 *cellp = p + s; 822 return of_read_ulong(p, s); 823 } 824 825 #ifdef CONFIG_PPC_PSERIES 826 /* 827 * Interpret the ibm,dynamic-memory property in the 828 * /ibm,dynamic-reconfiguration-memory node. 829 * This contains a list of memory blocks along with NUMA affinity 830 * information. 831 */ 832 static int __init early_init_dt_scan_drconf_memory(unsigned long node) 833 { 834 cell_t *dm, *ls; 835 unsigned long l, n; 836 unsigned long base, size, lmb_size, flags; 837 838 ls = (cell_t *)of_get_flat_dt_prop(node, "ibm,lmb-size", &l); 839 if (ls == NULL || l < dt_root_size_cells * sizeof(cell_t)) 840 return 0; 841 lmb_size = dt_mem_next_cell(dt_root_size_cells, &ls); 842 843 dm = (cell_t *)of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l); 844 if (dm == NULL || l < sizeof(cell_t)) 845 return 0; 846 847 n = *dm++; /* number of entries */ 848 if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(cell_t)) 849 return 0; 850 851 for (; n != 0; --n) { 852 base = dt_mem_next_cell(dt_root_addr_cells, &dm); 853 flags = dm[3]; 854 /* skip DRC index, pad, assoc. list index, flags */ 855 dm += 4; 856 /* skip this block if the reserved bit is set in flags (0x80) 857 or if the block is not assigned to this partition (0x8) */ 858 if ((flags & 0x80) || !(flags & 0x8)) 859 continue; 860 size = lmb_size; 861 if (iommu_is_off) { 862 if (base >= 0x80000000ul) 863 continue; 864 if ((base + size) > 0x80000000ul) 865 size = 0x80000000ul - base; 866 } 867 lmb_add(base, size); 868 } 869 lmb_dump_all(); 870 return 0; 871 } 872 #else 873 #define early_init_dt_scan_drconf_memory(node) 0 874 #endif /* CONFIG_PPC_PSERIES */ 875 876 static int __init early_init_dt_scan_memory(unsigned long node, 877 const char *uname, int depth, void *data) 878 { 879 char *type = of_get_flat_dt_prop(node, "device_type", NULL); 880 cell_t *reg, *endp; 881 unsigned long l; 882 883 /* Look for the ibm,dynamic-reconfiguration-memory node */ 884 if (depth == 1 && 885 strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0) 886 return early_init_dt_scan_drconf_memory(node); 887 888 /* We are scanning "memory" nodes only */ 889 if (type == NULL) { 890 /* 891 * The longtrail doesn't have a device_type on the 892 * /memory node, so look for the node called /memory@0. 893 */ 894 if (depth != 1 || strcmp(uname, "memory@0") != 0) 895 return 0; 896 } else if (strcmp(type, "memory") != 0) 897 return 0; 898 899 reg = (cell_t *)of_get_flat_dt_prop(node, "linux,usable-memory", &l); 900 if (reg == NULL) 901 reg = (cell_t *)of_get_flat_dt_prop(node, "reg", &l); 902 if (reg == NULL) 903 return 0; 904 905 endp = reg + (l / sizeof(cell_t)); 906 907 DBG("memory scan node %s, reg size %ld, data: %x %x %x %x,\n", 908 uname, l, reg[0], reg[1], reg[2], reg[3]); 909 910 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) { 911 unsigned long base, size; 912 913 base = dt_mem_next_cell(dt_root_addr_cells, ®); 914 size = dt_mem_next_cell(dt_root_size_cells, ®); 915 916 if (size == 0) 917 continue; 918 DBG(" - %lx , %lx\n", base, size); 919 #ifdef CONFIG_PPC64 920 if (iommu_is_off) { 921 if (base >= 0x80000000ul) 922 continue; 923 if ((base + size) > 0x80000000ul) 924 size = 0x80000000ul - base; 925 } 926 #endif 927 lmb_add(base, size); 928 } 929 return 0; 930 } 931 932 static void __init early_reserve_mem(void) 933 { 934 u64 base, size; 935 u64 *reserve_map; 936 unsigned long self_base; 937 unsigned long self_size; 938 939 reserve_map = (u64 *)(((unsigned long)initial_boot_params) + 940 initial_boot_params->off_mem_rsvmap); 941 942 /* before we do anything, lets reserve the dt blob */ 943 self_base = __pa((unsigned long)initial_boot_params); 944 self_size = initial_boot_params->totalsize; 945 lmb_reserve(self_base, self_size); 946 947 #ifdef CONFIG_BLK_DEV_INITRD 948 /* then reserve the initrd, if any */ 949 if (initrd_start && (initrd_end > initrd_start)) 950 lmb_reserve(__pa(initrd_start), initrd_end - initrd_start); 951 #endif /* CONFIG_BLK_DEV_INITRD */ 952 953 #ifdef CONFIG_PPC32 954 /* 955 * Handle the case where we might be booting from an old kexec 956 * image that setup the mem_rsvmap as pairs of 32-bit values 957 */ 958 if (*reserve_map > 0xffffffffull) { 959 u32 base_32, size_32; 960 u32 *reserve_map_32 = (u32 *)reserve_map; 961 962 while (1) { 963 base_32 = *(reserve_map_32++); 964 size_32 = *(reserve_map_32++); 965 if (size_32 == 0) 966 break; 967 /* skip if the reservation is for the blob */ 968 if (base_32 == self_base && size_32 == self_size) 969 continue; 970 DBG("reserving: %x -> %x\n", base_32, size_32); 971 lmb_reserve(base_32, size_32); 972 } 973 return; 974 } 975 #endif 976 while (1) { 977 base = *(reserve_map++); 978 size = *(reserve_map++); 979 if (size == 0) 980 break; 981 DBG("reserving: %llx -> %llx\n", base, size); 982 lmb_reserve(base, size); 983 } 984 985 #if 0 986 DBG("memory reserved, lmbs :\n"); 987 lmb_dump_all(); 988 #endif 989 } 990 991 void __init early_init_devtree(void *params) 992 { 993 DBG(" -> early_init_devtree()\n"); 994 995 /* Setup flat device-tree pointer */ 996 initial_boot_params = params; 997 998 #ifdef CONFIG_PPC_RTAS 999 /* Some machines might need RTAS info for debugging, grab it now. */ 1000 of_scan_flat_dt(early_init_dt_scan_rtas, NULL); 1001 #endif 1002 1003 /* Retrieve various informations from the /chosen node of the 1004 * device-tree, including the platform type, initrd location and 1005 * size, TCE reserve, and more ... 1006 */ 1007 of_scan_flat_dt(early_init_dt_scan_chosen, NULL); 1008 1009 /* Scan memory nodes and rebuild LMBs */ 1010 lmb_init(); 1011 of_scan_flat_dt(early_init_dt_scan_root, NULL); 1012 of_scan_flat_dt(early_init_dt_scan_memory, NULL); 1013 1014 /* Save command line for /proc/cmdline and then parse parameters */ 1015 strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE); 1016 parse_early_param(); 1017 1018 /* Reserve LMB regions used by kernel, initrd, dt, etc... */ 1019 lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START); 1020 reserve_kdump_trampoline(); 1021 reserve_crashkernel(); 1022 early_reserve_mem(); 1023 1024 lmb_enforce_memory_limit(memory_limit); 1025 lmb_analyze(); 1026 1027 DBG("Phys. mem: %lx\n", lmb_phys_mem_size()); 1028 1029 /* We may need to relocate the flat tree, do it now. 1030 * FIXME .. and the initrd too? */ 1031 move_device_tree(); 1032 1033 DBG("Scanning CPUs ...\n"); 1034 1035 /* Retreive CPU related informations from the flat tree 1036 * (altivec support, boot CPU ID, ...) 1037 */ 1038 of_scan_flat_dt(early_init_dt_scan_cpus, NULL); 1039 1040 DBG(" <- early_init_devtree()\n"); 1041 } 1042 1043 #undef printk 1044 1045 int of_n_addr_cells(struct device_node* np) 1046 { 1047 const int *ip; 1048 do { 1049 if (np->parent) 1050 np = np->parent; 1051 ip = of_get_property(np, "#address-cells", NULL); 1052 if (ip != NULL) 1053 return *ip; 1054 } while (np->parent); 1055 /* No #address-cells property for the root node, default to 1 */ 1056 return 1; 1057 } 1058 EXPORT_SYMBOL(of_n_addr_cells); 1059 1060 int of_n_size_cells(struct device_node* np) 1061 { 1062 const int* ip; 1063 do { 1064 if (np->parent) 1065 np = np->parent; 1066 ip = of_get_property(np, "#size-cells", NULL); 1067 if (ip != NULL) 1068 return *ip; 1069 } while (np->parent); 1070 /* No #size-cells property for the root node, default to 1 */ 1071 return 1; 1072 } 1073 EXPORT_SYMBOL(of_n_size_cells); 1074 1075 /** Checks if the given "compat" string matches one of the strings in 1076 * the device's "compatible" property 1077 */ 1078 int of_device_is_compatible(const struct device_node *device, 1079 const char *compat) 1080 { 1081 const char* cp; 1082 int cplen, l; 1083 1084 cp = of_get_property(device, "compatible", &cplen); 1085 if (cp == NULL) 1086 return 0; 1087 while (cplen > 0) { 1088 if (strncasecmp(cp, compat, strlen(compat)) == 0) 1089 return 1; 1090 l = strlen(cp) + 1; 1091 cp += l; 1092 cplen -= l; 1093 } 1094 1095 return 0; 1096 } 1097 EXPORT_SYMBOL(of_device_is_compatible); 1098 1099 1100 /** 1101 * Indicates whether the root node has a given value in its 1102 * compatible property. 1103 */ 1104 int machine_is_compatible(const char *compat) 1105 { 1106 struct device_node *root; 1107 int rc = 0; 1108 1109 root = of_find_node_by_path("/"); 1110 if (root) { 1111 rc = of_device_is_compatible(root, compat); 1112 of_node_put(root); 1113 } 1114 return rc; 1115 } 1116 EXPORT_SYMBOL(machine_is_compatible); 1117 1118 /******* 1119 * 1120 * New implementation of the OF "find" APIs, return a refcounted 1121 * object, call of_node_put() when done. The device tree and list 1122 * are protected by a rw_lock. 1123 * 1124 * Note that property management will need some locking as well, 1125 * this isn't dealt with yet. 1126 * 1127 *******/ 1128 1129 /** 1130 * of_find_node_by_name - Find a node by its "name" property 1131 * @from: The node to start searching from or NULL, the node 1132 * you pass will not be searched, only the next one 1133 * will; typically, you pass what the previous call 1134 * returned. of_node_put() will be called on it 1135 * @name: The name string to match against 1136 * 1137 * Returns a node pointer with refcount incremented, use 1138 * of_node_put() on it when done. 1139 */ 1140 struct device_node *of_find_node_by_name(struct device_node *from, 1141 const char *name) 1142 { 1143 struct device_node *np; 1144 1145 read_lock(&devtree_lock); 1146 np = from ? from->allnext : allnodes; 1147 for (; np != NULL; np = np->allnext) 1148 if (np->name != NULL && strcasecmp(np->name, name) == 0 1149 && of_node_get(np)) 1150 break; 1151 of_node_put(from); 1152 read_unlock(&devtree_lock); 1153 return np; 1154 } 1155 EXPORT_SYMBOL(of_find_node_by_name); 1156 1157 /** 1158 * of_find_node_by_type - Find a node by its "device_type" property 1159 * @from: The node to start searching from or NULL, the node 1160 * you pass will not be searched, only the next one 1161 * will; typically, you pass what the previous call 1162 * returned. of_node_put() will be called on it 1163 * @name: The type string to match against 1164 * 1165 * Returns a node pointer with refcount incremented, use 1166 * of_node_put() on it when done. 1167 */ 1168 struct device_node *of_find_node_by_type(struct device_node *from, 1169 const char *type) 1170 { 1171 struct device_node *np; 1172 1173 read_lock(&devtree_lock); 1174 np = from ? from->allnext : allnodes; 1175 for (; np != 0; np = np->allnext) 1176 if (np->type != 0 && strcasecmp(np->type, type) == 0 1177 && of_node_get(np)) 1178 break; 1179 of_node_put(from); 1180 read_unlock(&devtree_lock); 1181 return np; 1182 } 1183 EXPORT_SYMBOL(of_find_node_by_type); 1184 1185 /** 1186 * of_find_compatible_node - Find a node based on type and one of the 1187 * tokens in its "compatible" property 1188 * @from: The node to start searching from or NULL, the node 1189 * you pass will not be searched, only the next one 1190 * will; typically, you pass what the previous call 1191 * returned. of_node_put() will be called on it 1192 * @type: The type string to match "device_type" or NULL to ignore 1193 * @compatible: The string to match to one of the tokens in the device 1194 * "compatible" list. 1195 * 1196 * Returns a node pointer with refcount incremented, use 1197 * of_node_put() on it when done. 1198 */ 1199 struct device_node *of_find_compatible_node(struct device_node *from, 1200 const char *type, const char *compatible) 1201 { 1202 struct device_node *np; 1203 1204 read_lock(&devtree_lock); 1205 np = from ? from->allnext : allnodes; 1206 for (; np != 0; np = np->allnext) { 1207 if (type != NULL 1208 && !(np->type != 0 && strcasecmp(np->type, type) == 0)) 1209 continue; 1210 if (of_device_is_compatible(np, compatible) && of_node_get(np)) 1211 break; 1212 } 1213 of_node_put(from); 1214 read_unlock(&devtree_lock); 1215 return np; 1216 } 1217 EXPORT_SYMBOL(of_find_compatible_node); 1218 1219 /** 1220 * of_find_node_by_path - Find a node matching a full OF path 1221 * @path: The full path to match 1222 * 1223 * Returns a node pointer with refcount incremented, use 1224 * of_node_put() on it when done. 1225 */ 1226 struct device_node *of_find_node_by_path(const char *path) 1227 { 1228 struct device_node *np = allnodes; 1229 1230 read_lock(&devtree_lock); 1231 for (; np != 0; np = np->allnext) { 1232 if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0 1233 && of_node_get(np)) 1234 break; 1235 } 1236 read_unlock(&devtree_lock); 1237 return np; 1238 } 1239 EXPORT_SYMBOL(of_find_node_by_path); 1240 1241 /** 1242 * of_find_node_by_phandle - Find a node given a phandle 1243 * @handle: phandle of the node to find 1244 * 1245 * Returns a node pointer with refcount incremented, use 1246 * of_node_put() on it when done. 1247 */ 1248 struct device_node *of_find_node_by_phandle(phandle handle) 1249 { 1250 struct device_node *np; 1251 1252 read_lock(&devtree_lock); 1253 for (np = allnodes; np != 0; np = np->allnext) 1254 if (np->linux_phandle == handle) 1255 break; 1256 of_node_get(np); 1257 read_unlock(&devtree_lock); 1258 return np; 1259 } 1260 EXPORT_SYMBOL(of_find_node_by_phandle); 1261 1262 /** 1263 * of_find_all_nodes - Get next node in global list 1264 * @prev: Previous node or NULL to start iteration 1265 * of_node_put() will be called on it 1266 * 1267 * Returns a node pointer with refcount incremented, use 1268 * of_node_put() on it when done. 1269 */ 1270 struct device_node *of_find_all_nodes(struct device_node *prev) 1271 { 1272 struct device_node *np; 1273 1274 read_lock(&devtree_lock); 1275 np = prev ? prev->allnext : allnodes; 1276 for (; np != 0; np = np->allnext) 1277 if (of_node_get(np)) 1278 break; 1279 of_node_put(prev); 1280 read_unlock(&devtree_lock); 1281 return np; 1282 } 1283 EXPORT_SYMBOL(of_find_all_nodes); 1284 1285 /** 1286 * of_get_parent - Get a node's parent if any 1287 * @node: Node to get parent 1288 * 1289 * Returns a node pointer with refcount incremented, use 1290 * of_node_put() on it when done. 1291 */ 1292 struct device_node *of_get_parent(const struct device_node *node) 1293 { 1294 struct device_node *np; 1295 1296 if (!node) 1297 return NULL; 1298 1299 read_lock(&devtree_lock); 1300 np = of_node_get(node->parent); 1301 read_unlock(&devtree_lock); 1302 return np; 1303 } 1304 EXPORT_SYMBOL(of_get_parent); 1305 1306 /** 1307 * of_get_next_child - Iterate a node childs 1308 * @node: parent node 1309 * @prev: previous child of the parent node, or NULL to get first 1310 * 1311 * Returns a node pointer with refcount incremented, use 1312 * of_node_put() on it when done. 1313 */ 1314 struct device_node *of_get_next_child(const struct device_node *node, 1315 struct device_node *prev) 1316 { 1317 struct device_node *next; 1318 1319 read_lock(&devtree_lock); 1320 next = prev ? prev->sibling : node->child; 1321 for (; next != 0; next = next->sibling) 1322 if (of_node_get(next)) 1323 break; 1324 of_node_put(prev); 1325 read_unlock(&devtree_lock); 1326 return next; 1327 } 1328 EXPORT_SYMBOL(of_get_next_child); 1329 1330 /** 1331 * of_node_get - Increment refcount of a node 1332 * @node: Node to inc refcount, NULL is supported to 1333 * simplify writing of callers 1334 * 1335 * Returns node. 1336 */ 1337 struct device_node *of_node_get(struct device_node *node) 1338 { 1339 if (node) 1340 kref_get(&node->kref); 1341 return node; 1342 } 1343 EXPORT_SYMBOL(of_node_get); 1344 1345 static inline struct device_node * kref_to_device_node(struct kref *kref) 1346 { 1347 return container_of(kref, struct device_node, kref); 1348 } 1349 1350 /** 1351 * of_node_release - release a dynamically allocated node 1352 * @kref: kref element of the node to be released 1353 * 1354 * In of_node_put() this function is passed to kref_put() 1355 * as the destructor. 1356 */ 1357 static void of_node_release(struct kref *kref) 1358 { 1359 struct device_node *node = kref_to_device_node(kref); 1360 struct property *prop = node->properties; 1361 1362 if (!OF_IS_DYNAMIC(node)) 1363 return; 1364 while (prop) { 1365 struct property *next = prop->next; 1366 kfree(prop->name); 1367 kfree(prop->value); 1368 kfree(prop); 1369 prop = next; 1370 1371 if (!prop) { 1372 prop = node->deadprops; 1373 node->deadprops = NULL; 1374 } 1375 } 1376 kfree(node->full_name); 1377 kfree(node->data); 1378 kfree(node); 1379 } 1380 1381 /** 1382 * of_node_put - Decrement refcount of a node 1383 * @node: Node to dec refcount, NULL is supported to 1384 * simplify writing of callers 1385 * 1386 */ 1387 void of_node_put(struct device_node *node) 1388 { 1389 if (node) 1390 kref_put(&node->kref, of_node_release); 1391 } 1392 EXPORT_SYMBOL(of_node_put); 1393 1394 /* 1395 * Plug a device node into the tree and global list. 1396 */ 1397 void of_attach_node(struct device_node *np) 1398 { 1399 write_lock(&devtree_lock); 1400 np->sibling = np->parent->child; 1401 np->allnext = allnodes; 1402 np->parent->child = np; 1403 allnodes = np; 1404 write_unlock(&devtree_lock); 1405 } 1406 1407 /* 1408 * "Unplug" a node from the device tree. The caller must hold 1409 * a reference to the node. The memory associated with the node 1410 * is not freed until its refcount goes to zero. 1411 */ 1412 void of_detach_node(const struct device_node *np) 1413 { 1414 struct device_node *parent; 1415 1416 write_lock(&devtree_lock); 1417 1418 parent = np->parent; 1419 1420 if (allnodes == np) 1421 allnodes = np->allnext; 1422 else { 1423 struct device_node *prev; 1424 for (prev = allnodes; 1425 prev->allnext != np; 1426 prev = prev->allnext) 1427 ; 1428 prev->allnext = np->allnext; 1429 } 1430 1431 if (parent->child == np) 1432 parent->child = np->sibling; 1433 else { 1434 struct device_node *prevsib; 1435 for (prevsib = np->parent->child; 1436 prevsib->sibling != np; 1437 prevsib = prevsib->sibling) 1438 ; 1439 prevsib->sibling = np->sibling; 1440 } 1441 1442 write_unlock(&devtree_lock); 1443 } 1444 1445 #ifdef CONFIG_PPC_PSERIES 1446 /* 1447 * Fix up the uninitialized fields in a new device node: 1448 * name, type and pci-specific fields 1449 */ 1450 1451 static int of_finish_dynamic_node(struct device_node *node) 1452 { 1453 struct device_node *parent = of_get_parent(node); 1454 int err = 0; 1455 const phandle *ibm_phandle; 1456 1457 node->name = of_get_property(node, "name", NULL); 1458 node->type = of_get_property(node, "device_type", NULL); 1459 1460 if (!parent) { 1461 err = -ENODEV; 1462 goto out; 1463 } 1464 1465 /* We don't support that function on PowerMac, at least 1466 * not yet 1467 */ 1468 if (machine_is(powermac)) 1469 return -ENODEV; 1470 1471 /* fix up new node's linux_phandle field */ 1472 if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL))) 1473 node->linux_phandle = *ibm_phandle; 1474 1475 out: 1476 of_node_put(parent); 1477 return err; 1478 } 1479 1480 static int prom_reconfig_notifier(struct notifier_block *nb, 1481 unsigned long action, void *node) 1482 { 1483 int err; 1484 1485 switch (action) { 1486 case PSERIES_RECONFIG_ADD: 1487 err = of_finish_dynamic_node(node); 1488 if (err < 0) { 1489 printk(KERN_ERR "finish_node returned %d\n", err); 1490 err = NOTIFY_BAD; 1491 } 1492 break; 1493 default: 1494 err = NOTIFY_DONE; 1495 break; 1496 } 1497 return err; 1498 } 1499 1500 static struct notifier_block prom_reconfig_nb = { 1501 .notifier_call = prom_reconfig_notifier, 1502 .priority = 10, /* This one needs to run first */ 1503 }; 1504 1505 static int __init prom_reconfig_setup(void) 1506 { 1507 return pSeries_reconfig_notifier_register(&prom_reconfig_nb); 1508 } 1509 __initcall(prom_reconfig_setup); 1510 #endif 1511 1512 struct property *of_find_property(const struct device_node *np, 1513 const char *name, 1514 int *lenp) 1515 { 1516 struct property *pp; 1517 1518 read_lock(&devtree_lock); 1519 for (pp = np->properties; pp != 0; pp = pp->next) 1520 if (strcmp(pp->name, name) == 0) { 1521 if (lenp != 0) 1522 *lenp = pp->length; 1523 break; 1524 } 1525 read_unlock(&devtree_lock); 1526 1527 return pp; 1528 } 1529 EXPORT_SYMBOL(of_find_property); 1530 1531 /* 1532 * Find a property with a given name for a given node 1533 * and return the value. 1534 */ 1535 const void *of_get_property(const struct device_node *np, const char *name, 1536 int *lenp) 1537 { 1538 struct property *pp = of_find_property(np,name,lenp); 1539 return pp ? pp->value : NULL; 1540 } 1541 EXPORT_SYMBOL(of_get_property); 1542 1543 /* 1544 * Add a property to a node 1545 */ 1546 int prom_add_property(struct device_node* np, struct property* prop) 1547 { 1548 struct property **next; 1549 1550 prop->next = NULL; 1551 write_lock(&devtree_lock); 1552 next = &np->properties; 1553 while (*next) { 1554 if (strcmp(prop->name, (*next)->name) == 0) { 1555 /* duplicate ! don't insert it */ 1556 write_unlock(&devtree_lock); 1557 return -1; 1558 } 1559 next = &(*next)->next; 1560 } 1561 *next = prop; 1562 write_unlock(&devtree_lock); 1563 1564 #ifdef CONFIG_PROC_DEVICETREE 1565 /* try to add to proc as well if it was initialized */ 1566 if (np->pde) 1567 proc_device_tree_add_prop(np->pde, prop); 1568 #endif /* CONFIG_PROC_DEVICETREE */ 1569 1570 return 0; 1571 } 1572 1573 /* 1574 * Remove a property from a node. Note that we don't actually 1575 * remove it, since we have given out who-knows-how-many pointers 1576 * to the data using get-property. Instead we just move the property 1577 * to the "dead properties" list, so it won't be found any more. 1578 */ 1579 int prom_remove_property(struct device_node *np, struct property *prop) 1580 { 1581 struct property **next; 1582 int found = 0; 1583 1584 write_lock(&devtree_lock); 1585 next = &np->properties; 1586 while (*next) { 1587 if (*next == prop) { 1588 /* found the node */ 1589 *next = prop->next; 1590 prop->next = np->deadprops; 1591 np->deadprops = prop; 1592 found = 1; 1593 break; 1594 } 1595 next = &(*next)->next; 1596 } 1597 write_unlock(&devtree_lock); 1598 1599 if (!found) 1600 return -ENODEV; 1601 1602 #ifdef CONFIG_PROC_DEVICETREE 1603 /* try to remove the proc node as well */ 1604 if (np->pde) 1605 proc_device_tree_remove_prop(np->pde, prop); 1606 #endif /* CONFIG_PROC_DEVICETREE */ 1607 1608 return 0; 1609 } 1610 1611 /* 1612 * Update a property in a node. Note that we don't actually 1613 * remove it, since we have given out who-knows-how-many pointers 1614 * to the data using get-property. Instead we just move the property 1615 * to the "dead properties" list, and add the new property to the 1616 * property list 1617 */ 1618 int prom_update_property(struct device_node *np, 1619 struct property *newprop, 1620 struct property *oldprop) 1621 { 1622 struct property **next; 1623 int found = 0; 1624 1625 write_lock(&devtree_lock); 1626 next = &np->properties; 1627 while (*next) { 1628 if (*next == oldprop) { 1629 /* found the node */ 1630 newprop->next = oldprop->next; 1631 *next = newprop; 1632 oldprop->next = np->deadprops; 1633 np->deadprops = oldprop; 1634 found = 1; 1635 break; 1636 } 1637 next = &(*next)->next; 1638 } 1639 write_unlock(&devtree_lock); 1640 1641 if (!found) 1642 return -ENODEV; 1643 1644 #ifdef CONFIG_PROC_DEVICETREE 1645 /* try to add to proc as well if it was initialized */ 1646 if (np->pde) 1647 proc_device_tree_update_prop(np->pde, newprop, oldprop); 1648 #endif /* CONFIG_PROC_DEVICETREE */ 1649 1650 return 0; 1651 } 1652 1653 1654 /* Find the device node for a given logical cpu number, also returns the cpu 1655 * local thread number (index in ibm,interrupt-server#s) if relevant and 1656 * asked for (non NULL) 1657 */ 1658 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread) 1659 { 1660 int hardid; 1661 struct device_node *np; 1662 1663 hardid = get_hard_smp_processor_id(cpu); 1664 1665 for_each_node_by_type(np, "cpu") { 1666 const u32 *intserv; 1667 unsigned int plen, t; 1668 1669 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist 1670 * fallback to "reg" property and assume no threads 1671 */ 1672 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", 1673 &plen); 1674 if (intserv == NULL) { 1675 const u32 *reg = of_get_property(np, "reg", NULL); 1676 if (reg == NULL) 1677 continue; 1678 if (*reg == hardid) { 1679 if (thread) 1680 *thread = 0; 1681 return np; 1682 } 1683 } else { 1684 plen /= sizeof(u32); 1685 for (t = 0; t < plen; t++) { 1686 if (hardid == intserv[t]) { 1687 if (thread) 1688 *thread = t; 1689 return np; 1690 } 1691 } 1692 } 1693 } 1694 return NULL; 1695 } 1696 EXPORT_SYMBOL(of_get_cpu_node); 1697 1698 #ifdef DEBUG 1699 static struct debugfs_blob_wrapper flat_dt_blob; 1700 1701 static int __init export_flat_device_tree(void) 1702 { 1703 struct dentry *d; 1704 1705 d = debugfs_create_dir("powerpc", NULL); 1706 if (!d) 1707 return 1; 1708 1709 flat_dt_blob.data = initial_boot_params; 1710 flat_dt_blob.size = initial_boot_params->totalsize; 1711 1712 d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR, 1713 d, &flat_dt_blob); 1714 if (!d) 1715 return 1; 1716 1717 return 0; 1718 } 1719 __initcall(export_flat_device_tree); 1720 #endif 1721