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; 892 unsigned long l, n, flags; 893 u64 base, size, lmb_size; 894 895 ls = (cell_t *)of_get_flat_dt_prop(node, "ibm,lmb-size", &l); 896 if (ls == NULL || l < dt_root_size_cells * sizeof(cell_t)) 897 return 0; 898 lmb_size = dt_mem_next_cell(dt_root_size_cells, &ls); 899 900 dm = (cell_t *)of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l); 901 if (dm == NULL || l < sizeof(cell_t)) 902 return 0; 903 904 n = *dm++; /* number of entries */ 905 if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(cell_t)) 906 return 0; 907 908 for (; n != 0; --n) { 909 base = dt_mem_next_cell(dt_root_addr_cells, &dm); 910 flags = dm[3]; 911 /* skip DRC index, pad, assoc. list index, flags */ 912 dm += 4; 913 /* skip this block if the reserved bit is set in flags (0x80) 914 or if the block is not assigned to this partition (0x8) */ 915 if ((flags & 0x80) || !(flags & 0x8)) 916 continue; 917 size = lmb_size; 918 if (iommu_is_off) { 919 if (base >= 0x80000000ul) 920 continue; 921 if ((base + size) > 0x80000000ul) 922 size = 0x80000000ul - base; 923 } 924 lmb_add(base, size); 925 } 926 lmb_dump_all(); 927 return 0; 928 } 929 #else 930 #define early_init_dt_scan_drconf_memory(node) 0 931 #endif /* CONFIG_PPC_PSERIES */ 932 933 static int __init early_init_dt_scan_memory(unsigned long node, 934 const char *uname, int depth, void *data) 935 { 936 char *type = of_get_flat_dt_prop(node, "device_type", NULL); 937 cell_t *reg, *endp; 938 unsigned long l; 939 940 /* Look for the ibm,dynamic-reconfiguration-memory node */ 941 if (depth == 1 && 942 strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0) 943 return early_init_dt_scan_drconf_memory(node); 944 945 /* We are scanning "memory" nodes only */ 946 if (type == NULL) { 947 /* 948 * The longtrail doesn't have a device_type on the 949 * /memory node, so look for the node called /memory@0. 950 */ 951 if (depth != 1 || strcmp(uname, "memory@0") != 0) 952 return 0; 953 } else if (strcmp(type, "memory") != 0) 954 return 0; 955 956 reg = (cell_t *)of_get_flat_dt_prop(node, "linux,usable-memory", &l); 957 if (reg == NULL) 958 reg = (cell_t *)of_get_flat_dt_prop(node, "reg", &l); 959 if (reg == NULL) 960 return 0; 961 962 endp = reg + (l / sizeof(cell_t)); 963 964 DBG("memory scan node %s, reg size %ld, data: %x %x %x %x,\n", 965 uname, l, reg[0], reg[1], reg[2], reg[3]); 966 967 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) { 968 u64 base, size; 969 970 base = dt_mem_next_cell(dt_root_addr_cells, ®); 971 size = dt_mem_next_cell(dt_root_size_cells, ®); 972 973 if (size == 0) 974 continue; 975 DBG(" - %llx , %llx\n", (unsigned long long)base, 976 (unsigned long long)size); 977 #ifdef CONFIG_PPC64 978 if (iommu_is_off) { 979 if (base >= 0x80000000ul) 980 continue; 981 if ((base + size) > 0x80000000ul) 982 size = 0x80000000ul - base; 983 } 984 #endif 985 lmb_add(base, size); 986 987 memstart_addr = min((u64)memstart_addr, base); 988 } 989 990 return 0; 991 } 992 993 static void __init early_reserve_mem(void) 994 { 995 u64 base, size; 996 u64 *reserve_map; 997 unsigned long self_base; 998 unsigned long self_size; 999 1000 reserve_map = (u64 *)(((unsigned long)initial_boot_params) + 1001 initial_boot_params->off_mem_rsvmap); 1002 1003 /* before we do anything, lets reserve the dt blob */ 1004 self_base = __pa((unsigned long)initial_boot_params); 1005 self_size = initial_boot_params->totalsize; 1006 lmb_reserve(self_base, self_size); 1007 1008 #ifdef CONFIG_BLK_DEV_INITRD 1009 /* then reserve the initrd, if any */ 1010 if (initrd_start && (initrd_end > initrd_start)) 1011 lmb_reserve(__pa(initrd_start), initrd_end - initrd_start); 1012 #endif /* CONFIG_BLK_DEV_INITRD */ 1013 1014 #ifdef CONFIG_PPC32 1015 /* 1016 * Handle the case where we might be booting from an old kexec 1017 * image that setup the mem_rsvmap as pairs of 32-bit values 1018 */ 1019 if (*reserve_map > 0xffffffffull) { 1020 u32 base_32, size_32; 1021 u32 *reserve_map_32 = (u32 *)reserve_map; 1022 1023 while (1) { 1024 base_32 = *(reserve_map_32++); 1025 size_32 = *(reserve_map_32++); 1026 if (size_32 == 0) 1027 break; 1028 /* skip if the reservation is for the blob */ 1029 if (base_32 == self_base && size_32 == self_size) 1030 continue; 1031 DBG("reserving: %x -> %x\n", base_32, size_32); 1032 lmb_reserve(base_32, size_32); 1033 } 1034 return; 1035 } 1036 #endif 1037 while (1) { 1038 base = *(reserve_map++); 1039 size = *(reserve_map++); 1040 if (size == 0) 1041 break; 1042 DBG("reserving: %llx -> %llx\n", base, size); 1043 lmb_reserve(base, size); 1044 } 1045 1046 #if 0 1047 DBG("memory reserved, lmbs :\n"); 1048 lmb_dump_all(); 1049 #endif 1050 } 1051 1052 #ifdef CONFIG_PHYP_DUMP 1053 /** 1054 * phyp_dump_calculate_reserve_size() - reserve variable boot area 5% or arg 1055 * 1056 * Function to find the largest size we need to reserve 1057 * during early boot process. 1058 * 1059 * It either looks for boot param and returns that OR 1060 * returns larger of 256 or 5% rounded down to multiples of 256MB. 1061 * 1062 */ 1063 static inline unsigned long phyp_dump_calculate_reserve_size(void) 1064 { 1065 unsigned long tmp; 1066 1067 if (phyp_dump_info->reserve_bootvar) 1068 return phyp_dump_info->reserve_bootvar; 1069 1070 /* divide by 20 to get 5% of value */ 1071 tmp = lmb_end_of_DRAM(); 1072 do_div(tmp, 20); 1073 1074 /* round it down in multiples of 256 */ 1075 tmp = tmp & ~0x0FFFFFFFUL; 1076 1077 return (tmp > PHYP_DUMP_RMR_END ? tmp : PHYP_DUMP_RMR_END); 1078 } 1079 1080 /** 1081 * phyp_dump_reserve_mem() - reserve all not-yet-dumped mmemory 1082 * 1083 * This routine may reserve memory regions in the kernel only 1084 * if the system is supported and a dump was taken in last 1085 * boot instance or if the hardware is supported and the 1086 * scratch area needs to be setup. In other instances it returns 1087 * without reserving anything. The memory in case of dump being 1088 * active is freed when the dump is collected (by userland tools). 1089 */ 1090 static void __init phyp_dump_reserve_mem(void) 1091 { 1092 unsigned long base, size; 1093 unsigned long variable_reserve_size; 1094 1095 if (!phyp_dump_info->phyp_dump_configured) { 1096 printk(KERN_ERR "Phyp-dump not supported on this hardware\n"); 1097 return; 1098 } 1099 1100 if (!phyp_dump_info->phyp_dump_at_boot) { 1101 printk(KERN_INFO "Phyp-dump disabled at boot time\n"); 1102 return; 1103 } 1104 1105 variable_reserve_size = phyp_dump_calculate_reserve_size(); 1106 1107 if (phyp_dump_info->phyp_dump_is_active) { 1108 /* Reserve *everything* above RMR.Area freed by userland tools*/ 1109 base = variable_reserve_size; 1110 size = lmb_end_of_DRAM() - base; 1111 1112 /* XXX crashed_ram_end is wrong, since it may be beyond 1113 * the memory_limit, it will need to be adjusted. */ 1114 lmb_reserve(base, size); 1115 1116 phyp_dump_info->init_reserve_start = base; 1117 phyp_dump_info->init_reserve_size = size; 1118 } else { 1119 size = phyp_dump_info->cpu_state_size + 1120 phyp_dump_info->hpte_region_size + 1121 variable_reserve_size; 1122 base = lmb_end_of_DRAM() - size; 1123 lmb_reserve(base, size); 1124 phyp_dump_info->init_reserve_start = base; 1125 phyp_dump_info->init_reserve_size = size; 1126 } 1127 } 1128 #else 1129 static inline void __init phyp_dump_reserve_mem(void) {} 1130 #endif /* CONFIG_PHYP_DUMP && CONFIG_PPC_RTAS */ 1131 1132 1133 void __init early_init_devtree(void *params) 1134 { 1135 DBG(" -> early_init_devtree(%p)\n", params); 1136 1137 /* Setup flat device-tree pointer */ 1138 initial_boot_params = params; 1139 1140 #ifdef CONFIG_PPC_RTAS 1141 /* Some machines might need RTAS info for debugging, grab it now. */ 1142 of_scan_flat_dt(early_init_dt_scan_rtas, NULL); 1143 #endif 1144 1145 #ifdef CONFIG_PHYP_DUMP 1146 /* scan tree to see if dump occured during last boot */ 1147 of_scan_flat_dt(early_init_dt_scan_phyp_dump, NULL); 1148 #endif 1149 1150 /* Retrieve various informations from the /chosen node of the 1151 * device-tree, including the platform type, initrd location and 1152 * size, TCE reserve, and more ... 1153 */ 1154 of_scan_flat_dt(early_init_dt_scan_chosen, NULL); 1155 1156 /* Scan memory nodes and rebuild LMBs */ 1157 lmb_init(); 1158 of_scan_flat_dt(early_init_dt_scan_root, NULL); 1159 of_scan_flat_dt(early_init_dt_scan_memory, NULL); 1160 1161 /* Save command line for /proc/cmdline and then parse parameters */ 1162 strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE); 1163 parse_early_param(); 1164 1165 /* Reserve LMB regions used by kernel, initrd, dt, etc... */ 1166 lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START); 1167 reserve_kdump_trampoline(); 1168 reserve_crashkernel(); 1169 early_reserve_mem(); 1170 phyp_dump_reserve_mem(); 1171 1172 lmb_enforce_memory_limit(memory_limit); 1173 lmb_analyze(); 1174 1175 DBG("Phys. mem: %lx\n", lmb_phys_mem_size()); 1176 1177 /* We may need to relocate the flat tree, do it now. 1178 * FIXME .. and the initrd too? */ 1179 move_device_tree(); 1180 1181 DBG("Scanning CPUs ...\n"); 1182 1183 /* Retreive CPU related informations from the flat tree 1184 * (altivec support, boot CPU ID, ...) 1185 */ 1186 of_scan_flat_dt(early_init_dt_scan_cpus, NULL); 1187 1188 DBG(" <- early_init_devtree()\n"); 1189 } 1190 1191 1192 /** 1193 * Indicates whether the root node has a given value in its 1194 * compatible property. 1195 */ 1196 int machine_is_compatible(const char *compat) 1197 { 1198 struct device_node *root; 1199 int rc = 0; 1200 1201 root = of_find_node_by_path("/"); 1202 if (root) { 1203 rc = of_device_is_compatible(root, compat); 1204 of_node_put(root); 1205 } 1206 return rc; 1207 } 1208 EXPORT_SYMBOL(machine_is_compatible); 1209 1210 /******* 1211 * 1212 * New implementation of the OF "find" APIs, return a refcounted 1213 * object, call of_node_put() when done. The device tree and list 1214 * are protected by a rw_lock. 1215 * 1216 * Note that property management will need some locking as well, 1217 * this isn't dealt with yet. 1218 * 1219 *******/ 1220 1221 /** 1222 * of_find_node_by_phandle - Find a node given a phandle 1223 * @handle: phandle of the node to find 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_node_by_phandle(phandle handle) 1229 { 1230 struct device_node *np; 1231 1232 read_lock(&devtree_lock); 1233 for (np = allnodes; np != 0; np = np->allnext) 1234 if (np->linux_phandle == handle) 1235 break; 1236 of_node_get(np); 1237 read_unlock(&devtree_lock); 1238 return np; 1239 } 1240 EXPORT_SYMBOL(of_find_node_by_phandle); 1241 1242 /** 1243 * of_find_all_nodes - Get next node in global list 1244 * @prev: Previous node or NULL to start iteration 1245 * of_node_put() will be called on it 1246 * 1247 * Returns a node pointer with refcount incremented, use 1248 * of_node_put() on it when done. 1249 */ 1250 struct device_node *of_find_all_nodes(struct device_node *prev) 1251 { 1252 struct device_node *np; 1253 1254 read_lock(&devtree_lock); 1255 np = prev ? prev->allnext : allnodes; 1256 for (; np != 0; np = np->allnext) 1257 if (of_node_get(np)) 1258 break; 1259 of_node_put(prev); 1260 read_unlock(&devtree_lock); 1261 return np; 1262 } 1263 EXPORT_SYMBOL(of_find_all_nodes); 1264 1265 /** 1266 * of_node_get - Increment refcount of a node 1267 * @node: Node to inc refcount, NULL is supported to 1268 * simplify writing of callers 1269 * 1270 * Returns node. 1271 */ 1272 struct device_node *of_node_get(struct device_node *node) 1273 { 1274 if (node) 1275 kref_get(&node->kref); 1276 return node; 1277 } 1278 EXPORT_SYMBOL(of_node_get); 1279 1280 static inline struct device_node * kref_to_device_node(struct kref *kref) 1281 { 1282 return container_of(kref, struct device_node, kref); 1283 } 1284 1285 /** 1286 * of_node_release - release a dynamically allocated node 1287 * @kref: kref element of the node to be released 1288 * 1289 * In of_node_put() this function is passed to kref_put() 1290 * as the destructor. 1291 */ 1292 static void of_node_release(struct kref *kref) 1293 { 1294 struct device_node *node = kref_to_device_node(kref); 1295 struct property *prop = node->properties; 1296 1297 /* We should never be releasing nodes that haven't been detached. */ 1298 if (!of_node_check_flag(node, OF_DETACHED)) { 1299 printk("WARNING: Bad of_node_put() on %s\n", node->full_name); 1300 dump_stack(); 1301 kref_init(&node->kref); 1302 return; 1303 } 1304 1305 if (!of_node_check_flag(node, OF_DYNAMIC)) 1306 return; 1307 1308 while (prop) { 1309 struct property *next = prop->next; 1310 kfree(prop->name); 1311 kfree(prop->value); 1312 kfree(prop); 1313 prop = next; 1314 1315 if (!prop) { 1316 prop = node->deadprops; 1317 node->deadprops = NULL; 1318 } 1319 } 1320 kfree(node->full_name); 1321 kfree(node->data); 1322 kfree(node); 1323 } 1324 1325 /** 1326 * of_node_put - Decrement refcount of a node 1327 * @node: Node to dec refcount, NULL is supported to 1328 * simplify writing of callers 1329 * 1330 */ 1331 void of_node_put(struct device_node *node) 1332 { 1333 if (node) 1334 kref_put(&node->kref, of_node_release); 1335 } 1336 EXPORT_SYMBOL(of_node_put); 1337 1338 /* 1339 * Plug a device node into the tree and global list. 1340 */ 1341 void of_attach_node(struct device_node *np) 1342 { 1343 unsigned long flags; 1344 1345 write_lock_irqsave(&devtree_lock, flags); 1346 np->sibling = np->parent->child; 1347 np->allnext = allnodes; 1348 np->parent->child = np; 1349 allnodes = np; 1350 write_unlock_irqrestore(&devtree_lock, flags); 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(struct device_node *np) 1359 { 1360 struct device_node *parent; 1361 unsigned long flags; 1362 1363 write_lock_irqsave(&devtree_lock, flags); 1364 1365 parent = np->parent; 1366 if (!parent) 1367 goto out_unlock; 1368 1369 if (allnodes == np) 1370 allnodes = np->allnext; 1371 else { 1372 struct device_node *prev; 1373 for (prev = allnodes; 1374 prev->allnext != np; 1375 prev = prev->allnext) 1376 ; 1377 prev->allnext = np->allnext; 1378 } 1379 1380 if (parent->child == np) 1381 parent->child = np->sibling; 1382 else { 1383 struct device_node *prevsib; 1384 for (prevsib = np->parent->child; 1385 prevsib->sibling != np; 1386 prevsib = prevsib->sibling) 1387 ; 1388 prevsib->sibling = np->sibling; 1389 } 1390 1391 of_node_set_flag(np, OF_DETACHED); 1392 1393 out_unlock: 1394 write_unlock_irqrestore(&devtree_lock, flags); 1395 } 1396 1397 #ifdef CONFIG_PPC_PSERIES 1398 /* 1399 * Fix up the uninitialized fields in a new device node: 1400 * name, type and pci-specific fields 1401 */ 1402 1403 static int of_finish_dynamic_node(struct device_node *node) 1404 { 1405 struct device_node *parent = of_get_parent(node); 1406 int err = 0; 1407 const phandle *ibm_phandle; 1408 1409 node->name = of_get_property(node, "name", NULL); 1410 node->type = of_get_property(node, "device_type", NULL); 1411 1412 if (!node->name) 1413 node->name = "<NULL>"; 1414 if (!node->type) 1415 node->type = "<NULL>"; 1416 1417 if (!parent) { 1418 err = -ENODEV; 1419 goto out; 1420 } 1421 1422 /* We don't support that function on PowerMac, at least 1423 * not yet 1424 */ 1425 if (machine_is(powermac)) 1426 return -ENODEV; 1427 1428 /* fix up new node's linux_phandle field */ 1429 if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL))) 1430 node->linux_phandle = *ibm_phandle; 1431 1432 out: 1433 of_node_put(parent); 1434 return err; 1435 } 1436 1437 static int prom_reconfig_notifier(struct notifier_block *nb, 1438 unsigned long action, void *node) 1439 { 1440 int err; 1441 1442 switch (action) { 1443 case PSERIES_RECONFIG_ADD: 1444 err = of_finish_dynamic_node(node); 1445 if (err < 0) { 1446 printk(KERN_ERR "finish_node returned %d\n", err); 1447 err = NOTIFY_BAD; 1448 } 1449 break; 1450 default: 1451 err = NOTIFY_DONE; 1452 break; 1453 } 1454 return err; 1455 } 1456 1457 static struct notifier_block prom_reconfig_nb = { 1458 .notifier_call = prom_reconfig_notifier, 1459 .priority = 10, /* This one needs to run first */ 1460 }; 1461 1462 static int __init prom_reconfig_setup(void) 1463 { 1464 return pSeries_reconfig_notifier_register(&prom_reconfig_nb); 1465 } 1466 __initcall(prom_reconfig_setup); 1467 #endif 1468 1469 /* 1470 * Add a property to a node 1471 */ 1472 int prom_add_property(struct device_node* np, struct property* prop) 1473 { 1474 struct property **next; 1475 unsigned long flags; 1476 1477 prop->next = NULL; 1478 write_lock_irqsave(&devtree_lock, flags); 1479 next = &np->properties; 1480 while (*next) { 1481 if (strcmp(prop->name, (*next)->name) == 0) { 1482 /* duplicate ! don't insert it */ 1483 write_unlock_irqrestore(&devtree_lock, flags); 1484 return -1; 1485 } 1486 next = &(*next)->next; 1487 } 1488 *next = prop; 1489 write_unlock_irqrestore(&devtree_lock, flags); 1490 1491 #ifdef CONFIG_PROC_DEVICETREE 1492 /* try to add to proc as well if it was initialized */ 1493 if (np->pde) 1494 proc_device_tree_add_prop(np->pde, prop); 1495 #endif /* CONFIG_PROC_DEVICETREE */ 1496 1497 return 0; 1498 } 1499 1500 /* 1501 * Remove a property from a node. Note that we don't actually 1502 * remove it, since we have given out who-knows-how-many pointers 1503 * to the data using get-property. Instead we just move the property 1504 * to the "dead properties" list, so it won't be found any more. 1505 */ 1506 int prom_remove_property(struct device_node *np, struct property *prop) 1507 { 1508 struct property **next; 1509 unsigned long flags; 1510 int found = 0; 1511 1512 write_lock_irqsave(&devtree_lock, flags); 1513 next = &np->properties; 1514 while (*next) { 1515 if (*next == prop) { 1516 /* found the node */ 1517 *next = prop->next; 1518 prop->next = np->deadprops; 1519 np->deadprops = prop; 1520 found = 1; 1521 break; 1522 } 1523 next = &(*next)->next; 1524 } 1525 write_unlock_irqrestore(&devtree_lock, flags); 1526 1527 if (!found) 1528 return -ENODEV; 1529 1530 #ifdef CONFIG_PROC_DEVICETREE 1531 /* try to remove the proc node as well */ 1532 if (np->pde) 1533 proc_device_tree_remove_prop(np->pde, prop); 1534 #endif /* CONFIG_PROC_DEVICETREE */ 1535 1536 return 0; 1537 } 1538 1539 /* 1540 * Update a property in a node. Note that we don't actually 1541 * remove it, since we have given out who-knows-how-many pointers 1542 * to the data using get-property. Instead we just move the property 1543 * to the "dead properties" list, and add the new property to the 1544 * property list 1545 */ 1546 int prom_update_property(struct device_node *np, 1547 struct property *newprop, 1548 struct property *oldprop) 1549 { 1550 struct property **next; 1551 unsigned long flags; 1552 int found = 0; 1553 1554 write_lock_irqsave(&devtree_lock, flags); 1555 next = &np->properties; 1556 while (*next) { 1557 if (*next == oldprop) { 1558 /* found the node */ 1559 newprop->next = oldprop->next; 1560 *next = newprop; 1561 oldprop->next = np->deadprops; 1562 np->deadprops = oldprop; 1563 found = 1; 1564 break; 1565 } 1566 next = &(*next)->next; 1567 } 1568 write_unlock_irqrestore(&devtree_lock, flags); 1569 1570 if (!found) 1571 return -ENODEV; 1572 1573 #ifdef CONFIG_PROC_DEVICETREE 1574 /* try to add to proc as well if it was initialized */ 1575 if (np->pde) 1576 proc_device_tree_update_prop(np->pde, newprop, oldprop); 1577 #endif /* CONFIG_PROC_DEVICETREE */ 1578 1579 return 0; 1580 } 1581 1582 1583 /* Find the device node for a given logical cpu number, also returns the cpu 1584 * local thread number (index in ibm,interrupt-server#s) if relevant and 1585 * asked for (non NULL) 1586 */ 1587 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread) 1588 { 1589 int hardid; 1590 struct device_node *np; 1591 1592 hardid = get_hard_smp_processor_id(cpu); 1593 1594 for_each_node_by_type(np, "cpu") { 1595 const u32 *intserv; 1596 unsigned int plen, t; 1597 1598 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist 1599 * fallback to "reg" property and assume no threads 1600 */ 1601 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", 1602 &plen); 1603 if (intserv == NULL) { 1604 const u32 *reg = of_get_property(np, "reg", NULL); 1605 if (reg == NULL) 1606 continue; 1607 if (*reg == hardid) { 1608 if (thread) 1609 *thread = 0; 1610 return np; 1611 } 1612 } else { 1613 plen /= sizeof(u32); 1614 for (t = 0; t < plen; t++) { 1615 if (hardid == intserv[t]) { 1616 if (thread) 1617 *thread = t; 1618 return np; 1619 } 1620 } 1621 } 1622 } 1623 return NULL; 1624 } 1625 EXPORT_SYMBOL(of_get_cpu_node); 1626 1627 #if defined(CONFIG_DEBUG_FS) && defined(DEBUG) 1628 static struct debugfs_blob_wrapper flat_dt_blob; 1629 1630 static int __init export_flat_device_tree(void) 1631 { 1632 struct dentry *d; 1633 1634 flat_dt_blob.data = initial_boot_params; 1635 flat_dt_blob.size = initial_boot_params->totalsize; 1636 1637 d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR, 1638 powerpc_debugfs_root, &flat_dt_blob); 1639 if (!d) 1640 return 1; 1641 1642 return 0; 1643 } 1644 __initcall(export_flat_device_tree); 1645 #endif 1646