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