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 /** 1076 * Construct and return a list of the device_nodes with a given name. 1077 */ 1078 struct device_node *find_devices(const char *name) 1079 { 1080 struct device_node *head, **prevp, *np; 1081 1082 prevp = &head; 1083 for (np = allnodes; np != 0; np = np->allnext) { 1084 if (np->name != 0 && strcasecmp(np->name, name) == 0) { 1085 *prevp = np; 1086 prevp = &np->next; 1087 } 1088 } 1089 *prevp = NULL; 1090 return head; 1091 } 1092 EXPORT_SYMBOL(find_devices); 1093 1094 /** Checks if the given "compat" string matches one of the strings in 1095 * the device's "compatible" property 1096 */ 1097 int of_device_is_compatible(const struct device_node *device, 1098 const char *compat) 1099 { 1100 const char* cp; 1101 int cplen, l; 1102 1103 cp = of_get_property(device, "compatible", &cplen); 1104 if (cp == NULL) 1105 return 0; 1106 while (cplen > 0) { 1107 if (strncasecmp(cp, compat, strlen(compat)) == 0) 1108 return 1; 1109 l = strlen(cp) + 1; 1110 cp += l; 1111 cplen -= l; 1112 } 1113 1114 return 0; 1115 } 1116 EXPORT_SYMBOL(of_device_is_compatible); 1117 1118 1119 /** 1120 * Indicates whether the root node has a given value in its 1121 * compatible property. 1122 */ 1123 int machine_is_compatible(const char *compat) 1124 { 1125 struct device_node *root; 1126 int rc = 0; 1127 1128 root = of_find_node_by_path("/"); 1129 if (root) { 1130 rc = of_device_is_compatible(root, compat); 1131 of_node_put(root); 1132 } 1133 return rc; 1134 } 1135 EXPORT_SYMBOL(machine_is_compatible); 1136 1137 /******* 1138 * 1139 * New implementation of the OF "find" APIs, return a refcounted 1140 * object, call of_node_put() when done. The device tree and list 1141 * are protected by a rw_lock. 1142 * 1143 * Note that property management will need some locking as well, 1144 * this isn't dealt with yet. 1145 * 1146 *******/ 1147 1148 /** 1149 * of_find_node_by_name - Find a node by its "name" property 1150 * @from: The node to start searching from or NULL, the node 1151 * you pass will not be searched, only the next one 1152 * will; typically, you pass what the previous call 1153 * returned. of_node_put() will be called on it 1154 * @name: The name string to match against 1155 * 1156 * Returns a node pointer with refcount incremented, use 1157 * of_node_put() on it when done. 1158 */ 1159 struct device_node *of_find_node_by_name(struct device_node *from, 1160 const char *name) 1161 { 1162 struct device_node *np; 1163 1164 read_lock(&devtree_lock); 1165 np = from ? from->allnext : allnodes; 1166 for (; np != NULL; np = np->allnext) 1167 if (np->name != NULL && strcasecmp(np->name, name) == 0 1168 && of_node_get(np)) 1169 break; 1170 of_node_put(from); 1171 read_unlock(&devtree_lock); 1172 return np; 1173 } 1174 EXPORT_SYMBOL(of_find_node_by_name); 1175 1176 /** 1177 * of_find_node_by_type - Find a node by its "device_type" property 1178 * @from: The node to start searching from or NULL, the node 1179 * you pass will not be searched, only the next one 1180 * will; typically, you pass what the previous call 1181 * returned. of_node_put() will be called on it 1182 * @name: The type string to match against 1183 * 1184 * Returns a node pointer with refcount incremented, use 1185 * of_node_put() on it when done. 1186 */ 1187 struct device_node *of_find_node_by_type(struct device_node *from, 1188 const char *type) 1189 { 1190 struct device_node *np; 1191 1192 read_lock(&devtree_lock); 1193 np = from ? from->allnext : allnodes; 1194 for (; np != 0; np = np->allnext) 1195 if (np->type != 0 && strcasecmp(np->type, type) == 0 1196 && of_node_get(np)) 1197 break; 1198 of_node_put(from); 1199 read_unlock(&devtree_lock); 1200 return np; 1201 } 1202 EXPORT_SYMBOL(of_find_node_by_type); 1203 1204 /** 1205 * of_find_compatible_node - Find a node based on type and one of the 1206 * tokens in its "compatible" property 1207 * @from: The node to start searching from or NULL, the node 1208 * you pass will not be searched, only the next one 1209 * will; typically, you pass what the previous call 1210 * returned. of_node_put() will be called on it 1211 * @type: The type string to match "device_type" or NULL to ignore 1212 * @compatible: The string to match to one of the tokens in the device 1213 * "compatible" list. 1214 * 1215 * Returns a node pointer with refcount incremented, use 1216 * of_node_put() on it when done. 1217 */ 1218 struct device_node *of_find_compatible_node(struct device_node *from, 1219 const char *type, const char *compatible) 1220 { 1221 struct device_node *np; 1222 1223 read_lock(&devtree_lock); 1224 np = from ? from->allnext : allnodes; 1225 for (; np != 0; np = np->allnext) { 1226 if (type != NULL 1227 && !(np->type != 0 && strcasecmp(np->type, type) == 0)) 1228 continue; 1229 if (of_device_is_compatible(np, compatible) && of_node_get(np)) 1230 break; 1231 } 1232 of_node_put(from); 1233 read_unlock(&devtree_lock); 1234 return np; 1235 } 1236 EXPORT_SYMBOL(of_find_compatible_node); 1237 1238 /** 1239 * of_find_node_by_path - Find a node matching a full OF path 1240 * @path: The full path to match 1241 * 1242 * Returns a node pointer with refcount incremented, use 1243 * of_node_put() on it when done. 1244 */ 1245 struct device_node *of_find_node_by_path(const char *path) 1246 { 1247 struct device_node *np = allnodes; 1248 1249 read_lock(&devtree_lock); 1250 for (; np != 0; np = np->allnext) { 1251 if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0 1252 && of_node_get(np)) 1253 break; 1254 } 1255 read_unlock(&devtree_lock); 1256 return np; 1257 } 1258 EXPORT_SYMBOL(of_find_node_by_path); 1259 1260 /** 1261 * of_find_node_by_phandle - Find a node given a phandle 1262 * @handle: phandle of the node to find 1263 * 1264 * Returns a node pointer with refcount incremented, use 1265 * of_node_put() on it when done. 1266 */ 1267 struct device_node *of_find_node_by_phandle(phandle handle) 1268 { 1269 struct device_node *np; 1270 1271 read_lock(&devtree_lock); 1272 for (np = allnodes; np != 0; np = np->allnext) 1273 if (np->linux_phandle == handle) 1274 break; 1275 of_node_get(np); 1276 read_unlock(&devtree_lock); 1277 return np; 1278 } 1279 EXPORT_SYMBOL(of_find_node_by_phandle); 1280 1281 /** 1282 * of_find_all_nodes - Get next node in global list 1283 * @prev: Previous node or NULL to start iteration 1284 * of_node_put() will be called on it 1285 * 1286 * Returns a node pointer with refcount incremented, use 1287 * of_node_put() on it when done. 1288 */ 1289 struct device_node *of_find_all_nodes(struct device_node *prev) 1290 { 1291 struct device_node *np; 1292 1293 read_lock(&devtree_lock); 1294 np = prev ? prev->allnext : allnodes; 1295 for (; np != 0; np = np->allnext) 1296 if (of_node_get(np)) 1297 break; 1298 of_node_put(prev); 1299 read_unlock(&devtree_lock); 1300 return np; 1301 } 1302 EXPORT_SYMBOL(of_find_all_nodes); 1303 1304 /** 1305 * of_get_parent - Get a node's parent if any 1306 * @node: Node to get parent 1307 * 1308 * Returns a node pointer with refcount incremented, use 1309 * of_node_put() on it when done. 1310 */ 1311 struct device_node *of_get_parent(const struct device_node *node) 1312 { 1313 struct device_node *np; 1314 1315 if (!node) 1316 return NULL; 1317 1318 read_lock(&devtree_lock); 1319 np = of_node_get(node->parent); 1320 read_unlock(&devtree_lock); 1321 return np; 1322 } 1323 EXPORT_SYMBOL(of_get_parent); 1324 1325 /** 1326 * of_get_next_child - Iterate a node childs 1327 * @node: parent node 1328 * @prev: previous child of the parent node, or NULL to get first 1329 * 1330 * Returns a node pointer with refcount incremented, use 1331 * of_node_put() on it when done. 1332 */ 1333 struct device_node *of_get_next_child(const struct device_node *node, 1334 struct device_node *prev) 1335 { 1336 struct device_node *next; 1337 1338 read_lock(&devtree_lock); 1339 next = prev ? prev->sibling : node->child; 1340 for (; next != 0; next = next->sibling) 1341 if (of_node_get(next)) 1342 break; 1343 of_node_put(prev); 1344 read_unlock(&devtree_lock); 1345 return next; 1346 } 1347 EXPORT_SYMBOL(of_get_next_child); 1348 1349 /** 1350 * of_node_get - Increment refcount of a node 1351 * @node: Node to inc refcount, NULL is supported to 1352 * simplify writing of callers 1353 * 1354 * Returns node. 1355 */ 1356 struct device_node *of_node_get(struct device_node *node) 1357 { 1358 if (node) 1359 kref_get(&node->kref); 1360 return node; 1361 } 1362 EXPORT_SYMBOL(of_node_get); 1363 1364 static inline struct device_node * kref_to_device_node(struct kref *kref) 1365 { 1366 return container_of(kref, struct device_node, kref); 1367 } 1368 1369 /** 1370 * of_node_release - release a dynamically allocated node 1371 * @kref: kref element of the node to be released 1372 * 1373 * In of_node_put() this function is passed to kref_put() 1374 * as the destructor. 1375 */ 1376 static void of_node_release(struct kref *kref) 1377 { 1378 struct device_node *node = kref_to_device_node(kref); 1379 struct property *prop = node->properties; 1380 1381 if (!OF_IS_DYNAMIC(node)) 1382 return; 1383 while (prop) { 1384 struct property *next = prop->next; 1385 kfree(prop->name); 1386 kfree(prop->value); 1387 kfree(prop); 1388 prop = next; 1389 1390 if (!prop) { 1391 prop = node->deadprops; 1392 node->deadprops = NULL; 1393 } 1394 } 1395 kfree(node->full_name); 1396 kfree(node->data); 1397 kfree(node); 1398 } 1399 1400 /** 1401 * of_node_put - Decrement refcount of a node 1402 * @node: Node to dec refcount, NULL is supported to 1403 * simplify writing of callers 1404 * 1405 */ 1406 void of_node_put(struct device_node *node) 1407 { 1408 if (node) 1409 kref_put(&node->kref, of_node_release); 1410 } 1411 EXPORT_SYMBOL(of_node_put); 1412 1413 /* 1414 * Plug a device node into the tree and global list. 1415 */ 1416 void of_attach_node(struct device_node *np) 1417 { 1418 write_lock(&devtree_lock); 1419 np->sibling = np->parent->child; 1420 np->allnext = allnodes; 1421 np->parent->child = np; 1422 allnodes = np; 1423 write_unlock(&devtree_lock); 1424 } 1425 1426 /* 1427 * "Unplug" a node from the device tree. The caller must hold 1428 * a reference to the node. The memory associated with the node 1429 * is not freed until its refcount goes to zero. 1430 */ 1431 void of_detach_node(const struct device_node *np) 1432 { 1433 struct device_node *parent; 1434 1435 write_lock(&devtree_lock); 1436 1437 parent = np->parent; 1438 1439 if (allnodes == np) 1440 allnodes = np->allnext; 1441 else { 1442 struct device_node *prev; 1443 for (prev = allnodes; 1444 prev->allnext != np; 1445 prev = prev->allnext) 1446 ; 1447 prev->allnext = np->allnext; 1448 } 1449 1450 if (parent->child == np) 1451 parent->child = np->sibling; 1452 else { 1453 struct device_node *prevsib; 1454 for (prevsib = np->parent->child; 1455 prevsib->sibling != np; 1456 prevsib = prevsib->sibling) 1457 ; 1458 prevsib->sibling = np->sibling; 1459 } 1460 1461 write_unlock(&devtree_lock); 1462 } 1463 1464 #ifdef CONFIG_PPC_PSERIES 1465 /* 1466 * Fix up the uninitialized fields in a new device node: 1467 * name, type and pci-specific fields 1468 */ 1469 1470 static int of_finish_dynamic_node(struct device_node *node) 1471 { 1472 struct device_node *parent = of_get_parent(node); 1473 int err = 0; 1474 const phandle *ibm_phandle; 1475 1476 node->name = of_get_property(node, "name", NULL); 1477 node->type = of_get_property(node, "device_type", NULL); 1478 1479 if (!parent) { 1480 err = -ENODEV; 1481 goto out; 1482 } 1483 1484 /* We don't support that function on PowerMac, at least 1485 * not yet 1486 */ 1487 if (machine_is(powermac)) 1488 return -ENODEV; 1489 1490 /* fix up new node's linux_phandle field */ 1491 if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL))) 1492 node->linux_phandle = *ibm_phandle; 1493 1494 out: 1495 of_node_put(parent); 1496 return err; 1497 } 1498 1499 static int prom_reconfig_notifier(struct notifier_block *nb, 1500 unsigned long action, void *node) 1501 { 1502 int err; 1503 1504 switch (action) { 1505 case PSERIES_RECONFIG_ADD: 1506 err = of_finish_dynamic_node(node); 1507 if (err < 0) { 1508 printk(KERN_ERR "finish_node returned %d\n", err); 1509 err = NOTIFY_BAD; 1510 } 1511 break; 1512 default: 1513 err = NOTIFY_DONE; 1514 break; 1515 } 1516 return err; 1517 } 1518 1519 static struct notifier_block prom_reconfig_nb = { 1520 .notifier_call = prom_reconfig_notifier, 1521 .priority = 10, /* This one needs to run first */ 1522 }; 1523 1524 static int __init prom_reconfig_setup(void) 1525 { 1526 return pSeries_reconfig_notifier_register(&prom_reconfig_nb); 1527 } 1528 __initcall(prom_reconfig_setup); 1529 #endif 1530 1531 struct property *of_find_property(const struct device_node *np, 1532 const char *name, 1533 int *lenp) 1534 { 1535 struct property *pp; 1536 1537 read_lock(&devtree_lock); 1538 for (pp = np->properties; pp != 0; pp = pp->next) 1539 if (strcmp(pp->name, name) == 0) { 1540 if (lenp != 0) 1541 *lenp = pp->length; 1542 break; 1543 } 1544 read_unlock(&devtree_lock); 1545 1546 return pp; 1547 } 1548 EXPORT_SYMBOL(of_find_property); 1549 1550 /* 1551 * Find a property with a given name for a given node 1552 * and return the value. 1553 */ 1554 const void *of_get_property(const struct device_node *np, const char *name, 1555 int *lenp) 1556 { 1557 struct property *pp = of_find_property(np,name,lenp); 1558 return pp ? pp->value : NULL; 1559 } 1560 EXPORT_SYMBOL(of_get_property); 1561 1562 /* 1563 * Add a property to a node 1564 */ 1565 int prom_add_property(struct device_node* np, struct property* prop) 1566 { 1567 struct property **next; 1568 1569 prop->next = NULL; 1570 write_lock(&devtree_lock); 1571 next = &np->properties; 1572 while (*next) { 1573 if (strcmp(prop->name, (*next)->name) == 0) { 1574 /* duplicate ! don't insert it */ 1575 write_unlock(&devtree_lock); 1576 return -1; 1577 } 1578 next = &(*next)->next; 1579 } 1580 *next = prop; 1581 write_unlock(&devtree_lock); 1582 1583 #ifdef CONFIG_PROC_DEVICETREE 1584 /* try to add to proc as well if it was initialized */ 1585 if (np->pde) 1586 proc_device_tree_add_prop(np->pde, prop); 1587 #endif /* CONFIG_PROC_DEVICETREE */ 1588 1589 return 0; 1590 } 1591 1592 /* 1593 * Remove a property from a node. Note that we don't actually 1594 * remove it, since we have given out who-knows-how-many pointers 1595 * to the data using get-property. Instead we just move the property 1596 * to the "dead properties" list, so it won't be found any more. 1597 */ 1598 int prom_remove_property(struct device_node *np, struct property *prop) 1599 { 1600 struct property **next; 1601 int found = 0; 1602 1603 write_lock(&devtree_lock); 1604 next = &np->properties; 1605 while (*next) { 1606 if (*next == prop) { 1607 /* found the node */ 1608 *next = prop->next; 1609 prop->next = np->deadprops; 1610 np->deadprops = prop; 1611 found = 1; 1612 break; 1613 } 1614 next = &(*next)->next; 1615 } 1616 write_unlock(&devtree_lock); 1617 1618 if (!found) 1619 return -ENODEV; 1620 1621 #ifdef CONFIG_PROC_DEVICETREE 1622 /* try to remove the proc node as well */ 1623 if (np->pde) 1624 proc_device_tree_remove_prop(np->pde, prop); 1625 #endif /* CONFIG_PROC_DEVICETREE */ 1626 1627 return 0; 1628 } 1629 1630 /* 1631 * Update a property in a node. Note that we don't actually 1632 * remove it, since we have given out who-knows-how-many pointers 1633 * to the data using get-property. Instead we just move the property 1634 * to the "dead properties" list, and add the new property to the 1635 * property list 1636 */ 1637 int prom_update_property(struct device_node *np, 1638 struct property *newprop, 1639 struct property *oldprop) 1640 { 1641 struct property **next; 1642 int found = 0; 1643 1644 write_lock(&devtree_lock); 1645 next = &np->properties; 1646 while (*next) { 1647 if (*next == oldprop) { 1648 /* found the node */ 1649 newprop->next = oldprop->next; 1650 *next = newprop; 1651 oldprop->next = np->deadprops; 1652 np->deadprops = oldprop; 1653 found = 1; 1654 break; 1655 } 1656 next = &(*next)->next; 1657 } 1658 write_unlock(&devtree_lock); 1659 1660 if (!found) 1661 return -ENODEV; 1662 1663 #ifdef CONFIG_PROC_DEVICETREE 1664 /* try to add to proc as well if it was initialized */ 1665 if (np->pde) 1666 proc_device_tree_update_prop(np->pde, newprop, oldprop); 1667 #endif /* CONFIG_PROC_DEVICETREE */ 1668 1669 return 0; 1670 } 1671 1672 1673 /* Find the device node for a given logical cpu number, also returns the cpu 1674 * local thread number (index in ibm,interrupt-server#s) if relevant and 1675 * asked for (non NULL) 1676 */ 1677 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread) 1678 { 1679 int hardid; 1680 struct device_node *np; 1681 1682 hardid = get_hard_smp_processor_id(cpu); 1683 1684 for_each_node_by_type(np, "cpu") { 1685 const u32 *intserv; 1686 unsigned int plen, t; 1687 1688 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist 1689 * fallback to "reg" property and assume no threads 1690 */ 1691 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", 1692 &plen); 1693 if (intserv == NULL) { 1694 const u32 *reg = of_get_property(np, "reg", NULL); 1695 if (reg == NULL) 1696 continue; 1697 if (*reg == hardid) { 1698 if (thread) 1699 *thread = 0; 1700 return np; 1701 } 1702 } else { 1703 plen /= sizeof(u32); 1704 for (t = 0; t < plen; t++) { 1705 if (hardid == intserv[t]) { 1706 if (thread) 1707 *thread = t; 1708 return np; 1709 } 1710 } 1711 } 1712 } 1713 return NULL; 1714 } 1715 EXPORT_SYMBOL(of_get_cpu_node); 1716 1717 #ifdef DEBUG 1718 static struct debugfs_blob_wrapper flat_dt_blob; 1719 1720 static int __init export_flat_device_tree(void) 1721 { 1722 struct dentry *d; 1723 1724 d = debugfs_create_dir("powerpc", NULL); 1725 if (!d) 1726 return 1; 1727 1728 flat_dt_blob.data = initial_boot_params; 1729 flat_dt_blob.size = initial_boot_params->totalsize; 1730 1731 d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR, 1732 d, &flat_dt_blob); 1733 if (!d) 1734 return 1; 1735 1736 return 0; 1737 } 1738 __initcall(export_flat_device_tree); 1739 #endif 1740