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 unsigned long limit; 1164 1165 DBG(" -> early_init_devtree(%p)\n", params); 1166 1167 /* Setup flat device-tree pointer */ 1168 initial_boot_params = params; 1169 1170 #ifdef CONFIG_PPC_RTAS 1171 /* Some machines might need RTAS info for debugging, grab it now. */ 1172 of_scan_flat_dt(early_init_dt_scan_rtas, NULL); 1173 #endif 1174 1175 #ifdef CONFIG_PHYP_DUMP 1176 /* scan tree to see if dump occured during last boot */ 1177 of_scan_flat_dt(early_init_dt_scan_phyp_dump, NULL); 1178 #endif 1179 1180 /* Retrieve various informations from the /chosen node of the 1181 * device-tree, including the platform type, initrd location and 1182 * size, TCE reserve, and more ... 1183 */ 1184 of_scan_flat_dt(early_init_dt_scan_chosen, NULL); 1185 1186 /* Scan memory nodes and rebuild LMBs */ 1187 lmb_init(); 1188 of_scan_flat_dt(early_init_dt_scan_root, NULL); 1189 of_scan_flat_dt(early_init_dt_scan_memory, NULL); 1190 1191 /* Save command line for /proc/cmdline and then parse parameters */ 1192 strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE); 1193 parse_early_param(); 1194 1195 /* Reserve LMB regions used by kernel, initrd, dt, etc... */ 1196 lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START); 1197 /* If relocatable, reserve first 32k for interrupt vectors etc. */ 1198 if (PHYSICAL_START > MEMORY_START) 1199 lmb_reserve(MEMORY_START, 0x8000); 1200 reserve_kdump_trampoline(); 1201 reserve_crashkernel(); 1202 early_reserve_mem(); 1203 phyp_dump_reserve_mem(); 1204 1205 limit = memory_limit; 1206 if (! limit) { 1207 unsigned long memsize; 1208 1209 /* Ensure that total memory size is page-aligned, because 1210 * otherwise mark_bootmem() gets upset. */ 1211 lmb_analyze(); 1212 memsize = lmb_phys_mem_size(); 1213 if ((memsize & PAGE_MASK) != memsize) 1214 limit = memsize & PAGE_MASK; 1215 } 1216 lmb_enforce_memory_limit(limit); 1217 1218 lmb_analyze(); 1219 1220 DBG("Phys. mem: %lx\n", lmb_phys_mem_size()); 1221 1222 /* We may need to relocate the flat tree, do it now. 1223 * FIXME .. and the initrd too? */ 1224 move_device_tree(); 1225 1226 DBG("Scanning CPUs ...\n"); 1227 1228 /* Retreive CPU related informations from the flat tree 1229 * (altivec support, boot CPU ID, ...) 1230 */ 1231 of_scan_flat_dt(early_init_dt_scan_cpus, NULL); 1232 1233 DBG(" <- early_init_devtree()\n"); 1234 } 1235 1236 1237 /** 1238 * Indicates whether the root node has a given value in its 1239 * compatible property. 1240 */ 1241 int machine_is_compatible(const char *compat) 1242 { 1243 struct device_node *root; 1244 int rc = 0; 1245 1246 root = of_find_node_by_path("/"); 1247 if (root) { 1248 rc = of_device_is_compatible(root, compat); 1249 of_node_put(root); 1250 } 1251 return rc; 1252 } 1253 EXPORT_SYMBOL(machine_is_compatible); 1254 1255 /******* 1256 * 1257 * New implementation of the OF "find" APIs, return a refcounted 1258 * object, call of_node_put() when done. The device tree and list 1259 * are protected by a rw_lock. 1260 * 1261 * Note that property management will need some locking as well, 1262 * this isn't dealt with yet. 1263 * 1264 *******/ 1265 1266 /** 1267 * of_find_node_by_phandle - Find a node given a phandle 1268 * @handle: phandle of the node to find 1269 * 1270 * Returns a node pointer with refcount incremented, use 1271 * of_node_put() on it when done. 1272 */ 1273 struct device_node *of_find_node_by_phandle(phandle handle) 1274 { 1275 struct device_node *np; 1276 1277 read_lock(&devtree_lock); 1278 for (np = allnodes; np != 0; np = np->allnext) 1279 if (np->linux_phandle == handle) 1280 break; 1281 of_node_get(np); 1282 read_unlock(&devtree_lock); 1283 return np; 1284 } 1285 EXPORT_SYMBOL(of_find_node_by_phandle); 1286 1287 /** 1288 * of_find_next_cache_node - Find a node's subsidiary cache 1289 * @np: node of type "cpu" or "cache" 1290 * 1291 * Returns a node pointer with refcount incremented, use 1292 * of_node_put() on it when done. Caller should hold a reference 1293 * to np. 1294 */ 1295 struct device_node *of_find_next_cache_node(struct device_node *np) 1296 { 1297 struct device_node *child; 1298 const phandle *handle; 1299 1300 handle = of_get_property(np, "l2-cache", NULL); 1301 if (!handle) 1302 handle = of_get_property(np, "next-level-cache", NULL); 1303 1304 if (handle) 1305 return of_find_node_by_phandle(*handle); 1306 1307 /* OF on pmac has nodes instead of properties named "l2-cache" 1308 * beneath CPU nodes. 1309 */ 1310 if (!strcmp(np->type, "cpu")) 1311 for_each_child_of_node(np, child) 1312 if (!strcmp(child->type, "cache")) 1313 return child; 1314 1315 return NULL; 1316 } 1317 1318 /** 1319 * of_find_all_nodes - Get next node in global list 1320 * @prev: Previous node or NULL to start iteration 1321 * of_node_put() will be called on it 1322 * 1323 * Returns a node pointer with refcount incremented, use 1324 * of_node_put() on it when done. 1325 */ 1326 struct device_node *of_find_all_nodes(struct device_node *prev) 1327 { 1328 struct device_node *np; 1329 1330 read_lock(&devtree_lock); 1331 np = prev ? prev->allnext : allnodes; 1332 for (; np != 0; np = np->allnext) 1333 if (of_node_get(np)) 1334 break; 1335 of_node_put(prev); 1336 read_unlock(&devtree_lock); 1337 return np; 1338 } 1339 EXPORT_SYMBOL(of_find_all_nodes); 1340 1341 /** 1342 * of_node_get - Increment refcount of a node 1343 * @node: Node to inc refcount, NULL is supported to 1344 * simplify writing of callers 1345 * 1346 * Returns node. 1347 */ 1348 struct device_node *of_node_get(struct device_node *node) 1349 { 1350 if (node) 1351 kref_get(&node->kref); 1352 return node; 1353 } 1354 EXPORT_SYMBOL(of_node_get); 1355 1356 static inline struct device_node * kref_to_device_node(struct kref *kref) 1357 { 1358 return container_of(kref, struct device_node, kref); 1359 } 1360 1361 /** 1362 * of_node_release - release a dynamically allocated node 1363 * @kref: kref element of the node to be released 1364 * 1365 * In of_node_put() this function is passed to kref_put() 1366 * as the destructor. 1367 */ 1368 static void of_node_release(struct kref *kref) 1369 { 1370 struct device_node *node = kref_to_device_node(kref); 1371 struct property *prop = node->properties; 1372 1373 /* We should never be releasing nodes that haven't been detached. */ 1374 if (!of_node_check_flag(node, OF_DETACHED)) { 1375 printk("WARNING: Bad of_node_put() on %s\n", node->full_name); 1376 dump_stack(); 1377 kref_init(&node->kref); 1378 return; 1379 } 1380 1381 if (!of_node_check_flag(node, OF_DYNAMIC)) 1382 return; 1383 1384 while (prop) { 1385 struct property *next = prop->next; 1386 kfree(prop->name); 1387 kfree(prop->value); 1388 kfree(prop); 1389 prop = next; 1390 1391 if (!prop) { 1392 prop = node->deadprops; 1393 node->deadprops = NULL; 1394 } 1395 } 1396 kfree(node->full_name); 1397 kfree(node->data); 1398 kfree(node); 1399 } 1400 1401 /** 1402 * of_node_put - Decrement refcount of a node 1403 * @node: Node to dec refcount, NULL is supported to 1404 * simplify writing of callers 1405 * 1406 */ 1407 void of_node_put(struct device_node *node) 1408 { 1409 if (node) 1410 kref_put(&node->kref, of_node_release); 1411 } 1412 EXPORT_SYMBOL(of_node_put); 1413 1414 /* 1415 * Plug a device node into the tree and global list. 1416 */ 1417 void of_attach_node(struct device_node *np) 1418 { 1419 unsigned long flags; 1420 1421 write_lock_irqsave(&devtree_lock, flags); 1422 np->sibling = np->parent->child; 1423 np->allnext = allnodes; 1424 np->parent->child = np; 1425 allnodes = np; 1426 write_unlock_irqrestore(&devtree_lock, flags); 1427 } 1428 1429 /* 1430 * "Unplug" a node from the device tree. The caller must hold 1431 * a reference to the node. The memory associated with the node 1432 * is not freed until its refcount goes to zero. 1433 */ 1434 void of_detach_node(struct device_node *np) 1435 { 1436 struct device_node *parent; 1437 unsigned long flags; 1438 1439 write_lock_irqsave(&devtree_lock, flags); 1440 1441 parent = np->parent; 1442 if (!parent) 1443 goto out_unlock; 1444 1445 if (allnodes == np) 1446 allnodes = np->allnext; 1447 else { 1448 struct device_node *prev; 1449 for (prev = allnodes; 1450 prev->allnext != np; 1451 prev = prev->allnext) 1452 ; 1453 prev->allnext = np->allnext; 1454 } 1455 1456 if (parent->child == np) 1457 parent->child = np->sibling; 1458 else { 1459 struct device_node *prevsib; 1460 for (prevsib = np->parent->child; 1461 prevsib->sibling != np; 1462 prevsib = prevsib->sibling) 1463 ; 1464 prevsib->sibling = np->sibling; 1465 } 1466 1467 of_node_set_flag(np, OF_DETACHED); 1468 1469 out_unlock: 1470 write_unlock_irqrestore(&devtree_lock, flags); 1471 } 1472 1473 #ifdef CONFIG_PPC_PSERIES 1474 /* 1475 * Fix up the uninitialized fields in a new device node: 1476 * name, type and pci-specific fields 1477 */ 1478 1479 static int of_finish_dynamic_node(struct device_node *node) 1480 { 1481 struct device_node *parent = of_get_parent(node); 1482 int err = 0; 1483 const phandle *ibm_phandle; 1484 1485 node->name = of_get_property(node, "name", NULL); 1486 node->type = of_get_property(node, "device_type", NULL); 1487 1488 if (!node->name) 1489 node->name = "<NULL>"; 1490 if (!node->type) 1491 node->type = "<NULL>"; 1492 1493 if (!parent) { 1494 err = -ENODEV; 1495 goto out; 1496 } 1497 1498 /* We don't support that function on PowerMac, at least 1499 * not yet 1500 */ 1501 if (machine_is(powermac)) 1502 return -ENODEV; 1503 1504 /* fix up new node's linux_phandle field */ 1505 if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL))) 1506 node->linux_phandle = *ibm_phandle; 1507 1508 out: 1509 of_node_put(parent); 1510 return err; 1511 } 1512 1513 static int prom_reconfig_notifier(struct notifier_block *nb, 1514 unsigned long action, void *node) 1515 { 1516 int err; 1517 1518 switch (action) { 1519 case PSERIES_RECONFIG_ADD: 1520 err = of_finish_dynamic_node(node); 1521 if (err < 0) { 1522 printk(KERN_ERR "finish_node returned %d\n", err); 1523 err = NOTIFY_BAD; 1524 } 1525 break; 1526 default: 1527 err = NOTIFY_DONE; 1528 break; 1529 } 1530 return err; 1531 } 1532 1533 static struct notifier_block prom_reconfig_nb = { 1534 .notifier_call = prom_reconfig_notifier, 1535 .priority = 10, /* This one needs to run first */ 1536 }; 1537 1538 static int __init prom_reconfig_setup(void) 1539 { 1540 return pSeries_reconfig_notifier_register(&prom_reconfig_nb); 1541 } 1542 __initcall(prom_reconfig_setup); 1543 #endif 1544 1545 /* 1546 * Add a property to a node 1547 */ 1548 int prom_add_property(struct device_node* np, struct property* prop) 1549 { 1550 struct property **next; 1551 unsigned long flags; 1552 1553 prop->next = NULL; 1554 write_lock_irqsave(&devtree_lock, flags); 1555 next = &np->properties; 1556 while (*next) { 1557 if (strcmp(prop->name, (*next)->name) == 0) { 1558 /* duplicate ! don't insert it */ 1559 write_unlock_irqrestore(&devtree_lock, flags); 1560 return -1; 1561 } 1562 next = &(*next)->next; 1563 } 1564 *next = prop; 1565 write_unlock_irqrestore(&devtree_lock, flags); 1566 1567 #ifdef CONFIG_PROC_DEVICETREE 1568 /* try to add to proc as well if it was initialized */ 1569 if (np->pde) 1570 proc_device_tree_add_prop(np->pde, prop); 1571 #endif /* CONFIG_PROC_DEVICETREE */ 1572 1573 return 0; 1574 } 1575 1576 /* 1577 * Remove a property from a node. Note that we don't actually 1578 * remove it, since we have given out who-knows-how-many pointers 1579 * to the data using get-property. Instead we just move the property 1580 * to the "dead properties" list, so it won't be found any more. 1581 */ 1582 int prom_remove_property(struct device_node *np, struct property *prop) 1583 { 1584 struct property **next; 1585 unsigned long flags; 1586 int found = 0; 1587 1588 write_lock_irqsave(&devtree_lock, flags); 1589 next = &np->properties; 1590 while (*next) { 1591 if (*next == prop) { 1592 /* found the node */ 1593 *next = prop->next; 1594 prop->next = np->deadprops; 1595 np->deadprops = prop; 1596 found = 1; 1597 break; 1598 } 1599 next = &(*next)->next; 1600 } 1601 write_unlock_irqrestore(&devtree_lock, flags); 1602 1603 if (!found) 1604 return -ENODEV; 1605 1606 #ifdef CONFIG_PROC_DEVICETREE 1607 /* try to remove the proc node as well */ 1608 if (np->pde) 1609 proc_device_tree_remove_prop(np->pde, prop); 1610 #endif /* CONFIG_PROC_DEVICETREE */ 1611 1612 return 0; 1613 } 1614 1615 /* 1616 * Update a property in a node. Note that we don't actually 1617 * remove it, since we have given out who-knows-how-many pointers 1618 * to the data using get-property. Instead we just move the property 1619 * to the "dead properties" list, and add the new property to the 1620 * property list 1621 */ 1622 int prom_update_property(struct device_node *np, 1623 struct property *newprop, 1624 struct property *oldprop) 1625 { 1626 struct property **next; 1627 unsigned long flags; 1628 int found = 0; 1629 1630 write_lock_irqsave(&devtree_lock, flags); 1631 next = &np->properties; 1632 while (*next) { 1633 if (*next == oldprop) { 1634 /* found the node */ 1635 newprop->next = oldprop->next; 1636 *next = newprop; 1637 oldprop->next = np->deadprops; 1638 np->deadprops = oldprop; 1639 found = 1; 1640 break; 1641 } 1642 next = &(*next)->next; 1643 } 1644 write_unlock_irqrestore(&devtree_lock, flags); 1645 1646 if (!found) 1647 return -ENODEV; 1648 1649 #ifdef CONFIG_PROC_DEVICETREE 1650 /* try to add to proc as well if it was initialized */ 1651 if (np->pde) 1652 proc_device_tree_update_prop(np->pde, newprop, oldprop); 1653 #endif /* CONFIG_PROC_DEVICETREE */ 1654 1655 return 0; 1656 } 1657 1658 1659 /* Find the device node for a given logical cpu number, also returns the cpu 1660 * local thread number (index in ibm,interrupt-server#s) if relevant and 1661 * asked for (non NULL) 1662 */ 1663 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread) 1664 { 1665 int hardid; 1666 struct device_node *np; 1667 1668 hardid = get_hard_smp_processor_id(cpu); 1669 1670 for_each_node_by_type(np, "cpu") { 1671 const u32 *intserv; 1672 unsigned int plen, t; 1673 1674 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist 1675 * fallback to "reg" property and assume no threads 1676 */ 1677 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", 1678 &plen); 1679 if (intserv == NULL) { 1680 const u32 *reg = of_get_property(np, "reg", NULL); 1681 if (reg == NULL) 1682 continue; 1683 if (*reg == hardid) { 1684 if (thread) 1685 *thread = 0; 1686 return np; 1687 } 1688 } else { 1689 plen /= sizeof(u32); 1690 for (t = 0; t < plen; t++) { 1691 if (hardid == intserv[t]) { 1692 if (thread) 1693 *thread = t; 1694 return np; 1695 } 1696 } 1697 } 1698 } 1699 return NULL; 1700 } 1701 EXPORT_SYMBOL(of_get_cpu_node); 1702 1703 #if defined(CONFIG_DEBUG_FS) && defined(DEBUG) 1704 static struct debugfs_blob_wrapper flat_dt_blob; 1705 1706 static int __init export_flat_device_tree(void) 1707 { 1708 struct dentry *d; 1709 1710 flat_dt_blob.data = initial_boot_params; 1711 flat_dt_blob.size = initial_boot_params->totalsize; 1712 1713 d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR, 1714 powerpc_debugfs_root, &flat_dt_blob); 1715 if (!d) 1716 return 1; 1717 1718 return 0; 1719 } 1720 __initcall(export_flat_device_tree); 1721 #endif 1722