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