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/config.h> 20 #include <linux/kernel.h> 21 #include <linux/string.h> 22 #include <linux/init.h> 23 #include <linux/threads.h> 24 #include <linux/spinlock.h> 25 #include <linux/types.h> 26 #include <linux/pci.h> 27 #include <linux/stringify.h> 28 #include <linux/delay.h> 29 #include <linux/initrd.h> 30 #include <linux/bitops.h> 31 #include <linux/module.h> 32 #include <linux/kexec.h> 33 34 #include <asm/prom.h> 35 #include <asm/rtas.h> 36 #include <asm/lmb.h> 37 #include <asm/page.h> 38 #include <asm/processor.h> 39 #include <asm/irq.h> 40 #include <asm/io.h> 41 #include <asm/kdump.h> 42 #include <asm/smp.h> 43 #include <asm/system.h> 44 #include <asm/mmu.h> 45 #include <asm/pgtable.h> 46 #include <asm/pci.h> 47 #include <asm/iommu.h> 48 #include <asm/btext.h> 49 #include <asm/sections.h> 50 #include <asm/machdep.h> 51 #include <asm/pSeries_reconfig.h> 52 #include <asm/pci-bridge.h> 53 54 #ifdef DEBUG 55 #define DBG(fmt...) printk(KERN_ERR fmt) 56 #else 57 #define DBG(fmt...) 58 #endif 59 60 61 static int __initdata dt_root_addr_cells; 62 static int __initdata dt_root_size_cells; 63 64 #ifdef CONFIG_PPC64 65 static int __initdata iommu_is_off; 66 int __initdata iommu_force_on; 67 unsigned long tce_alloc_start, tce_alloc_end; 68 #endif 69 70 typedef u32 cell_t; 71 72 #if 0 73 static struct boot_param_header *initial_boot_params __initdata; 74 #else 75 struct boot_param_header *initial_boot_params; 76 #endif 77 78 static struct device_node *allnodes = NULL; 79 80 /* use when traversing tree through the allnext, child, sibling, 81 * or parent members of struct device_node. 82 */ 83 static DEFINE_RWLOCK(devtree_lock); 84 85 /* export that to outside world */ 86 struct device_node *of_chosen; 87 88 struct device_node *dflt_interrupt_controller; 89 int num_interrupt_controllers; 90 91 /* 92 * Wrapper for allocating memory for various data that needs to be 93 * attached to device nodes as they are processed at boot or when 94 * added to the device tree later (e.g. DLPAR). At boot there is 95 * already a region reserved so we just increment *mem_start by size; 96 * otherwise we call kmalloc. 97 */ 98 static void * prom_alloc(unsigned long size, unsigned long *mem_start) 99 { 100 unsigned long tmp; 101 102 if (!mem_start) 103 return kmalloc(size, GFP_KERNEL); 104 105 tmp = *mem_start; 106 *mem_start += size; 107 return (void *)tmp; 108 } 109 110 /* 111 * Find the device_node with a given phandle. 112 */ 113 static struct device_node * find_phandle(phandle ph) 114 { 115 struct device_node *np; 116 117 for (np = allnodes; np != 0; np = np->allnext) 118 if (np->linux_phandle == ph) 119 return np; 120 return NULL; 121 } 122 123 /* 124 * Find the interrupt parent of a node. 125 */ 126 static struct device_node * __devinit intr_parent(struct device_node *p) 127 { 128 phandle *parp; 129 130 parp = (phandle *) get_property(p, "interrupt-parent", NULL); 131 if (parp == NULL) 132 return p->parent; 133 p = find_phandle(*parp); 134 if (p != NULL) 135 return p; 136 /* 137 * On a powermac booted with BootX, we don't get to know the 138 * phandles for any nodes, so find_phandle will return NULL. 139 * Fortunately these machines only have one interrupt controller 140 * so there isn't in fact any ambiguity. -- paulus 141 */ 142 if (num_interrupt_controllers == 1) 143 p = dflt_interrupt_controller; 144 return p; 145 } 146 147 /* 148 * Find out the size of each entry of the interrupts property 149 * for a node. 150 */ 151 int __devinit prom_n_intr_cells(struct device_node *np) 152 { 153 struct device_node *p; 154 unsigned int *icp; 155 156 for (p = np; (p = intr_parent(p)) != NULL; ) { 157 icp = (unsigned int *) 158 get_property(p, "#interrupt-cells", NULL); 159 if (icp != NULL) 160 return *icp; 161 if (get_property(p, "interrupt-controller", NULL) != NULL 162 || get_property(p, "interrupt-map", NULL) != NULL) { 163 printk("oops, node %s doesn't have #interrupt-cells\n", 164 p->full_name); 165 return 1; 166 } 167 } 168 #ifdef DEBUG_IRQ 169 printk("prom_n_intr_cells failed for %s\n", np->full_name); 170 #endif 171 return 1; 172 } 173 174 /* 175 * Map an interrupt from a device up to the platform interrupt 176 * descriptor. 177 */ 178 static int __devinit map_interrupt(unsigned int **irq, struct device_node **ictrler, 179 struct device_node *np, unsigned int *ints, 180 int nintrc) 181 { 182 struct device_node *p, *ipar; 183 unsigned int *imap, *imask, *ip; 184 int i, imaplen, match; 185 int newintrc = 0, newaddrc = 0; 186 unsigned int *reg; 187 int naddrc; 188 189 reg = (unsigned int *) get_property(np, "reg", NULL); 190 naddrc = prom_n_addr_cells(np); 191 p = intr_parent(np); 192 while (p != NULL) { 193 if (get_property(p, "interrupt-controller", NULL) != NULL) 194 /* this node is an interrupt controller, stop here */ 195 break; 196 imap = (unsigned int *) 197 get_property(p, "interrupt-map", &imaplen); 198 if (imap == NULL) { 199 p = intr_parent(p); 200 continue; 201 } 202 imask = (unsigned int *) 203 get_property(p, "interrupt-map-mask", NULL); 204 if (imask == NULL) { 205 printk("oops, %s has interrupt-map but no mask\n", 206 p->full_name); 207 return 0; 208 } 209 imaplen /= sizeof(unsigned int); 210 match = 0; 211 ipar = NULL; 212 while (imaplen > 0 && !match) { 213 /* check the child-interrupt field */ 214 match = 1; 215 for (i = 0; i < naddrc && match; ++i) 216 match = ((reg[i] ^ imap[i]) & imask[i]) == 0; 217 for (; i < naddrc + nintrc && match; ++i) 218 match = ((ints[i-naddrc] ^ imap[i]) & imask[i]) == 0; 219 imap += naddrc + nintrc; 220 imaplen -= naddrc + nintrc; 221 /* grab the interrupt parent */ 222 ipar = find_phandle((phandle) *imap++); 223 --imaplen; 224 if (ipar == NULL && num_interrupt_controllers == 1) 225 /* cope with BootX not giving us phandles */ 226 ipar = dflt_interrupt_controller; 227 if (ipar == NULL) { 228 printk("oops, no int parent %x in map of %s\n", 229 imap[-1], p->full_name); 230 return 0; 231 } 232 /* find the parent's # addr and intr cells */ 233 ip = (unsigned int *) 234 get_property(ipar, "#interrupt-cells", NULL); 235 if (ip == NULL) { 236 printk("oops, no #interrupt-cells on %s\n", 237 ipar->full_name); 238 return 0; 239 } 240 newintrc = *ip; 241 ip = (unsigned int *) 242 get_property(ipar, "#address-cells", NULL); 243 newaddrc = (ip == NULL)? 0: *ip; 244 imap += newaddrc + newintrc; 245 imaplen -= newaddrc + newintrc; 246 } 247 if (imaplen < 0) { 248 printk("oops, error decoding int-map on %s, len=%d\n", 249 p->full_name, imaplen); 250 return 0; 251 } 252 if (!match) { 253 #ifdef DEBUG_IRQ 254 printk("oops, no match in %s int-map for %s\n", 255 p->full_name, np->full_name); 256 #endif 257 return 0; 258 } 259 p = ipar; 260 naddrc = newaddrc; 261 nintrc = newintrc; 262 ints = imap - nintrc; 263 reg = ints - naddrc; 264 } 265 if (p == NULL) { 266 #ifdef DEBUG_IRQ 267 printk("hmmm, int tree for %s doesn't have ctrler\n", 268 np->full_name); 269 #endif 270 return 0; 271 } 272 *irq = ints; 273 *ictrler = p; 274 return nintrc; 275 } 276 277 static unsigned char map_isa_senses[4] = { 278 IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE, 279 IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE, 280 IRQ_SENSE_EDGE | IRQ_POLARITY_NEGATIVE, 281 IRQ_SENSE_EDGE | IRQ_POLARITY_POSITIVE 282 }; 283 284 static unsigned char map_mpic_senses[4] = { 285 IRQ_SENSE_EDGE | IRQ_POLARITY_POSITIVE, 286 IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE, 287 /* 2 seems to be used for the 8259 cascade... */ 288 IRQ_SENSE_LEVEL | IRQ_POLARITY_POSITIVE, 289 IRQ_SENSE_EDGE | IRQ_POLARITY_NEGATIVE, 290 }; 291 292 static int __devinit finish_node_interrupts(struct device_node *np, 293 unsigned long *mem_start, 294 int measure_only) 295 { 296 unsigned int *ints; 297 int intlen, intrcells, intrcount; 298 int i, j, n, sense; 299 unsigned int *irq, virq; 300 struct device_node *ic; 301 int trace = 0; 302 303 //#define TRACE(fmt...) do { if (trace) { printk(fmt); mdelay(1000); } } while(0) 304 #define TRACE(fmt...) 305 306 if (!strcmp(np->name, "smu-doorbell")) 307 trace = 1; 308 309 TRACE("Finishing SMU doorbell ! num_interrupt_controllers = %d\n", 310 num_interrupt_controllers); 311 312 if (num_interrupt_controllers == 0) { 313 /* 314 * Old machines just have a list of interrupt numbers 315 * and no interrupt-controller nodes. 316 */ 317 ints = (unsigned int *) get_property(np, "AAPL,interrupts", 318 &intlen); 319 /* XXX old interpret_pci_props looked in parent too */ 320 /* XXX old interpret_macio_props looked for interrupts 321 before AAPL,interrupts */ 322 if (ints == NULL) 323 ints = (unsigned int *) get_property(np, "interrupts", 324 &intlen); 325 if (ints == NULL) 326 return 0; 327 328 np->n_intrs = intlen / sizeof(unsigned int); 329 np->intrs = prom_alloc(np->n_intrs * sizeof(np->intrs[0]), 330 mem_start); 331 if (!np->intrs) 332 return -ENOMEM; 333 if (measure_only) 334 return 0; 335 336 for (i = 0; i < np->n_intrs; ++i) { 337 np->intrs[i].line = *ints++; 338 np->intrs[i].sense = IRQ_SENSE_LEVEL 339 | IRQ_POLARITY_NEGATIVE; 340 } 341 return 0; 342 } 343 344 ints = (unsigned int *) get_property(np, "interrupts", &intlen); 345 TRACE("ints=%p, intlen=%d\n", ints, intlen); 346 if (ints == NULL) 347 return 0; 348 intrcells = prom_n_intr_cells(np); 349 intlen /= intrcells * sizeof(unsigned int); 350 TRACE("intrcells=%d, new intlen=%d\n", intrcells, intlen); 351 np->intrs = prom_alloc(intlen * sizeof(*(np->intrs)), mem_start); 352 if (!np->intrs) 353 return -ENOMEM; 354 355 if (measure_only) 356 return 0; 357 358 intrcount = 0; 359 for (i = 0; i < intlen; ++i, ints += intrcells) { 360 n = map_interrupt(&irq, &ic, np, ints, intrcells); 361 TRACE("map, irq=%d, ic=%p, n=%d\n", irq, ic, n); 362 if (n <= 0) 363 continue; 364 365 /* don't map IRQ numbers under a cascaded 8259 controller */ 366 if (ic && device_is_compatible(ic, "chrp,iic")) { 367 np->intrs[intrcount].line = irq[0]; 368 sense = (n > 1)? (irq[1] & 3): 3; 369 np->intrs[intrcount].sense = map_isa_senses[sense]; 370 } else { 371 virq = virt_irq_create_mapping(irq[0]); 372 TRACE("virq=%d\n", virq); 373 #ifdef CONFIG_PPC64 374 if (virq == NO_IRQ) { 375 printk(KERN_CRIT "Could not allocate interrupt" 376 " number for %s\n", np->full_name); 377 continue; 378 } 379 #endif 380 np->intrs[intrcount].line = irq_offset_up(virq); 381 sense = (n > 1)? (irq[1] & 3): 1; 382 383 /* Apple uses bits in there in a different way, let's 384 * only keep the real sense bit on macs 385 */ 386 if (_machine == PLATFORM_POWERMAC) 387 sense &= 0x1; 388 np->intrs[intrcount].sense = map_mpic_senses[sense]; 389 } 390 391 #ifdef CONFIG_PPC64 392 /* We offset irq numbers for the u3 MPIC by 128 in PowerMac */ 393 if (_machine == PLATFORM_POWERMAC && ic && ic->parent) { 394 char *name = get_property(ic->parent, "name", NULL); 395 if (name && !strcmp(name, "u3")) 396 np->intrs[intrcount].line += 128; 397 else if (!(name && (!strcmp(name, "mac-io") || 398 !strcmp(name, "u4")))) 399 /* ignore other cascaded controllers, such as 400 the k2-sata-root */ 401 break; 402 } 403 #endif /* CONFIG_PPC64 */ 404 if (n > 2) { 405 printk("hmmm, got %d intr cells for %s:", n, 406 np->full_name); 407 for (j = 0; j < n; ++j) 408 printk(" %d", irq[j]); 409 printk("\n"); 410 } 411 ++intrcount; 412 } 413 np->n_intrs = intrcount; 414 415 return 0; 416 } 417 418 static int __devinit finish_node(struct device_node *np, 419 unsigned long *mem_start, 420 int measure_only) 421 { 422 struct device_node *child; 423 int rc = 0; 424 425 rc = finish_node_interrupts(np, mem_start, measure_only); 426 if (rc) 427 goto out; 428 429 for (child = np->child; child != NULL; child = child->sibling) { 430 rc = finish_node(child, mem_start, measure_only); 431 if (rc) 432 goto out; 433 } 434 out: 435 return rc; 436 } 437 438 static void __init scan_interrupt_controllers(void) 439 { 440 struct device_node *np; 441 int n = 0; 442 char *name, *ic; 443 int iclen; 444 445 for (np = allnodes; np != NULL; np = np->allnext) { 446 ic = get_property(np, "interrupt-controller", &iclen); 447 name = get_property(np, "name", NULL); 448 /* checking iclen makes sure we don't get a false 449 match on /chosen.interrupt_controller */ 450 if ((name != NULL 451 && strcmp(name, "interrupt-controller") == 0) 452 || (ic != NULL && iclen == 0 453 && strcmp(name, "AppleKiwi"))) { 454 if (n == 0) 455 dflt_interrupt_controller = np; 456 ++n; 457 } 458 } 459 num_interrupt_controllers = n; 460 } 461 462 /** 463 * finish_device_tree is called once things are running normally 464 * (i.e. with text and data mapped to the address they were linked at). 465 * It traverses the device tree and fills in some of the additional, 466 * fields in each node like {n_}addrs and {n_}intrs, the virt interrupt 467 * mapping is also initialized at this point. 468 */ 469 void __init finish_device_tree(void) 470 { 471 unsigned long start, end, size = 0; 472 473 DBG(" -> finish_device_tree\n"); 474 475 #ifdef CONFIG_PPC64 476 /* Initialize virtual IRQ map */ 477 virt_irq_init(); 478 #endif 479 scan_interrupt_controllers(); 480 481 /* 482 * Finish device-tree (pre-parsing some properties etc...) 483 * We do this in 2 passes. One with "measure_only" set, which 484 * will only measure the amount of memory needed, then we can 485 * allocate that memory, and call finish_node again. However, 486 * we must be careful as most routines will fail nowadays when 487 * prom_alloc() returns 0, so we must make sure our first pass 488 * doesn't start at 0. We pre-initialize size to 16 for that 489 * reason and then remove those additional 16 bytes 490 */ 491 size = 16; 492 finish_node(allnodes, &size, 1); 493 size -= 16; 494 495 if (0 == size) 496 end = start = 0; 497 else 498 end = start = (unsigned long)__va(lmb_alloc(size, 128)); 499 500 finish_node(allnodes, &end, 0); 501 BUG_ON(end != start + size); 502 503 DBG(" <- finish_device_tree\n"); 504 } 505 506 static inline char *find_flat_dt_string(u32 offset) 507 { 508 return ((char *)initial_boot_params) + 509 initial_boot_params->off_dt_strings + offset; 510 } 511 512 /** 513 * This function is used to scan the flattened device-tree, it is 514 * used to extract the memory informations at boot before we can 515 * unflatten the tree 516 */ 517 int __init of_scan_flat_dt(int (*it)(unsigned long node, 518 const char *uname, int depth, 519 void *data), 520 void *data) 521 { 522 unsigned long p = ((unsigned long)initial_boot_params) + 523 initial_boot_params->off_dt_struct; 524 int rc = 0; 525 int depth = -1; 526 527 do { 528 u32 tag = *((u32 *)p); 529 char *pathp; 530 531 p += 4; 532 if (tag == OF_DT_END_NODE) { 533 depth --; 534 continue; 535 } 536 if (tag == OF_DT_NOP) 537 continue; 538 if (tag == OF_DT_END) 539 break; 540 if (tag == OF_DT_PROP) { 541 u32 sz = *((u32 *)p); 542 p += 8; 543 if (initial_boot_params->version < 0x10) 544 p = _ALIGN(p, sz >= 8 ? 8 : 4); 545 p += sz; 546 p = _ALIGN(p, 4); 547 continue; 548 } 549 if (tag != OF_DT_BEGIN_NODE) { 550 printk(KERN_WARNING "Invalid tag %x scanning flattened" 551 " device tree !\n", tag); 552 return -EINVAL; 553 } 554 depth++; 555 pathp = (char *)p; 556 p = _ALIGN(p + strlen(pathp) + 1, 4); 557 if ((*pathp) == '/') { 558 char *lp, *np; 559 for (lp = NULL, np = pathp; *np; np++) 560 if ((*np) == '/') 561 lp = np+1; 562 if (lp != NULL) 563 pathp = lp; 564 } 565 rc = it(p, pathp, depth, data); 566 if (rc != 0) 567 break; 568 } while(1); 569 570 return rc; 571 } 572 573 /** 574 * This function can be used within scan_flattened_dt callback to get 575 * access to properties 576 */ 577 void* __init of_get_flat_dt_prop(unsigned long node, const char *name, 578 unsigned long *size) 579 { 580 unsigned long p = node; 581 582 do { 583 u32 tag = *((u32 *)p); 584 u32 sz, noff; 585 const char *nstr; 586 587 p += 4; 588 if (tag == OF_DT_NOP) 589 continue; 590 if (tag != OF_DT_PROP) 591 return NULL; 592 593 sz = *((u32 *)p); 594 noff = *((u32 *)(p + 4)); 595 p += 8; 596 if (initial_boot_params->version < 0x10) 597 p = _ALIGN(p, sz >= 8 ? 8 : 4); 598 599 nstr = find_flat_dt_string(noff); 600 if (nstr == NULL) { 601 printk(KERN_WARNING "Can't find property index" 602 " name !\n"); 603 return NULL; 604 } 605 if (strcmp(name, nstr) == 0) { 606 if (size) 607 *size = sz; 608 return (void *)p; 609 } 610 p += sz; 611 p = _ALIGN(p, 4); 612 } while(1); 613 } 614 615 static void *__init unflatten_dt_alloc(unsigned long *mem, unsigned long size, 616 unsigned long align) 617 { 618 void *res; 619 620 *mem = _ALIGN(*mem, align); 621 res = (void *)*mem; 622 *mem += size; 623 624 return res; 625 } 626 627 static unsigned long __init unflatten_dt_node(unsigned long mem, 628 unsigned long *p, 629 struct device_node *dad, 630 struct device_node ***allnextpp, 631 unsigned long fpsize) 632 { 633 struct device_node *np; 634 struct property *pp, **prev_pp = NULL; 635 char *pathp; 636 u32 tag; 637 unsigned int l, allocl; 638 int has_name = 0; 639 int new_format = 0; 640 641 tag = *((u32 *)(*p)); 642 if (tag != OF_DT_BEGIN_NODE) { 643 printk("Weird tag at start of node: %x\n", tag); 644 return mem; 645 } 646 *p += 4; 647 pathp = (char *)*p; 648 l = allocl = strlen(pathp) + 1; 649 *p = _ALIGN(*p + l, 4); 650 651 /* version 0x10 has a more compact unit name here instead of the full 652 * path. we accumulate the full path size using "fpsize", we'll rebuild 653 * it later. We detect this because the first character of the name is 654 * not '/'. 655 */ 656 if ((*pathp) != '/') { 657 new_format = 1; 658 if (fpsize == 0) { 659 /* root node: special case. fpsize accounts for path 660 * plus terminating zero. root node only has '/', so 661 * fpsize should be 2, but we want to avoid the first 662 * level nodes to have two '/' so we use fpsize 1 here 663 */ 664 fpsize = 1; 665 allocl = 2; 666 } else { 667 /* account for '/' and path size minus terminal 0 668 * already in 'l' 669 */ 670 fpsize += l; 671 allocl = fpsize; 672 } 673 } 674 675 676 np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl, 677 __alignof__(struct device_node)); 678 if (allnextpp) { 679 memset(np, 0, sizeof(*np)); 680 np->full_name = ((char*)np) + sizeof(struct device_node); 681 if (new_format) { 682 char *p = np->full_name; 683 /* rebuild full path for new format */ 684 if (dad && dad->parent) { 685 strcpy(p, dad->full_name); 686 #ifdef DEBUG 687 if ((strlen(p) + l + 1) != allocl) { 688 DBG("%s: p: %d, l: %d, a: %d\n", 689 pathp, strlen(p), l, allocl); 690 } 691 #endif 692 p += strlen(p); 693 } 694 *(p++) = '/'; 695 memcpy(p, pathp, l); 696 } else 697 memcpy(np->full_name, pathp, l); 698 prev_pp = &np->properties; 699 **allnextpp = np; 700 *allnextpp = &np->allnext; 701 if (dad != NULL) { 702 np->parent = dad; 703 /* we temporarily use the next field as `last_child'*/ 704 if (dad->next == 0) 705 dad->child = np; 706 else 707 dad->next->sibling = np; 708 dad->next = np; 709 } 710 kref_init(&np->kref); 711 } 712 while(1) { 713 u32 sz, noff; 714 char *pname; 715 716 tag = *((u32 *)(*p)); 717 if (tag == OF_DT_NOP) { 718 *p += 4; 719 continue; 720 } 721 if (tag != OF_DT_PROP) 722 break; 723 *p += 4; 724 sz = *((u32 *)(*p)); 725 noff = *((u32 *)((*p) + 4)); 726 *p += 8; 727 if (initial_boot_params->version < 0x10) 728 *p = _ALIGN(*p, sz >= 8 ? 8 : 4); 729 730 pname = find_flat_dt_string(noff); 731 if (pname == NULL) { 732 printk("Can't find property name in list !\n"); 733 break; 734 } 735 if (strcmp(pname, "name") == 0) 736 has_name = 1; 737 l = strlen(pname) + 1; 738 pp = unflatten_dt_alloc(&mem, sizeof(struct property), 739 __alignof__(struct property)); 740 if (allnextpp) { 741 if (strcmp(pname, "linux,phandle") == 0) { 742 np->node = *((u32 *)*p); 743 if (np->linux_phandle == 0) 744 np->linux_phandle = np->node; 745 } 746 if (strcmp(pname, "ibm,phandle") == 0) 747 np->linux_phandle = *((u32 *)*p); 748 pp->name = pname; 749 pp->length = sz; 750 pp->value = (void *)*p; 751 *prev_pp = pp; 752 prev_pp = &pp->next; 753 } 754 *p = _ALIGN((*p) + sz, 4); 755 } 756 /* with version 0x10 we may not have the name property, recreate 757 * it here from the unit name if absent 758 */ 759 if (!has_name) { 760 char *p = pathp, *ps = pathp, *pa = NULL; 761 int sz; 762 763 while (*p) { 764 if ((*p) == '@') 765 pa = p; 766 if ((*p) == '/') 767 ps = p + 1; 768 p++; 769 } 770 if (pa < ps) 771 pa = p; 772 sz = (pa - ps) + 1; 773 pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz, 774 __alignof__(struct property)); 775 if (allnextpp) { 776 pp->name = "name"; 777 pp->length = sz; 778 pp->value = (unsigned char *)(pp + 1); 779 *prev_pp = pp; 780 prev_pp = &pp->next; 781 memcpy(pp->value, ps, sz - 1); 782 ((char *)pp->value)[sz - 1] = 0; 783 DBG("fixed up name for %s -> %s\n", pathp, pp->value); 784 } 785 } 786 if (allnextpp) { 787 *prev_pp = NULL; 788 np->name = get_property(np, "name", NULL); 789 np->type = get_property(np, "device_type", NULL); 790 791 if (!np->name) 792 np->name = "<NULL>"; 793 if (!np->type) 794 np->type = "<NULL>"; 795 } 796 while (tag == OF_DT_BEGIN_NODE) { 797 mem = unflatten_dt_node(mem, p, np, allnextpp, fpsize); 798 tag = *((u32 *)(*p)); 799 } 800 if (tag != OF_DT_END_NODE) { 801 printk("Weird tag at end of node: %x\n", tag); 802 return mem; 803 } 804 *p += 4; 805 return mem; 806 } 807 808 809 /** 810 * unflattens the device-tree passed by the firmware, creating the 811 * tree of struct device_node. It also fills the "name" and "type" 812 * pointers of the nodes so the normal device-tree walking functions 813 * can be used (this used to be done by finish_device_tree) 814 */ 815 void __init unflatten_device_tree(void) 816 { 817 unsigned long start, mem, size; 818 struct device_node **allnextp = &allnodes; 819 char *p = NULL; 820 int l = 0; 821 822 DBG(" -> unflatten_device_tree()\n"); 823 824 /* First pass, scan for size */ 825 start = ((unsigned long)initial_boot_params) + 826 initial_boot_params->off_dt_struct; 827 size = unflatten_dt_node(0, &start, NULL, NULL, 0); 828 size = (size | 3) + 1; 829 830 DBG(" size is %lx, allocating...\n", size); 831 832 /* Allocate memory for the expanded device tree */ 833 mem = lmb_alloc(size + 4, __alignof__(struct device_node)); 834 if (!mem) { 835 DBG("Couldn't allocate memory with lmb_alloc()!\n"); 836 panic("Couldn't allocate memory with lmb_alloc()!\n"); 837 } 838 mem = (unsigned long) __va(mem); 839 840 ((u32 *)mem)[size / 4] = 0xdeadbeef; 841 842 DBG(" unflattening %lx...\n", mem); 843 844 /* Second pass, do actual unflattening */ 845 start = ((unsigned long)initial_boot_params) + 846 initial_boot_params->off_dt_struct; 847 unflatten_dt_node(mem, &start, NULL, &allnextp, 0); 848 if (*((u32 *)start) != OF_DT_END) 849 printk(KERN_WARNING "Weird tag at end of tree: %08x\n", *((u32 *)start)); 850 if (((u32 *)mem)[size / 4] != 0xdeadbeef) 851 printk(KERN_WARNING "End of tree marker overwritten: %08x\n", 852 ((u32 *)mem)[size / 4] ); 853 *allnextp = NULL; 854 855 /* Get pointer to OF "/chosen" node for use everywhere */ 856 of_chosen = of_find_node_by_path("/chosen"); 857 if (of_chosen == NULL) 858 of_chosen = of_find_node_by_path("/chosen@0"); 859 860 /* Retreive command line */ 861 if (of_chosen != NULL) { 862 p = (char *)get_property(of_chosen, "bootargs", &l); 863 if (p != NULL && l > 0) 864 strlcpy(cmd_line, p, min(l, COMMAND_LINE_SIZE)); 865 } 866 #ifdef CONFIG_CMDLINE 867 if (l == 0 || (l == 1 && (*p) == 0)) 868 strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE); 869 #endif /* CONFIG_CMDLINE */ 870 871 DBG("Command line is: %s\n", cmd_line); 872 873 DBG(" <- unflatten_device_tree()\n"); 874 } 875 876 877 static int __init early_init_dt_scan_cpus(unsigned long node, 878 const char *uname, int depth, void *data) 879 { 880 u32 *prop; 881 unsigned long size; 882 char *type = of_get_flat_dt_prop(node, "device_type", &size); 883 884 /* We are scanning "cpu" nodes only */ 885 if (type == NULL || strcmp(type, "cpu") != 0) 886 return 0; 887 888 boot_cpuid = 0; 889 boot_cpuid_phys = 0; 890 if (initial_boot_params && initial_boot_params->version >= 2) { 891 /* version 2 of the kexec param format adds the phys cpuid 892 * of booted proc. 893 */ 894 boot_cpuid_phys = initial_boot_params->boot_cpuid_phys; 895 } else { 896 /* Check if it's the boot-cpu, set it's hw index now */ 897 if (of_get_flat_dt_prop(node, 898 "linux,boot-cpu", NULL) != NULL) { 899 prop = of_get_flat_dt_prop(node, "reg", NULL); 900 if (prop != NULL) 901 boot_cpuid_phys = *prop; 902 } 903 } 904 set_hard_smp_processor_id(0, boot_cpuid_phys); 905 906 #ifdef CONFIG_ALTIVEC 907 /* Check if we have a VMX and eventually update CPU features */ 908 prop = (u32 *)of_get_flat_dt_prop(node, "ibm,vmx", NULL); 909 if (prop && (*prop) > 0) { 910 cur_cpu_spec->cpu_features |= CPU_FTR_ALTIVEC; 911 cur_cpu_spec->cpu_user_features |= PPC_FEATURE_HAS_ALTIVEC; 912 } 913 914 /* Same goes for Apple's "altivec" property */ 915 prop = (u32 *)of_get_flat_dt_prop(node, "altivec", NULL); 916 if (prop) { 917 cur_cpu_spec->cpu_features |= CPU_FTR_ALTIVEC; 918 cur_cpu_spec->cpu_user_features |= PPC_FEATURE_HAS_ALTIVEC; 919 } 920 #endif /* CONFIG_ALTIVEC */ 921 922 #ifdef CONFIG_PPC_PSERIES 923 /* 924 * Check for an SMT capable CPU and set the CPU feature. We do 925 * this by looking at the size of the ibm,ppc-interrupt-server#s 926 * property 927 */ 928 prop = (u32 *)of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", 929 &size); 930 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT; 931 if (prop && ((size / sizeof(u32)) > 1)) 932 cur_cpu_spec->cpu_features |= CPU_FTR_SMT; 933 #endif 934 935 return 0; 936 } 937 938 static int __init early_init_dt_scan_chosen(unsigned long node, 939 const char *uname, int depth, void *data) 940 { 941 u32 *prop; 942 unsigned long *lprop; 943 944 DBG("search \"chosen\", depth: %d, uname: %s\n", depth, uname); 945 946 if (depth != 1 || 947 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0)) 948 return 0; 949 950 /* get platform type */ 951 prop = (u32 *)of_get_flat_dt_prop(node, "linux,platform", NULL); 952 if (prop == NULL) 953 return 0; 954 #ifdef CONFIG_PPC_MULTIPLATFORM 955 _machine = *prop; 956 #endif 957 958 #ifdef CONFIG_PPC64 959 /* check if iommu is forced on or off */ 960 if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL) 961 iommu_is_off = 1; 962 if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL) 963 iommu_force_on = 1; 964 #endif 965 966 lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL); 967 if (lprop) 968 memory_limit = *lprop; 969 970 #ifdef CONFIG_PPC64 971 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL); 972 if (lprop) 973 tce_alloc_start = *lprop; 974 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL); 975 if (lprop) 976 tce_alloc_end = *lprop; 977 #endif 978 979 #ifdef CONFIG_PPC_RTAS 980 /* To help early debugging via the front panel, we retrieve a minimal 981 * set of RTAS infos now if available 982 */ 983 { 984 u64 *basep, *entryp; 985 986 basep = of_get_flat_dt_prop(node, "linux,rtas-base", NULL); 987 entryp = of_get_flat_dt_prop(node, "linux,rtas-entry", NULL); 988 prop = of_get_flat_dt_prop(node, "linux,rtas-size", NULL); 989 if (basep && entryp && prop) { 990 rtas.base = *basep; 991 rtas.entry = *entryp; 992 rtas.size = *prop; 993 } 994 } 995 #endif /* CONFIG_PPC_RTAS */ 996 997 #ifdef CONFIG_KEXEC 998 lprop = (u64*)of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL); 999 if (lprop) 1000 crashk_res.start = *lprop; 1001 1002 lprop = (u64*)of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL); 1003 if (lprop) 1004 crashk_res.end = crashk_res.start + *lprop - 1; 1005 #endif 1006 1007 /* break now */ 1008 return 1; 1009 } 1010 1011 static int __init early_init_dt_scan_root(unsigned long node, 1012 const char *uname, int depth, void *data) 1013 { 1014 u32 *prop; 1015 1016 if (depth != 0) 1017 return 0; 1018 1019 prop = of_get_flat_dt_prop(node, "#size-cells", NULL); 1020 dt_root_size_cells = (prop == NULL) ? 1 : *prop; 1021 DBG("dt_root_size_cells = %x\n", dt_root_size_cells); 1022 1023 prop = of_get_flat_dt_prop(node, "#address-cells", NULL); 1024 dt_root_addr_cells = (prop == NULL) ? 2 : *prop; 1025 DBG("dt_root_addr_cells = %x\n", dt_root_addr_cells); 1026 1027 /* break now */ 1028 return 1; 1029 } 1030 1031 static unsigned long __init dt_mem_next_cell(int s, cell_t **cellp) 1032 { 1033 cell_t *p = *cellp; 1034 unsigned long r; 1035 1036 /* Ignore more than 2 cells */ 1037 while (s > sizeof(unsigned long) / 4) { 1038 p++; 1039 s--; 1040 } 1041 r = *p++; 1042 #ifdef CONFIG_PPC64 1043 if (s > 1) { 1044 r <<= 32; 1045 r |= *(p++); 1046 s--; 1047 } 1048 #endif 1049 1050 *cellp = p; 1051 return r; 1052 } 1053 1054 1055 static int __init early_init_dt_scan_memory(unsigned long node, 1056 const char *uname, int depth, void *data) 1057 { 1058 char *type = of_get_flat_dt_prop(node, "device_type", NULL); 1059 cell_t *reg, *endp; 1060 unsigned long l; 1061 1062 /* We are scanning "memory" nodes only */ 1063 if (type == NULL) { 1064 /* 1065 * The longtrail doesn't have a device_type on the 1066 * /memory node, so look for the node called /memory@0. 1067 */ 1068 if (depth != 1 || strcmp(uname, "memory@0") != 0) 1069 return 0; 1070 } else if (strcmp(type, "memory") != 0) 1071 return 0; 1072 1073 reg = (cell_t *)of_get_flat_dt_prop(node, "linux,usable-memory", &l); 1074 if (reg == NULL) 1075 reg = (cell_t *)of_get_flat_dt_prop(node, "reg", &l); 1076 if (reg == NULL) 1077 return 0; 1078 1079 endp = reg + (l / sizeof(cell_t)); 1080 1081 DBG("memory scan node %s, reg size %ld, data: %x %x %x %x,\n", 1082 uname, l, reg[0], reg[1], reg[2], reg[3]); 1083 1084 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) { 1085 unsigned long base, size; 1086 1087 base = dt_mem_next_cell(dt_root_addr_cells, ®); 1088 size = dt_mem_next_cell(dt_root_size_cells, ®); 1089 1090 if (size == 0) 1091 continue; 1092 DBG(" - %lx , %lx\n", base, size); 1093 #ifdef CONFIG_PPC64 1094 if (iommu_is_off) { 1095 if (base >= 0x80000000ul) 1096 continue; 1097 if ((base + size) > 0x80000000ul) 1098 size = 0x80000000ul - base; 1099 } 1100 #endif 1101 lmb_add(base, size); 1102 } 1103 return 0; 1104 } 1105 1106 static void __init early_reserve_mem(void) 1107 { 1108 u64 base, size; 1109 u64 *reserve_map; 1110 1111 reserve_map = (u64 *)(((unsigned long)initial_boot_params) + 1112 initial_boot_params->off_mem_rsvmap); 1113 #ifdef CONFIG_PPC32 1114 /* 1115 * Handle the case where we might be booting from an old kexec 1116 * image that setup the mem_rsvmap as pairs of 32-bit values 1117 */ 1118 if (*reserve_map > 0xffffffffull) { 1119 u32 base_32, size_32; 1120 u32 *reserve_map_32 = (u32 *)reserve_map; 1121 1122 while (1) { 1123 base_32 = *(reserve_map_32++); 1124 size_32 = *(reserve_map_32++); 1125 if (size_32 == 0) 1126 break; 1127 DBG("reserving: %lx -> %lx\n", base_32, size_32); 1128 lmb_reserve(base_32, size_32); 1129 } 1130 return; 1131 } 1132 #endif 1133 while (1) { 1134 base = *(reserve_map++); 1135 size = *(reserve_map++); 1136 if (size == 0) 1137 break; 1138 DBG("reserving: %llx -> %llx\n", base, size); 1139 lmb_reserve(base, size); 1140 } 1141 1142 #if 0 1143 DBG("memory reserved, lmbs :\n"); 1144 lmb_dump_all(); 1145 #endif 1146 } 1147 1148 void __init early_init_devtree(void *params) 1149 { 1150 DBG(" -> early_init_devtree()\n"); 1151 1152 /* Setup flat device-tree pointer */ 1153 initial_boot_params = params; 1154 1155 /* Retrieve various informations from the /chosen node of the 1156 * device-tree, including the platform type, initrd location and 1157 * size, TCE reserve, and more ... 1158 */ 1159 of_scan_flat_dt(early_init_dt_scan_chosen, NULL); 1160 1161 /* Scan memory nodes and rebuild LMBs */ 1162 lmb_init(); 1163 of_scan_flat_dt(early_init_dt_scan_root, NULL); 1164 of_scan_flat_dt(early_init_dt_scan_memory, NULL); 1165 lmb_enforce_memory_limit(memory_limit); 1166 lmb_analyze(); 1167 1168 DBG("Phys. mem: %lx\n", lmb_phys_mem_size()); 1169 1170 /* Reserve LMB regions used by kernel, initrd, dt, etc... */ 1171 lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START); 1172 #ifdef CONFIG_CRASH_DUMP 1173 lmb_reserve(0, KDUMP_RESERVE_LIMIT); 1174 #endif 1175 early_reserve_mem(); 1176 1177 DBG("Scanning CPUs ...\n"); 1178 1179 /* Retreive CPU related informations from the flat tree 1180 * (altivec support, boot CPU ID, ...) 1181 */ 1182 of_scan_flat_dt(early_init_dt_scan_cpus, NULL); 1183 1184 DBG(" <- early_init_devtree()\n"); 1185 } 1186 1187 #undef printk 1188 1189 int 1190 prom_n_addr_cells(struct device_node* np) 1191 { 1192 int* ip; 1193 do { 1194 if (np->parent) 1195 np = np->parent; 1196 ip = (int *) get_property(np, "#address-cells", NULL); 1197 if (ip != NULL) 1198 return *ip; 1199 } while (np->parent); 1200 /* No #address-cells property for the root node, default to 1 */ 1201 return 1; 1202 } 1203 EXPORT_SYMBOL(prom_n_addr_cells); 1204 1205 int 1206 prom_n_size_cells(struct device_node* np) 1207 { 1208 int* ip; 1209 do { 1210 if (np->parent) 1211 np = np->parent; 1212 ip = (int *) get_property(np, "#size-cells", NULL); 1213 if (ip != NULL) 1214 return *ip; 1215 } while (np->parent); 1216 /* No #size-cells property for the root node, default to 1 */ 1217 return 1; 1218 } 1219 EXPORT_SYMBOL(prom_n_size_cells); 1220 1221 /** 1222 * Work out the sense (active-low level / active-high edge) 1223 * of each interrupt from the device tree. 1224 */ 1225 void __init prom_get_irq_senses(unsigned char *senses, int off, int max) 1226 { 1227 struct device_node *np; 1228 int i, j; 1229 1230 /* default to level-triggered */ 1231 memset(senses, IRQ_SENSE_LEVEL | IRQ_POLARITY_NEGATIVE, max - off); 1232 1233 for (np = allnodes; np != 0; np = np->allnext) { 1234 for (j = 0; j < np->n_intrs; j++) { 1235 i = np->intrs[j].line; 1236 if (i >= off && i < max) 1237 senses[i-off] = np->intrs[j].sense; 1238 } 1239 } 1240 } 1241 1242 /** 1243 * Construct and return a list of the device_nodes with a given name. 1244 */ 1245 struct device_node *find_devices(const char *name) 1246 { 1247 struct device_node *head, **prevp, *np; 1248 1249 prevp = &head; 1250 for (np = allnodes; np != 0; np = np->allnext) { 1251 if (np->name != 0 && strcasecmp(np->name, name) == 0) { 1252 *prevp = np; 1253 prevp = &np->next; 1254 } 1255 } 1256 *prevp = NULL; 1257 return head; 1258 } 1259 EXPORT_SYMBOL(find_devices); 1260 1261 /** 1262 * Construct and return a list of the device_nodes with a given type. 1263 */ 1264 struct device_node *find_type_devices(const char *type) 1265 { 1266 struct device_node *head, **prevp, *np; 1267 1268 prevp = &head; 1269 for (np = allnodes; np != 0; np = np->allnext) { 1270 if (np->type != 0 && strcasecmp(np->type, type) == 0) { 1271 *prevp = np; 1272 prevp = &np->next; 1273 } 1274 } 1275 *prevp = NULL; 1276 return head; 1277 } 1278 EXPORT_SYMBOL(find_type_devices); 1279 1280 /** 1281 * Returns all nodes linked together 1282 */ 1283 struct device_node *find_all_nodes(void) 1284 { 1285 struct device_node *head, **prevp, *np; 1286 1287 prevp = &head; 1288 for (np = allnodes; np != 0; np = np->allnext) { 1289 *prevp = np; 1290 prevp = &np->next; 1291 } 1292 *prevp = NULL; 1293 return head; 1294 } 1295 EXPORT_SYMBOL(find_all_nodes); 1296 1297 /** Checks if the given "compat" string matches one of the strings in 1298 * the device's "compatible" property 1299 */ 1300 int device_is_compatible(struct device_node *device, const char *compat) 1301 { 1302 const char* cp; 1303 int cplen, l; 1304 1305 cp = (char *) get_property(device, "compatible", &cplen); 1306 if (cp == NULL) 1307 return 0; 1308 while (cplen > 0) { 1309 if (strncasecmp(cp, compat, strlen(compat)) == 0) 1310 return 1; 1311 l = strlen(cp) + 1; 1312 cp += l; 1313 cplen -= l; 1314 } 1315 1316 return 0; 1317 } 1318 EXPORT_SYMBOL(device_is_compatible); 1319 1320 1321 /** 1322 * Indicates whether the root node has a given value in its 1323 * compatible property. 1324 */ 1325 int machine_is_compatible(const char *compat) 1326 { 1327 struct device_node *root; 1328 int rc = 0; 1329 1330 root = of_find_node_by_path("/"); 1331 if (root) { 1332 rc = device_is_compatible(root, compat); 1333 of_node_put(root); 1334 } 1335 return rc; 1336 } 1337 EXPORT_SYMBOL(machine_is_compatible); 1338 1339 /** 1340 * Construct and return a list of the device_nodes with a given type 1341 * and compatible property. 1342 */ 1343 struct device_node *find_compatible_devices(const char *type, 1344 const char *compat) 1345 { 1346 struct device_node *head, **prevp, *np; 1347 1348 prevp = &head; 1349 for (np = allnodes; np != 0; np = np->allnext) { 1350 if (type != NULL 1351 && !(np->type != 0 && strcasecmp(np->type, type) == 0)) 1352 continue; 1353 if (device_is_compatible(np, compat)) { 1354 *prevp = np; 1355 prevp = &np->next; 1356 } 1357 } 1358 *prevp = NULL; 1359 return head; 1360 } 1361 EXPORT_SYMBOL(find_compatible_devices); 1362 1363 /** 1364 * Find the device_node with a given full_name. 1365 */ 1366 struct device_node *find_path_device(const char *path) 1367 { 1368 struct device_node *np; 1369 1370 for (np = allnodes; np != 0; np = np->allnext) 1371 if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0) 1372 return np; 1373 return NULL; 1374 } 1375 EXPORT_SYMBOL(find_path_device); 1376 1377 /******* 1378 * 1379 * New implementation of the OF "find" APIs, return a refcounted 1380 * object, call of_node_put() when done. The device tree and list 1381 * are protected by a rw_lock. 1382 * 1383 * Note that property management will need some locking as well, 1384 * this isn't dealt with yet. 1385 * 1386 *******/ 1387 1388 /** 1389 * of_find_node_by_name - Find a node by its "name" property 1390 * @from: The node to start searching from or NULL, the node 1391 * you pass will not be searched, only the next one 1392 * will; typically, you pass what the previous call 1393 * returned. of_node_put() will be called on it 1394 * @name: The name string to match against 1395 * 1396 * Returns a node pointer with refcount incremented, use 1397 * of_node_put() on it when done. 1398 */ 1399 struct device_node *of_find_node_by_name(struct device_node *from, 1400 const char *name) 1401 { 1402 struct device_node *np; 1403 1404 read_lock(&devtree_lock); 1405 np = from ? from->allnext : allnodes; 1406 for (; np != 0; np = np->allnext) 1407 if (np->name != 0 && strcasecmp(np->name, name) == 0 1408 && of_node_get(np)) 1409 break; 1410 if (from) 1411 of_node_put(from); 1412 read_unlock(&devtree_lock); 1413 return np; 1414 } 1415 EXPORT_SYMBOL(of_find_node_by_name); 1416 1417 /** 1418 * of_find_node_by_type - Find a node by its "device_type" property 1419 * @from: The node to start searching from or NULL, the node 1420 * you pass will not be searched, only the next one 1421 * will; typically, you pass what the previous call 1422 * returned. of_node_put() will be called on it 1423 * @name: The type string to match against 1424 * 1425 * Returns a node pointer with refcount incremented, use 1426 * of_node_put() on it when done. 1427 */ 1428 struct device_node *of_find_node_by_type(struct device_node *from, 1429 const char *type) 1430 { 1431 struct device_node *np; 1432 1433 read_lock(&devtree_lock); 1434 np = from ? from->allnext : allnodes; 1435 for (; np != 0; np = np->allnext) 1436 if (np->type != 0 && strcasecmp(np->type, type) == 0 1437 && of_node_get(np)) 1438 break; 1439 if (from) 1440 of_node_put(from); 1441 read_unlock(&devtree_lock); 1442 return np; 1443 } 1444 EXPORT_SYMBOL(of_find_node_by_type); 1445 1446 /** 1447 * of_find_compatible_node - Find a node based on type and one of the 1448 * tokens in its "compatible" property 1449 * @from: The node to start searching from or NULL, the node 1450 * you pass will not be searched, only the next one 1451 * will; typically, you pass what the previous call 1452 * returned. of_node_put() will be called on it 1453 * @type: The type string to match "device_type" or NULL to ignore 1454 * @compatible: The string to match to one of the tokens in the device 1455 * "compatible" list. 1456 * 1457 * Returns a node pointer with refcount incremented, use 1458 * of_node_put() on it when done. 1459 */ 1460 struct device_node *of_find_compatible_node(struct device_node *from, 1461 const char *type, const char *compatible) 1462 { 1463 struct device_node *np; 1464 1465 read_lock(&devtree_lock); 1466 np = from ? from->allnext : allnodes; 1467 for (; np != 0; np = np->allnext) { 1468 if (type != NULL 1469 && !(np->type != 0 && strcasecmp(np->type, type) == 0)) 1470 continue; 1471 if (device_is_compatible(np, compatible) && of_node_get(np)) 1472 break; 1473 } 1474 if (from) 1475 of_node_put(from); 1476 read_unlock(&devtree_lock); 1477 return np; 1478 } 1479 EXPORT_SYMBOL(of_find_compatible_node); 1480 1481 /** 1482 * of_find_node_by_path - Find a node matching a full OF path 1483 * @path: The full path to match 1484 * 1485 * Returns a node pointer with refcount incremented, use 1486 * of_node_put() on it when done. 1487 */ 1488 struct device_node *of_find_node_by_path(const char *path) 1489 { 1490 struct device_node *np = allnodes; 1491 1492 read_lock(&devtree_lock); 1493 for (; np != 0; np = np->allnext) { 1494 if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0 1495 && of_node_get(np)) 1496 break; 1497 } 1498 read_unlock(&devtree_lock); 1499 return np; 1500 } 1501 EXPORT_SYMBOL(of_find_node_by_path); 1502 1503 /** 1504 * of_find_node_by_phandle - Find a node given a phandle 1505 * @handle: phandle of the node to find 1506 * 1507 * Returns a node pointer with refcount incremented, use 1508 * of_node_put() on it when done. 1509 */ 1510 struct device_node *of_find_node_by_phandle(phandle handle) 1511 { 1512 struct device_node *np; 1513 1514 read_lock(&devtree_lock); 1515 for (np = allnodes; np != 0; np = np->allnext) 1516 if (np->linux_phandle == handle) 1517 break; 1518 if (np) 1519 of_node_get(np); 1520 read_unlock(&devtree_lock); 1521 return np; 1522 } 1523 EXPORT_SYMBOL(of_find_node_by_phandle); 1524 1525 /** 1526 * of_find_all_nodes - Get next node in global list 1527 * @prev: Previous node or NULL to start iteration 1528 * of_node_put() will be called on it 1529 * 1530 * Returns a node pointer with refcount incremented, use 1531 * of_node_put() on it when done. 1532 */ 1533 struct device_node *of_find_all_nodes(struct device_node *prev) 1534 { 1535 struct device_node *np; 1536 1537 read_lock(&devtree_lock); 1538 np = prev ? prev->allnext : allnodes; 1539 for (; np != 0; np = np->allnext) 1540 if (of_node_get(np)) 1541 break; 1542 if (prev) 1543 of_node_put(prev); 1544 read_unlock(&devtree_lock); 1545 return np; 1546 } 1547 EXPORT_SYMBOL(of_find_all_nodes); 1548 1549 /** 1550 * of_get_parent - Get a node's parent if any 1551 * @node: Node to get parent 1552 * 1553 * Returns a node pointer with refcount incremented, use 1554 * of_node_put() on it when done. 1555 */ 1556 struct device_node *of_get_parent(const struct device_node *node) 1557 { 1558 struct device_node *np; 1559 1560 if (!node) 1561 return NULL; 1562 1563 read_lock(&devtree_lock); 1564 np = of_node_get(node->parent); 1565 read_unlock(&devtree_lock); 1566 return np; 1567 } 1568 EXPORT_SYMBOL(of_get_parent); 1569 1570 /** 1571 * of_get_next_child - Iterate a node childs 1572 * @node: parent node 1573 * @prev: previous child of the parent node, or NULL to get first 1574 * 1575 * Returns a node pointer with refcount incremented, use 1576 * of_node_put() on it when done. 1577 */ 1578 struct device_node *of_get_next_child(const struct device_node *node, 1579 struct device_node *prev) 1580 { 1581 struct device_node *next; 1582 1583 read_lock(&devtree_lock); 1584 next = prev ? prev->sibling : node->child; 1585 for (; next != 0; next = next->sibling) 1586 if (of_node_get(next)) 1587 break; 1588 if (prev) 1589 of_node_put(prev); 1590 read_unlock(&devtree_lock); 1591 return next; 1592 } 1593 EXPORT_SYMBOL(of_get_next_child); 1594 1595 /** 1596 * of_node_get - Increment refcount of a node 1597 * @node: Node to inc refcount, NULL is supported to 1598 * simplify writing of callers 1599 * 1600 * Returns node. 1601 */ 1602 struct device_node *of_node_get(struct device_node *node) 1603 { 1604 if (node) 1605 kref_get(&node->kref); 1606 return node; 1607 } 1608 EXPORT_SYMBOL(of_node_get); 1609 1610 static inline struct device_node * kref_to_device_node(struct kref *kref) 1611 { 1612 return container_of(kref, struct device_node, kref); 1613 } 1614 1615 /** 1616 * of_node_release - release a dynamically allocated node 1617 * @kref: kref element of the node to be released 1618 * 1619 * In of_node_put() this function is passed to kref_put() 1620 * as the destructor. 1621 */ 1622 static void of_node_release(struct kref *kref) 1623 { 1624 struct device_node *node = kref_to_device_node(kref); 1625 struct property *prop = node->properties; 1626 1627 if (!OF_IS_DYNAMIC(node)) 1628 return; 1629 while (prop) { 1630 struct property *next = prop->next; 1631 kfree(prop->name); 1632 kfree(prop->value); 1633 kfree(prop); 1634 prop = next; 1635 1636 if (!prop) { 1637 prop = node->deadprops; 1638 node->deadprops = NULL; 1639 } 1640 } 1641 kfree(node->intrs); 1642 kfree(node->full_name); 1643 kfree(node->data); 1644 kfree(node); 1645 } 1646 1647 /** 1648 * of_node_put - Decrement refcount of a node 1649 * @node: Node to dec refcount, NULL is supported to 1650 * simplify writing of callers 1651 * 1652 */ 1653 void of_node_put(struct device_node *node) 1654 { 1655 if (node) 1656 kref_put(&node->kref, of_node_release); 1657 } 1658 EXPORT_SYMBOL(of_node_put); 1659 1660 /* 1661 * Plug a device node into the tree and global list. 1662 */ 1663 void of_attach_node(struct device_node *np) 1664 { 1665 write_lock(&devtree_lock); 1666 np->sibling = np->parent->child; 1667 np->allnext = allnodes; 1668 np->parent->child = np; 1669 allnodes = np; 1670 write_unlock(&devtree_lock); 1671 } 1672 1673 /* 1674 * "Unplug" a node from the device tree. The caller must hold 1675 * a reference to the node. The memory associated with the node 1676 * is not freed until its refcount goes to zero. 1677 */ 1678 void of_detach_node(const struct device_node *np) 1679 { 1680 struct device_node *parent; 1681 1682 write_lock(&devtree_lock); 1683 1684 parent = np->parent; 1685 1686 if (allnodes == np) 1687 allnodes = np->allnext; 1688 else { 1689 struct device_node *prev; 1690 for (prev = allnodes; 1691 prev->allnext != np; 1692 prev = prev->allnext) 1693 ; 1694 prev->allnext = np->allnext; 1695 } 1696 1697 if (parent->child == np) 1698 parent->child = np->sibling; 1699 else { 1700 struct device_node *prevsib; 1701 for (prevsib = np->parent->child; 1702 prevsib->sibling != np; 1703 prevsib = prevsib->sibling) 1704 ; 1705 prevsib->sibling = np->sibling; 1706 } 1707 1708 write_unlock(&devtree_lock); 1709 } 1710 1711 #ifdef CONFIG_PPC_PSERIES 1712 /* 1713 * Fix up the uninitialized fields in a new device node: 1714 * name, type, n_addrs, addrs, n_intrs, intrs, and pci-specific fields 1715 * 1716 * A lot of boot-time code is duplicated here, because functions such 1717 * as finish_node_interrupts, interpret_pci_props, etc. cannot use the 1718 * slab allocator. 1719 * 1720 * This should probably be split up into smaller chunks. 1721 */ 1722 1723 static int of_finish_dynamic_node(struct device_node *node) 1724 { 1725 struct device_node *parent = of_get_parent(node); 1726 int err = 0; 1727 phandle *ibm_phandle; 1728 1729 node->name = get_property(node, "name", NULL); 1730 node->type = get_property(node, "device_type", NULL); 1731 1732 if (!parent) { 1733 err = -ENODEV; 1734 goto out; 1735 } 1736 1737 /* We don't support that function on PowerMac, at least 1738 * not yet 1739 */ 1740 if (_machine == PLATFORM_POWERMAC) 1741 return -ENODEV; 1742 1743 /* fix up new node's linux_phandle field */ 1744 if ((ibm_phandle = (unsigned int *)get_property(node, 1745 "ibm,phandle", NULL))) 1746 node->linux_phandle = *ibm_phandle; 1747 1748 out: 1749 of_node_put(parent); 1750 return err; 1751 } 1752 1753 static int prom_reconfig_notifier(struct notifier_block *nb, 1754 unsigned long action, void *node) 1755 { 1756 int err; 1757 1758 switch (action) { 1759 case PSERIES_RECONFIG_ADD: 1760 err = of_finish_dynamic_node(node); 1761 if (!err) 1762 finish_node(node, NULL, 0); 1763 if (err < 0) { 1764 printk(KERN_ERR "finish_node returned %d\n", err); 1765 err = NOTIFY_BAD; 1766 } 1767 break; 1768 default: 1769 err = NOTIFY_DONE; 1770 break; 1771 } 1772 return err; 1773 } 1774 1775 static struct notifier_block prom_reconfig_nb = { 1776 .notifier_call = prom_reconfig_notifier, 1777 .priority = 10, /* This one needs to run first */ 1778 }; 1779 1780 static int __init prom_reconfig_setup(void) 1781 { 1782 return pSeries_reconfig_notifier_register(&prom_reconfig_nb); 1783 } 1784 __initcall(prom_reconfig_setup); 1785 #endif 1786 1787 struct property *of_find_property(struct device_node *np, const char *name, 1788 int *lenp) 1789 { 1790 struct property *pp; 1791 1792 read_lock(&devtree_lock); 1793 for (pp = np->properties; pp != 0; pp = pp->next) 1794 if (strcmp(pp->name, name) == 0) { 1795 if (lenp != 0) 1796 *lenp = pp->length; 1797 break; 1798 } 1799 read_unlock(&devtree_lock); 1800 1801 return pp; 1802 } 1803 1804 /* 1805 * Find a property with a given name for a given node 1806 * and return the value. 1807 */ 1808 unsigned char *get_property(struct device_node *np, const char *name, 1809 int *lenp) 1810 { 1811 struct property *pp = of_find_property(np,name,lenp); 1812 return pp ? pp->value : NULL; 1813 } 1814 EXPORT_SYMBOL(get_property); 1815 1816 /* 1817 * Add a property to a node 1818 */ 1819 int prom_add_property(struct device_node* np, struct property* prop) 1820 { 1821 struct property **next; 1822 1823 prop->next = NULL; 1824 write_lock(&devtree_lock); 1825 next = &np->properties; 1826 while (*next) { 1827 if (strcmp(prop->name, (*next)->name) == 0) { 1828 /* duplicate ! don't insert it */ 1829 write_unlock(&devtree_lock); 1830 return -1; 1831 } 1832 next = &(*next)->next; 1833 } 1834 *next = prop; 1835 write_unlock(&devtree_lock); 1836 1837 #ifdef CONFIG_PROC_DEVICETREE 1838 /* try to add to proc as well if it was initialized */ 1839 if (np->pde) 1840 proc_device_tree_add_prop(np->pde, prop); 1841 #endif /* CONFIG_PROC_DEVICETREE */ 1842 1843 return 0; 1844 } 1845 1846 /* 1847 * Remove a property from a node. Note that we don't actually 1848 * remove it, since we have given out who-knows-how-many pointers 1849 * to the data using get-property. Instead we just move the property 1850 * to the "dead properties" list, so it won't be found any more. 1851 */ 1852 int prom_remove_property(struct device_node *np, struct property *prop) 1853 { 1854 struct property **next; 1855 int found = 0; 1856 1857 write_lock(&devtree_lock); 1858 next = &np->properties; 1859 while (*next) { 1860 if (*next == prop) { 1861 /* found the node */ 1862 *next = prop->next; 1863 prop->next = np->deadprops; 1864 np->deadprops = prop; 1865 found = 1; 1866 break; 1867 } 1868 next = &(*next)->next; 1869 } 1870 write_unlock(&devtree_lock); 1871 1872 if (!found) 1873 return -ENODEV; 1874 1875 #ifdef CONFIG_PROC_DEVICETREE 1876 /* try to remove the proc node as well */ 1877 if (np->pde) 1878 proc_device_tree_remove_prop(np->pde, prop); 1879 #endif /* CONFIG_PROC_DEVICETREE */ 1880 1881 return 0; 1882 } 1883 1884 /* 1885 * Update a property in a node. Note that we don't actually 1886 * remove it, since we have given out who-knows-how-many pointers 1887 * to the data using get-property. Instead we just move the property 1888 * to the "dead properties" list, and add the new property to the 1889 * property list 1890 */ 1891 int prom_update_property(struct device_node *np, 1892 struct property *newprop, 1893 struct property *oldprop) 1894 { 1895 struct property **next; 1896 int found = 0; 1897 1898 write_lock(&devtree_lock); 1899 next = &np->properties; 1900 while (*next) { 1901 if (*next == oldprop) { 1902 /* found the node */ 1903 newprop->next = oldprop->next; 1904 *next = newprop; 1905 oldprop->next = np->deadprops; 1906 np->deadprops = oldprop; 1907 found = 1; 1908 break; 1909 } 1910 next = &(*next)->next; 1911 } 1912 write_unlock(&devtree_lock); 1913 1914 if (!found) 1915 return -ENODEV; 1916 1917 #ifdef CONFIG_PROC_DEVICETREE 1918 /* try to add to proc as well if it was initialized */ 1919 if (np->pde) 1920 proc_device_tree_update_prop(np->pde, newprop, oldprop); 1921 #endif /* CONFIG_PROC_DEVICETREE */ 1922 1923 return 0; 1924 } 1925 1926 #ifdef CONFIG_KEXEC 1927 /* We may have allocated the flat device tree inside the crash kernel region 1928 * in prom_init. If so we need to move it out into regular memory. */ 1929 void kdump_move_device_tree(void) 1930 { 1931 unsigned long start, end; 1932 struct boot_param_header *new; 1933 1934 start = __pa((unsigned long)initial_boot_params); 1935 end = start + initial_boot_params->totalsize; 1936 1937 if (end < crashk_res.start || start > crashk_res.end) 1938 return; 1939 1940 new = (struct boot_param_header*) 1941 __va(lmb_alloc(initial_boot_params->totalsize, PAGE_SIZE)); 1942 1943 memcpy(new, initial_boot_params, initial_boot_params->totalsize); 1944 1945 initial_boot_params = new; 1946 1947 DBG("Flat device tree blob moved to %p\n", initial_boot_params); 1948 1949 /* XXX should we unreserve the old DT? */ 1950 } 1951 #endif /* CONFIG_KEXEC */ 1952