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, "slb-size", NULL); 594 if (slb_size_ptr != NULL) { 595 mmu_slb_size = *slb_size_ptr; 596 return; 597 } 598 slb_size_ptr = of_get_flat_dt_prop(node, "ibm,slb-size", NULL); 599 if (slb_size_ptr != NULL) { 600 mmu_slb_size = *slb_size_ptr; 601 } 602 } 603 #else 604 #define check_cpu_slb_size(node) do { } while(0) 605 #endif 606 607 static struct feature_property { 608 const char *name; 609 u32 min_value; 610 unsigned long cpu_feature; 611 unsigned long cpu_user_ftr; 612 } feature_properties[] __initdata = { 613 #ifdef CONFIG_ALTIVEC 614 {"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC}, 615 {"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC}, 616 #endif /* CONFIG_ALTIVEC */ 617 #ifdef CONFIG_VSX 618 /* Yes, this _really_ is ibm,vmx == 2 to enable VSX */ 619 {"ibm,vmx", 2, CPU_FTR_VSX, PPC_FEATURE_HAS_VSX}, 620 #endif /* CONFIG_VSX */ 621 #ifdef CONFIG_PPC64 622 {"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP}, 623 {"ibm,purr", 1, CPU_FTR_PURR, 0}, 624 {"ibm,spurr", 1, CPU_FTR_SPURR, 0}, 625 #endif /* CONFIG_PPC64 */ 626 }; 627 628 #if defined(CONFIG_44x) && defined(CONFIG_PPC_FPU) 629 static inline void identical_pvr_fixup(unsigned long node) 630 { 631 unsigned int pvr; 632 char *model = of_get_flat_dt_prop(node, "model", NULL); 633 634 /* 635 * Since 440GR(x)/440EP(x) processors have the same pvr, 636 * we check the node path and set bit 28 in the cur_cpu_spec 637 * pvr for EP(x) processor version. This bit is always 0 in 638 * the "real" pvr. Then we call identify_cpu again with 639 * the new logical pvr to enable FPU support. 640 */ 641 if (model && strstr(model, "440EP")) { 642 pvr = cur_cpu_spec->pvr_value | 0x8; 643 identify_cpu(0, pvr); 644 DBG("Using logical pvr %x for %s\n", pvr, model); 645 } 646 } 647 #else 648 #define identical_pvr_fixup(node) do { } while(0) 649 #endif 650 651 static void __init check_cpu_feature_properties(unsigned long node) 652 { 653 unsigned long i; 654 struct feature_property *fp = feature_properties; 655 const u32 *prop; 656 657 for (i = 0; i < ARRAY_SIZE(feature_properties); ++i, ++fp) { 658 prop = of_get_flat_dt_prop(node, fp->name, NULL); 659 if (prop && *prop >= fp->min_value) { 660 cur_cpu_spec->cpu_features |= fp->cpu_feature; 661 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr; 662 } 663 } 664 } 665 666 static int __init early_init_dt_scan_cpus(unsigned long node, 667 const char *uname, int depth, 668 void *data) 669 { 670 static int logical_cpuid = 0; 671 char *type = of_get_flat_dt_prop(node, "device_type", NULL); 672 const u32 *prop; 673 const u32 *intserv; 674 int i, nthreads; 675 unsigned long len; 676 int found = 0; 677 678 /* We are scanning "cpu" nodes only */ 679 if (type == NULL || strcmp(type, "cpu") != 0) 680 return 0; 681 682 /* Get physical cpuid */ 683 intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len); 684 if (intserv) { 685 nthreads = len / sizeof(int); 686 } else { 687 intserv = of_get_flat_dt_prop(node, "reg", NULL); 688 nthreads = 1; 689 } 690 691 /* 692 * Now see if any of these threads match our boot cpu. 693 * NOTE: This must match the parsing done in smp_setup_cpu_maps. 694 */ 695 for (i = 0; i < nthreads; i++) { 696 /* 697 * version 2 of the kexec param format adds the phys cpuid of 698 * booted proc. 699 */ 700 if (initial_boot_params && initial_boot_params->version >= 2) { 701 if (intserv[i] == 702 initial_boot_params->boot_cpuid_phys) { 703 found = 1; 704 break; 705 } 706 } else { 707 /* 708 * Check if it's the boot-cpu, set it's hw index now, 709 * unfortunately this format did not support booting 710 * off secondary threads. 711 */ 712 if (of_get_flat_dt_prop(node, 713 "linux,boot-cpu", NULL) != NULL) { 714 found = 1; 715 break; 716 } 717 } 718 719 #ifdef CONFIG_SMP 720 /* logical cpu id is always 0 on UP kernels */ 721 logical_cpuid++; 722 #endif 723 } 724 725 if (found) { 726 DBG("boot cpu: logical %d physical %d\n", logical_cpuid, 727 intserv[i]); 728 boot_cpuid = logical_cpuid; 729 set_hard_smp_processor_id(boot_cpuid, intserv[i]); 730 731 /* 732 * PAPR defines "logical" PVR values for cpus that 733 * meet various levels of the architecture: 734 * 0x0f000001 Architecture version 2.04 735 * 0x0f000002 Architecture version 2.05 736 * If the cpu-version property in the cpu node contains 737 * such a value, we call identify_cpu again with the 738 * logical PVR value in order to use the cpu feature 739 * bits appropriate for the architecture level. 740 * 741 * A POWER6 partition in "POWER6 architected" mode 742 * uses the 0x0f000002 PVR value; in POWER5+ mode 743 * it uses 0x0f000001. 744 */ 745 prop = of_get_flat_dt_prop(node, "cpu-version", NULL); 746 if (prop && (*prop & 0xff000000) == 0x0f000000) 747 identify_cpu(0, *prop); 748 749 identical_pvr_fixup(node); 750 } 751 752 check_cpu_feature_properties(node); 753 check_cpu_pa_features(node); 754 check_cpu_slb_size(node); 755 756 #ifdef CONFIG_PPC_PSERIES 757 if (nthreads > 1) 758 cur_cpu_spec->cpu_features |= CPU_FTR_SMT; 759 else 760 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT; 761 #endif 762 763 return 0; 764 } 765 766 #ifdef CONFIG_BLK_DEV_INITRD 767 static void __init early_init_dt_check_for_initrd(unsigned long node) 768 { 769 unsigned long l; 770 u32 *prop; 771 772 DBG("Looking for initrd properties... "); 773 774 prop = of_get_flat_dt_prop(node, "linux,initrd-start", &l); 775 if (prop) { 776 initrd_start = (unsigned long)__va(of_read_ulong(prop, l/4)); 777 778 prop = of_get_flat_dt_prop(node, "linux,initrd-end", &l); 779 if (prop) { 780 initrd_end = (unsigned long) 781 __va(of_read_ulong(prop, l/4)); 782 initrd_below_start_ok = 1; 783 } else { 784 initrd_start = 0; 785 } 786 } 787 788 DBG("initrd_start=0x%lx initrd_end=0x%lx\n", initrd_start, initrd_end); 789 } 790 #else 791 static inline void early_init_dt_check_for_initrd(unsigned long node) 792 { 793 } 794 #endif /* CONFIG_BLK_DEV_INITRD */ 795 796 static int __init early_init_dt_scan_chosen(unsigned long node, 797 const char *uname, int depth, void *data) 798 { 799 unsigned long *lprop; 800 unsigned long l; 801 char *p; 802 803 DBG("search \"chosen\", depth: %d, uname: %s\n", depth, uname); 804 805 if (depth != 1 || 806 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0)) 807 return 0; 808 809 #ifdef CONFIG_PPC64 810 /* check if iommu is forced on or off */ 811 if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL) 812 iommu_is_off = 1; 813 if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL) 814 iommu_force_on = 1; 815 #endif 816 817 /* mem=x on the command line is the preferred mechanism */ 818 lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL); 819 if (lprop) 820 memory_limit = *lprop; 821 822 #ifdef CONFIG_PPC64 823 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL); 824 if (lprop) 825 tce_alloc_start = *lprop; 826 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL); 827 if (lprop) 828 tce_alloc_end = *lprop; 829 #endif 830 831 #ifdef CONFIG_KEXEC 832 lprop = of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL); 833 if (lprop) 834 crashk_res.start = *lprop; 835 836 lprop = of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL); 837 if (lprop) 838 crashk_res.end = crashk_res.start + *lprop - 1; 839 #endif 840 841 early_init_dt_check_for_initrd(node); 842 843 /* Retreive command line */ 844 p = of_get_flat_dt_prop(node, "bootargs", &l); 845 if (p != NULL && l > 0) 846 strlcpy(cmd_line, p, min((int)l, COMMAND_LINE_SIZE)); 847 848 #ifdef CONFIG_CMDLINE 849 if (p == NULL || l == 0 || (l == 1 && (*p) == 0)) 850 strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE); 851 #endif /* CONFIG_CMDLINE */ 852 853 DBG("Command line is: %s\n", cmd_line); 854 855 /* break now */ 856 return 1; 857 } 858 859 static int __init early_init_dt_scan_root(unsigned long node, 860 const char *uname, int depth, void *data) 861 { 862 u32 *prop; 863 864 if (depth != 0) 865 return 0; 866 867 prop = of_get_flat_dt_prop(node, "#size-cells", NULL); 868 dt_root_size_cells = (prop == NULL) ? 1 : *prop; 869 DBG("dt_root_size_cells = %x\n", dt_root_size_cells); 870 871 prop = of_get_flat_dt_prop(node, "#address-cells", NULL); 872 dt_root_addr_cells = (prop == NULL) ? 2 : *prop; 873 DBG("dt_root_addr_cells = %x\n", dt_root_addr_cells); 874 875 /* break now */ 876 return 1; 877 } 878 879 static u64 __init dt_mem_next_cell(int s, cell_t **cellp) 880 { 881 cell_t *p = *cellp; 882 883 *cellp = p + s; 884 return of_read_number(p, s); 885 } 886 887 #ifdef CONFIG_PPC_PSERIES 888 /* 889 * Interpret the ibm,dynamic-memory property in the 890 * /ibm,dynamic-reconfiguration-memory node. 891 * This contains a list of memory blocks along with NUMA affinity 892 * information. 893 */ 894 static int __init early_init_dt_scan_drconf_memory(unsigned long node) 895 { 896 cell_t *dm, *ls, *usm; 897 unsigned long l, n, flags; 898 u64 base, size, lmb_size; 899 unsigned int is_kexec_kdump = 0, rngs; 900 901 ls = of_get_flat_dt_prop(node, "ibm,lmb-size", &l); 902 if (ls == NULL || l < dt_root_size_cells * sizeof(cell_t)) 903 return 0; 904 lmb_size = dt_mem_next_cell(dt_root_size_cells, &ls); 905 906 dm = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l); 907 if (dm == NULL || l < sizeof(cell_t)) 908 return 0; 909 910 n = *dm++; /* number of entries */ 911 if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(cell_t)) 912 return 0; 913 914 /* check if this is a kexec/kdump kernel. */ 915 usm = of_get_flat_dt_prop(node, "linux,drconf-usable-memory", 916 &l); 917 if (usm != NULL) 918 is_kexec_kdump = 1; 919 920 for (; n != 0; --n) { 921 base = dt_mem_next_cell(dt_root_addr_cells, &dm); 922 flags = dm[3]; 923 /* skip DRC index, pad, assoc. list index, flags */ 924 dm += 4; 925 /* skip this block if the reserved bit is set in flags (0x80) 926 or if the block is not assigned to this partition (0x8) */ 927 if ((flags & 0x80) || !(flags & 0x8)) 928 continue; 929 size = lmb_size; 930 rngs = 1; 931 if (is_kexec_kdump) { 932 /* 933 * For each lmb in ibm,dynamic-memory, a corresponding 934 * entry in linux,drconf-usable-memory property contains 935 * a counter 'p' followed by 'p' (base, size) duple. 936 * Now read the counter from 937 * linux,drconf-usable-memory property 938 */ 939 rngs = dt_mem_next_cell(dt_root_size_cells, &usm); 940 if (!rngs) /* there are no (base, size) duple */ 941 continue; 942 } 943 do { 944 if (is_kexec_kdump) { 945 base = dt_mem_next_cell(dt_root_addr_cells, 946 &usm); 947 size = dt_mem_next_cell(dt_root_size_cells, 948 &usm); 949 } 950 if (iommu_is_off) { 951 if (base >= 0x80000000ul) 952 continue; 953 if ((base + size) > 0x80000000ul) 954 size = 0x80000000ul - base; 955 } 956 lmb_add(base, size); 957 } while (--rngs); 958 } 959 lmb_dump_all(); 960 return 0; 961 } 962 #else 963 #define early_init_dt_scan_drconf_memory(node) 0 964 #endif /* CONFIG_PPC_PSERIES */ 965 966 static int __init early_init_dt_scan_memory(unsigned long node, 967 const char *uname, int depth, void *data) 968 { 969 char *type = of_get_flat_dt_prop(node, "device_type", NULL); 970 cell_t *reg, *endp; 971 unsigned long l; 972 973 /* Look for the ibm,dynamic-reconfiguration-memory node */ 974 if (depth == 1 && 975 strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0) 976 return early_init_dt_scan_drconf_memory(node); 977 978 /* We are scanning "memory" nodes only */ 979 if (type == NULL) { 980 /* 981 * The longtrail doesn't have a device_type on the 982 * /memory node, so look for the node called /memory@0. 983 */ 984 if (depth != 1 || strcmp(uname, "memory@0") != 0) 985 return 0; 986 } else if (strcmp(type, "memory") != 0) 987 return 0; 988 989 reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l); 990 if (reg == NULL) 991 reg = of_get_flat_dt_prop(node, "reg", &l); 992 if (reg == NULL) 993 return 0; 994 995 endp = reg + (l / sizeof(cell_t)); 996 997 DBG("memory scan node %s, reg size %ld, data: %x %x %x %x,\n", 998 uname, l, reg[0], reg[1], reg[2], reg[3]); 999 1000 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) { 1001 u64 base, size; 1002 1003 base = dt_mem_next_cell(dt_root_addr_cells, ®); 1004 size = dt_mem_next_cell(dt_root_size_cells, ®); 1005 1006 if (size == 0) 1007 continue; 1008 DBG(" - %llx , %llx\n", (unsigned long long)base, 1009 (unsigned long long)size); 1010 #ifdef CONFIG_PPC64 1011 if (iommu_is_off) { 1012 if (base >= 0x80000000ul) 1013 continue; 1014 if ((base + size) > 0x80000000ul) 1015 size = 0x80000000ul - base; 1016 } 1017 #endif 1018 lmb_add(base, size); 1019 1020 memstart_addr = min((u64)memstart_addr, base); 1021 } 1022 1023 return 0; 1024 } 1025 1026 static void __init early_reserve_mem(void) 1027 { 1028 u64 base, size; 1029 u64 *reserve_map; 1030 unsigned long self_base; 1031 unsigned long self_size; 1032 1033 reserve_map = (u64 *)(((unsigned long)initial_boot_params) + 1034 initial_boot_params->off_mem_rsvmap); 1035 1036 /* before we do anything, lets reserve the dt blob */ 1037 self_base = __pa((unsigned long)initial_boot_params); 1038 self_size = initial_boot_params->totalsize; 1039 lmb_reserve(self_base, self_size); 1040 1041 #ifdef CONFIG_BLK_DEV_INITRD 1042 /* then reserve the initrd, if any */ 1043 if (initrd_start && (initrd_end > initrd_start)) 1044 lmb_reserve(__pa(initrd_start), initrd_end - initrd_start); 1045 #endif /* CONFIG_BLK_DEV_INITRD */ 1046 1047 #ifdef CONFIG_PPC32 1048 /* 1049 * Handle the case where we might be booting from an old kexec 1050 * image that setup the mem_rsvmap as pairs of 32-bit values 1051 */ 1052 if (*reserve_map > 0xffffffffull) { 1053 u32 base_32, size_32; 1054 u32 *reserve_map_32 = (u32 *)reserve_map; 1055 1056 while (1) { 1057 base_32 = *(reserve_map_32++); 1058 size_32 = *(reserve_map_32++); 1059 if (size_32 == 0) 1060 break; 1061 /* skip if the reservation is for the blob */ 1062 if (base_32 == self_base && size_32 == self_size) 1063 continue; 1064 DBG("reserving: %x -> %x\n", base_32, size_32); 1065 lmb_reserve(base_32, size_32); 1066 } 1067 return; 1068 } 1069 #endif 1070 while (1) { 1071 base = *(reserve_map++); 1072 size = *(reserve_map++); 1073 if (size == 0) 1074 break; 1075 DBG("reserving: %llx -> %llx\n", base, size); 1076 lmb_reserve(base, size); 1077 } 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 lmb_dump_all(); 1220 1221 DBG("Phys. mem: %lx\n", lmb_phys_mem_size()); 1222 1223 /* We may need to relocate the flat tree, do it now. 1224 * FIXME .. and the initrd too? */ 1225 move_device_tree(); 1226 1227 DBG("Scanning CPUs ...\n"); 1228 1229 /* Retreive CPU related informations from the flat tree 1230 * (altivec support, boot CPU ID, ...) 1231 */ 1232 of_scan_flat_dt(early_init_dt_scan_cpus, NULL); 1233 1234 DBG(" <- early_init_devtree()\n"); 1235 } 1236 1237 1238 /** 1239 * Indicates whether the root node has a given value in its 1240 * compatible property. 1241 */ 1242 int machine_is_compatible(const char *compat) 1243 { 1244 struct device_node *root; 1245 int rc = 0; 1246 1247 root = of_find_node_by_path("/"); 1248 if (root) { 1249 rc = of_device_is_compatible(root, compat); 1250 of_node_put(root); 1251 } 1252 return rc; 1253 } 1254 EXPORT_SYMBOL(machine_is_compatible); 1255 1256 /******* 1257 * 1258 * New implementation of the OF "find" APIs, return a refcounted 1259 * object, call of_node_put() when done. The device tree and list 1260 * are protected by a rw_lock. 1261 * 1262 * Note that property management will need some locking as well, 1263 * this isn't dealt with yet. 1264 * 1265 *******/ 1266 1267 /** 1268 * of_find_node_by_phandle - Find a node given a phandle 1269 * @handle: phandle of the node to find 1270 * 1271 * Returns a node pointer with refcount incremented, use 1272 * of_node_put() on it when done. 1273 */ 1274 struct device_node *of_find_node_by_phandle(phandle handle) 1275 { 1276 struct device_node *np; 1277 1278 read_lock(&devtree_lock); 1279 for (np = allnodes; np != 0; np = np->allnext) 1280 if (np->linux_phandle == handle) 1281 break; 1282 of_node_get(np); 1283 read_unlock(&devtree_lock); 1284 return np; 1285 } 1286 EXPORT_SYMBOL(of_find_node_by_phandle); 1287 1288 /** 1289 * of_find_next_cache_node - Find a node's subsidiary cache 1290 * @np: node of type "cpu" or "cache" 1291 * 1292 * Returns a node pointer with refcount incremented, use 1293 * of_node_put() on it when done. Caller should hold a reference 1294 * to np. 1295 */ 1296 struct device_node *of_find_next_cache_node(struct device_node *np) 1297 { 1298 struct device_node *child; 1299 const phandle *handle; 1300 1301 handle = of_get_property(np, "l2-cache", NULL); 1302 if (!handle) 1303 handle = of_get_property(np, "next-level-cache", NULL); 1304 1305 if (handle) 1306 return of_find_node_by_phandle(*handle); 1307 1308 /* OF on pmac has nodes instead of properties named "l2-cache" 1309 * beneath CPU nodes. 1310 */ 1311 if (!strcmp(np->type, "cpu")) 1312 for_each_child_of_node(np, child) 1313 if (!strcmp(child->type, "cache")) 1314 return child; 1315 1316 return NULL; 1317 } 1318 1319 /** 1320 * of_find_all_nodes - Get next node in global list 1321 * @prev: Previous node or NULL to start iteration 1322 * of_node_put() will be called on it 1323 * 1324 * Returns a node pointer with refcount incremented, use 1325 * of_node_put() on it when done. 1326 */ 1327 struct device_node *of_find_all_nodes(struct device_node *prev) 1328 { 1329 struct device_node *np; 1330 1331 read_lock(&devtree_lock); 1332 np = prev ? prev->allnext : allnodes; 1333 for (; np != 0; np = np->allnext) 1334 if (of_node_get(np)) 1335 break; 1336 of_node_put(prev); 1337 read_unlock(&devtree_lock); 1338 return np; 1339 } 1340 EXPORT_SYMBOL(of_find_all_nodes); 1341 1342 /** 1343 * of_node_get - Increment refcount of a node 1344 * @node: Node to inc refcount, NULL is supported to 1345 * simplify writing of callers 1346 * 1347 * Returns node. 1348 */ 1349 struct device_node *of_node_get(struct device_node *node) 1350 { 1351 if (node) 1352 kref_get(&node->kref); 1353 return node; 1354 } 1355 EXPORT_SYMBOL(of_node_get); 1356 1357 static inline struct device_node * kref_to_device_node(struct kref *kref) 1358 { 1359 return container_of(kref, struct device_node, kref); 1360 } 1361 1362 /** 1363 * of_node_release - release a dynamically allocated node 1364 * @kref: kref element of the node to be released 1365 * 1366 * In of_node_put() this function is passed to kref_put() 1367 * as the destructor. 1368 */ 1369 static void of_node_release(struct kref *kref) 1370 { 1371 struct device_node *node = kref_to_device_node(kref); 1372 struct property *prop = node->properties; 1373 1374 /* We should never be releasing nodes that haven't been detached. */ 1375 if (!of_node_check_flag(node, OF_DETACHED)) { 1376 printk("WARNING: Bad of_node_put() on %s\n", node->full_name); 1377 dump_stack(); 1378 kref_init(&node->kref); 1379 return; 1380 } 1381 1382 if (!of_node_check_flag(node, OF_DYNAMIC)) 1383 return; 1384 1385 while (prop) { 1386 struct property *next = prop->next; 1387 kfree(prop->name); 1388 kfree(prop->value); 1389 kfree(prop); 1390 prop = next; 1391 1392 if (!prop) { 1393 prop = node->deadprops; 1394 node->deadprops = NULL; 1395 } 1396 } 1397 kfree(node->full_name); 1398 kfree(node->data); 1399 kfree(node); 1400 } 1401 1402 /** 1403 * of_node_put - Decrement refcount of a node 1404 * @node: Node to dec refcount, NULL is supported to 1405 * simplify writing of callers 1406 * 1407 */ 1408 void of_node_put(struct device_node *node) 1409 { 1410 if (node) 1411 kref_put(&node->kref, of_node_release); 1412 } 1413 EXPORT_SYMBOL(of_node_put); 1414 1415 /* 1416 * Plug a device node into the tree and global list. 1417 */ 1418 void of_attach_node(struct device_node *np) 1419 { 1420 unsigned long flags; 1421 1422 write_lock_irqsave(&devtree_lock, flags); 1423 np->sibling = np->parent->child; 1424 np->allnext = allnodes; 1425 np->parent->child = np; 1426 allnodes = np; 1427 write_unlock_irqrestore(&devtree_lock, flags); 1428 } 1429 1430 /* 1431 * "Unplug" a node from the device tree. The caller must hold 1432 * a reference to the node. The memory associated with the node 1433 * is not freed until its refcount goes to zero. 1434 */ 1435 void of_detach_node(struct device_node *np) 1436 { 1437 struct device_node *parent; 1438 unsigned long flags; 1439 1440 write_lock_irqsave(&devtree_lock, flags); 1441 1442 parent = np->parent; 1443 if (!parent) 1444 goto out_unlock; 1445 1446 if (allnodes == np) 1447 allnodes = np->allnext; 1448 else { 1449 struct device_node *prev; 1450 for (prev = allnodes; 1451 prev->allnext != np; 1452 prev = prev->allnext) 1453 ; 1454 prev->allnext = np->allnext; 1455 } 1456 1457 if (parent->child == np) 1458 parent->child = np->sibling; 1459 else { 1460 struct device_node *prevsib; 1461 for (prevsib = np->parent->child; 1462 prevsib->sibling != np; 1463 prevsib = prevsib->sibling) 1464 ; 1465 prevsib->sibling = np->sibling; 1466 } 1467 1468 of_node_set_flag(np, OF_DETACHED); 1469 1470 out_unlock: 1471 write_unlock_irqrestore(&devtree_lock, flags); 1472 } 1473 1474 #ifdef CONFIG_PPC_PSERIES 1475 /* 1476 * Fix up the uninitialized fields in a new device node: 1477 * name, type and pci-specific fields 1478 */ 1479 1480 static int of_finish_dynamic_node(struct device_node *node) 1481 { 1482 struct device_node *parent = of_get_parent(node); 1483 int err = 0; 1484 const phandle *ibm_phandle; 1485 1486 node->name = of_get_property(node, "name", NULL); 1487 node->type = of_get_property(node, "device_type", NULL); 1488 1489 if (!node->name) 1490 node->name = "<NULL>"; 1491 if (!node->type) 1492 node->type = "<NULL>"; 1493 1494 if (!parent) { 1495 err = -ENODEV; 1496 goto out; 1497 } 1498 1499 /* We don't support that function on PowerMac, at least 1500 * not yet 1501 */ 1502 if (machine_is(powermac)) 1503 return -ENODEV; 1504 1505 /* fix up new node's linux_phandle field */ 1506 if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL))) 1507 node->linux_phandle = *ibm_phandle; 1508 1509 out: 1510 of_node_put(parent); 1511 return err; 1512 } 1513 1514 static int prom_reconfig_notifier(struct notifier_block *nb, 1515 unsigned long action, void *node) 1516 { 1517 int err; 1518 1519 switch (action) { 1520 case PSERIES_RECONFIG_ADD: 1521 err = of_finish_dynamic_node(node); 1522 if (err < 0) { 1523 printk(KERN_ERR "finish_node returned %d\n", err); 1524 err = NOTIFY_BAD; 1525 } 1526 break; 1527 default: 1528 err = NOTIFY_DONE; 1529 break; 1530 } 1531 return err; 1532 } 1533 1534 static struct notifier_block prom_reconfig_nb = { 1535 .notifier_call = prom_reconfig_notifier, 1536 .priority = 10, /* This one needs to run first */ 1537 }; 1538 1539 static int __init prom_reconfig_setup(void) 1540 { 1541 return pSeries_reconfig_notifier_register(&prom_reconfig_nb); 1542 } 1543 __initcall(prom_reconfig_setup); 1544 #endif 1545 1546 /* 1547 * Add a property to a node 1548 */ 1549 int prom_add_property(struct device_node* np, struct property* prop) 1550 { 1551 struct property **next; 1552 unsigned long flags; 1553 1554 prop->next = NULL; 1555 write_lock_irqsave(&devtree_lock, flags); 1556 next = &np->properties; 1557 while (*next) { 1558 if (strcmp(prop->name, (*next)->name) == 0) { 1559 /* duplicate ! don't insert it */ 1560 write_unlock_irqrestore(&devtree_lock, flags); 1561 return -1; 1562 } 1563 next = &(*next)->next; 1564 } 1565 *next = prop; 1566 write_unlock_irqrestore(&devtree_lock, flags); 1567 1568 #ifdef CONFIG_PROC_DEVICETREE 1569 /* try to add to proc as well if it was initialized */ 1570 if (np->pde) 1571 proc_device_tree_add_prop(np->pde, prop); 1572 #endif /* CONFIG_PROC_DEVICETREE */ 1573 1574 return 0; 1575 } 1576 1577 /* 1578 * Remove a property from a node. Note that we don't actually 1579 * remove it, since we have given out who-knows-how-many pointers 1580 * to the data using get-property. Instead we just move the property 1581 * to the "dead properties" list, so it won't be found any more. 1582 */ 1583 int prom_remove_property(struct device_node *np, struct property *prop) 1584 { 1585 struct property **next; 1586 unsigned long flags; 1587 int found = 0; 1588 1589 write_lock_irqsave(&devtree_lock, flags); 1590 next = &np->properties; 1591 while (*next) { 1592 if (*next == prop) { 1593 /* found the node */ 1594 *next = prop->next; 1595 prop->next = np->deadprops; 1596 np->deadprops = prop; 1597 found = 1; 1598 break; 1599 } 1600 next = &(*next)->next; 1601 } 1602 write_unlock_irqrestore(&devtree_lock, flags); 1603 1604 if (!found) 1605 return -ENODEV; 1606 1607 #ifdef CONFIG_PROC_DEVICETREE 1608 /* try to remove the proc node as well */ 1609 if (np->pde) 1610 proc_device_tree_remove_prop(np->pde, prop); 1611 #endif /* CONFIG_PROC_DEVICETREE */ 1612 1613 return 0; 1614 } 1615 1616 /* 1617 * Update a property in a node. Note that we don't actually 1618 * remove it, since we have given out who-knows-how-many pointers 1619 * to the data using get-property. Instead we just move the property 1620 * to the "dead properties" list, and add the new property to the 1621 * property list 1622 */ 1623 int prom_update_property(struct device_node *np, 1624 struct property *newprop, 1625 struct property *oldprop) 1626 { 1627 struct property **next; 1628 unsigned long flags; 1629 int found = 0; 1630 1631 write_lock_irqsave(&devtree_lock, flags); 1632 next = &np->properties; 1633 while (*next) { 1634 if (*next == oldprop) { 1635 /* found the node */ 1636 newprop->next = oldprop->next; 1637 *next = newprop; 1638 oldprop->next = np->deadprops; 1639 np->deadprops = oldprop; 1640 found = 1; 1641 break; 1642 } 1643 next = &(*next)->next; 1644 } 1645 write_unlock_irqrestore(&devtree_lock, flags); 1646 1647 if (!found) 1648 return -ENODEV; 1649 1650 #ifdef CONFIG_PROC_DEVICETREE 1651 /* try to add to proc as well if it was initialized */ 1652 if (np->pde) 1653 proc_device_tree_update_prop(np->pde, newprop, oldprop); 1654 #endif /* CONFIG_PROC_DEVICETREE */ 1655 1656 return 0; 1657 } 1658 1659 1660 /* Find the device node for a given logical cpu number, also returns the cpu 1661 * local thread number (index in ibm,interrupt-server#s) if relevant and 1662 * asked for (non NULL) 1663 */ 1664 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread) 1665 { 1666 int hardid; 1667 struct device_node *np; 1668 1669 hardid = get_hard_smp_processor_id(cpu); 1670 1671 for_each_node_by_type(np, "cpu") { 1672 const u32 *intserv; 1673 unsigned int plen, t; 1674 1675 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist 1676 * fallback to "reg" property and assume no threads 1677 */ 1678 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", 1679 &plen); 1680 if (intserv == NULL) { 1681 const u32 *reg = of_get_property(np, "reg", NULL); 1682 if (reg == NULL) 1683 continue; 1684 if (*reg == hardid) { 1685 if (thread) 1686 *thread = 0; 1687 return np; 1688 } 1689 } else { 1690 plen /= sizeof(u32); 1691 for (t = 0; t < plen; t++) { 1692 if (hardid == intserv[t]) { 1693 if (thread) 1694 *thread = t; 1695 return np; 1696 } 1697 } 1698 } 1699 } 1700 return NULL; 1701 } 1702 EXPORT_SYMBOL(of_get_cpu_node); 1703 1704 #if defined(CONFIG_DEBUG_FS) && defined(DEBUG) 1705 static struct debugfs_blob_wrapper flat_dt_blob; 1706 1707 static int __init export_flat_device_tree(void) 1708 { 1709 struct dentry *d; 1710 1711 flat_dt_blob.data = initial_boot_params; 1712 flat_dt_blob.size = initial_boot_params->totalsize; 1713 1714 d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR, 1715 powerpc_debugfs_root, &flat_dt_blob); 1716 if (!d) 1717 return 1; 1718 1719 return 0; 1720 } 1721 __initcall(export_flat_device_tree); 1722 #endif 1723