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