开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
prom.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：55k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

prom.c：源码内容
  1. /*
  2.  * BK Id: SCCS/s.prom.c 1.48 12/19/01 10:50:58 paulus
  3.  */
  4. /*
  5.  * Procedures for interfacing to the Open Firmware PROM on
  6.  * Power Macintosh computers.
  7.  *
  8.  * In particular, we are interested in the device tree
  9.  * and in using some of its services (exit, write to stdout).
  10.  *
  11.  * Paul Mackerras August 1996.
  12.  * Copyright (C) 1996 Paul Mackerras.
  13.  */
  14. #include <stdarg.h>
  15. #include <linux/config.h>
  16. #include <linux/kernel.h>
  17. #include <linux/string.h>
  18. #include <linux/init.h>
  19. #include <linux/version.h>
  20. #include <linux/threads.h>
  21. #include <linux/spinlock.h>
  22. #include <linux/ioport.h>
  23. #include <linux/pci.h>
  24. #include <linux/slab.h>
  26. #include <asm/sections.h>
  27. #include <asm/prom.h>
  28. #include <asm/page.h>
  29. #include <asm/processor.h>
  30. #include <asm/irq.h>
  31. #include <asm/io.h>
  32. #include <asm/smp.h>
  33. #include <asm/bootx.h>
  34. #include <asm/system.h>
  35. #include <asm/mmu.h>
  36. #include <asm/pgtable.h>
  37. #include <asm/bitops.h>
  38. #include <asm/bootinfo.h>
  39. #include <asm/btext.h>
  40. #include <asm/pci-bridge.h>
  41. #include "open_pic.h"
  43. #ifdef CONFIG_FB
  44. #include <asm/linux_logo.h>
  45. #endif
  47. /*
  48.  * Properties whose value is longer than this get excluded from our
  49.  * copy of the device tree.  This way we don't waste space storing
  50.  * things like "driver,AAPL,MacOS,PowerPC" properties.  But this value
  51.  * does need to be big enough to ensure that we don't lose things
  52.  * like the interrupt-map property on a PCI-PCI bridge.
  53.  */
  54. #define MAX_PROPERTY_LENGTH 4096
  56. struct prom_args {
  57. const char *service;
  58. int nargs;
  59. int nret;
  60. void *args[10];
  61. };
  63. struct pci_address {
  64. unsigned a_hi;
  65. unsigned a_mid;
  66. unsigned a_lo;
  67. };
  69. struct pci_reg_property {
  70. struct pci_address addr;
  71. unsigned size_hi;
  72. unsigned size_lo;
  73. };
  75. struct pci_range {
  76. struct pci_address addr;
  77. unsigned phys;
  78. unsigned size_hi;
  79. unsigned size_lo;
  80. };
  82. struct isa_reg_property {
  83. unsigned space;
  84. unsigned address;
  85. unsigned size;
  86. };
  88. struct pci_intr_map {
  89. struct pci_address addr;
  90. unsigned dunno;
  91. phandle int_ctrler;
  92. unsigned intr;
  93. };
  95. typedef unsigned long interpret_func(struct device_node *, unsigned long,
  96.      int, int);
  97. static interpret_func interpret_pci_props;
  98. static interpret_func interpret_dbdma_props;
  99. static interpret_func interpret_isa_props;
  100. static interpret_func interpret_macio_props;
  101. static interpret_func interpret_root_props;
  103. #ifndef FB_MAX /* avoid pulling in all of the fb stuff */
  104. #define FB_MAX 8
  105. #endif
  106. char *prom_display_paths[FB_MAX] __initdata = { 0, };
  107. phandle prom_display_nodes[FB_MAX] __initdata;
  108. unsigned int prom_num_displays __initdata = 0;
  109. char *of_stdout_device __initdata = 0;
  110. ihandle prom_disp_node __initdata = 0;
  112. prom_entry prom __initdata = 0;
  113. ihandle prom_chosen __initdata = 0;
  114. ihandle prom_stdout __initdata = 0;
  116. extern char *klimit;
  117. char *bootpath;
  118. char *bootdevice;
  120. unsigned int rtas_data;   /* physical pointer */
  121. unsigned int rtas_entry;  /* physical pointer */
  122. unsigned int rtas_size;
  123. unsigned int old_rtas;
  125. /* Set for a newworld or CHRP machine */
  126. int use_of_interrupt_tree;
  127. struct device_node *dflt_interrupt_controller;
  128. int num_interrupt_controllers;
  130. int pmac_newworld;
  132. static struct device_node *allnodes;
  134. static void *call_prom(const char *service, int nargs, int nret, ...);
  135. static void prom_exit(void);
  136. static unsigned long copy_device_tree(unsigned long, unsigned long);
  137. static unsigned long inspect_node(phandle, struct device_node *, unsigned long,
  138.   unsigned long, struct device_node ***);
  139. static unsigned long finish_node(struct device_node *, unsigned long,
  140.  interpret_func *, int, int);
  141. static unsigned long finish_node_interrupts(struct device_node *, unsigned long);
  142. static unsigned long check_display(unsigned long);
  143. static int prom_next_node(phandle *);
  144. static void *early_get_property(unsigned long, unsigned long, char *);
  145. static struct device_node *find_phandle(phandle);
  147. #ifdef CONFIG_BOOTX_TEXT
  148. static void setup_disp_fake_bi(ihandle dp);
  149. #endif
  151. extern void enter_rtas(void *);
  152. void phys_call_rtas(int, int, int, ...);
  154. extern char cmd_line[512]; /* XXX */
  155. boot_infos_t *boot_infos;
  156. unsigned long dev_tree_size;
  158. #define ALIGN(x) (((x) + sizeof(unsigned long)-1) & -sizeof(unsigned long))
  160. /* Is boot-info compatible ? */
  161. #define BOOT_INFO_IS_COMPATIBLE(bi) ((bi)->compatible_version <= BOOT_INFO_VERSION)
  162. #define BOOT_INFO_IS_V2_COMPATIBLE(bi) ((bi)->version >= 2)
  163. #define BOOT_INFO_IS_V4_COMPATIBLE(bi) ((bi)->version >= 4)
  165. /*
  166.  * Note that prom_init() and anything called from prom_init() must
  167.  * use the RELOC/PTRRELOC macros to access any static data in
  168.  * memory, since the kernel may be running at an address that is
  169.  * different from the address that it was linked at.
  170.  * (Note that strings count as static variables.)
  171.  */
  173. static void __init
  174. prom_exit()
  175. {
  176. struct prom_args args;
  177. unsigned long offset = reloc_offset();
  179. args.service = "exit";
  180. args.nargs = 0;
  181. args.nret = 0;
  182. RELOC(prom)(&args);
  183. for (;;) /* should never get here */
  184. ;
  185. }
  187. void __init
  188. prom_enter(void)
  189. {
  190. struct prom_args args;
  191. unsigned long offset = reloc_offset();
  193. args.service = RELOC("enter");
  194. args.nargs = 0;
  195. args.nret = 0;
  196. RELOC(prom)(&args);
  197. }
  199. static void * __init
  200. call_prom(const char *service, int nargs, int nret, ...)
  201. {
  202. va_list list;
  203. int i;
  204. unsigned long offset = reloc_offset();
  205. struct prom_args prom_args;
  207. prom_args.service = service;
  208. prom_args.nargs = nargs;
  209. prom_args.nret = nret;
  210. va_start(list, nret);
  211. for (i = 0; i < nargs; ++i)
  212. prom_args.args[i] = va_arg(list, void *);
  213. va_end(list);
  214. for (i = 0; i < nret; ++i)
  215. prom_args.args[i + nargs] = 0;
  216. RELOC(prom)(&prom_args);
  217. return prom_args.args[nargs];
  218. }
  220. void __init
  221. prom_print(const char *msg)
  222. {
  223. const char *p, *q;
  224. unsigned long offset = reloc_offset();
  226. if (RELOC(prom_stdout) == 0)
  227. return;
  229. for (p = msg; *p != 0; p = q) {
  230. for (q = p; *q != 0 && *q != 'n'; ++q)
  231. ;
  232. if (q > p)
  233. call_prom(RELOC("write"), 3, 1, RELOC(prom_stdout),
  234.   p, q - p);
  235. if (*q != 0) {
  236. ++q;
  237. call_prom(RELOC("write"), 3, 1, RELOC(prom_stdout),
  238.   RELOC("rn"), 2);
  239. }
  240. }
  241. }
  243. static void __init
  244. prom_print_hex(unsigned int v)
  245. {
  246. char buf[16];
  247. int i, c;
  249. for (i = 0; i < 8; ++i) {
  250. c = (v >> ((7-i)*4)) & 0xf;
  251. c += (c >= 10)? ('a' - 10): '0';
  252. buf[i] = c;
  253. }
  254. buf[i] = ' ';
  255. buf[i+1] = 0;
  256. prom_print(buf);
  257. }
  259. unsigned long smp_chrp_cpu_nr __initdata = 0;
  261. #ifdef CONFIG_SMP
  262. /*
  263.  * With CHRP SMP we need to use the OF to start the other
  264.  * processors so we can't wait until smp_boot_cpus (the OF is
  265.  * trashed by then) so we have to put the processors into
  266.  * a holding pattern controlled by the kernel (not OF) before
  267.  * we destroy the OF.
  268.  *
  269.  * This uses a chunk of high memory, puts some holding pattern
  270.  * code there and sends the other processors off to there until
  271.  * smp_boot_cpus tells them to do something.  We do that by using
  272.  * physical address 0x0.  The holding pattern checks that address
  273.  * until its cpu # is there, when it is that cpu jumps to
  274.  * __secondary_start().  smp_boot_cpus() takes care of setting those
  275.  * values.
  276.  *
  277.  * We also use physical address 0x4 here to tell when a cpu
  278.  * is in its holding pattern code.
  279.  *
  280.  * -- Cort
  281.  */
  282. static void __init
  283. prom_hold_cpus(unsigned long mem)
  284. {
  285. extern void __secondary_hold(void);
  286. unsigned long i;
  287. int cpu;
  288. phandle node;
  289. unsigned long offset = reloc_offset();
  290. char type[16], *path;
  291. unsigned int reg;
  293. /*
  294.  * XXX: hack to make sure we're chrp, assume that if we're
  295.  *      chrp we have a device_type property -- Cort
  296.  */
  297. node = call_prom(RELOC("finddevice"), 1, 1, RELOC("/"));
  298. if ( (int)call_prom(RELOC("getprop"), 4, 1, node,
  299.     RELOC("device_type"),type, sizeof(type)) <= 0)
  300. return;
  302. /* copy the holding pattern code to someplace safe (0) */
  303. /* the holding pattern is now within the first 0x100
  304.    bytes of the kernel image -- paulus */
  305. memcpy((void *)0, (void *)(KERNELBASE + offset), 0x100);
  306. flush_icache_range(0, 0x100);
  308. /* look for cpus */
  309. *(unsigned long *)(0x0) = 0;
  310. asm volatile("dcbf 0,%0": : "r" (0) : "memory");
  311. for (node = 0; prom_next_node(&node); ) {
  312. type[0] = 0;
  313. call_prom(RELOC("getprop"), 4, 1, node, RELOC("device_type"),
  314.   type, sizeof(type));
  315. if (strcmp(type, RELOC("cpu")) != 0)
  316. continue;
  317. path = (char *) mem;
  318. memset(path, 0, 256);
  319. if ((int) call_prom(RELOC("package-to-path"), 3, 1,
  320.     node, path, 255) < 0)
  321. continue;
  322. reg = -1;
  323. call_prom(RELOC("getprop"), 4, 1, node, RELOC("reg"),
  324.   &reg, sizeof(reg));
  325. cpu = RELOC(smp_chrp_cpu_nr)++;
  326. RELOC(smp_hw_index)[cpu] = reg;
  327. /* XXX: hack - don't start cpu 0, this cpu -- Cort */
  328. if (cpu == 0)
  329. continue;
  330. prom_print(RELOC("starting cpu "));
  331. prom_print(path);
  332. *(ulong *)(0x4) = 0;
  333. call_prom(RELOC("start-cpu"), 3, 0, node,
  334.   __pa(__secondary_hold), cpu);
  335. prom_print(RELOC("..."));
  336. for ( i = 0 ; (i < 10000) && (*(ulong *)(0x4) == 0); i++ )
  337. ;
  338. if (*(ulong *)(0x4) == cpu)
  339. prom_print(RELOC("okn"));
  340. else {
  341. prom_print(RELOC("failed: "));
  342. prom_print_hex(*(ulong *)0x4);
  343. prom_print(RELOC("n"));
  344. }
  345. }
  346. }
  347. #endif /* CONFIG_SMP */
  349. void __init
  350. bootx_init(unsigned long r4, unsigned long phys)
  351. {
  352. boot_infos_t *bi = (boot_infos_t *) r4;
  353. unsigned long space;
  354. unsigned long ptr, x;
  355. char *model;
  356. unsigned long offset = reloc_offset();
  358. RELOC(boot_infos) = PTRUNRELOC(bi);
  359. if (!BOOT_INFO_IS_V2_COMPATIBLE(bi))
  360. bi->logicalDisplayBase = 0;
  362. #ifdef CONFIG_BOOTX_TEXT
  363. btext_init(bi);
  365. /*
  366.  * Test if boot-info is compatible.  Done only in config
  367.  * CONFIG_BOOTX_TEXT since there is nothing much we can do
  368.  * with an incompatible version, except display a message
  369.  * and eventually hang the processor...
  370.  *
  371.  * I'll try to keep enough of boot-info compatible in the
  372.  * future to always allow display of this message;
  373.  */
  374. if (!BOOT_INFO_IS_COMPATIBLE(bi)) {
  375. btext_drawstring(RELOC(" !!! WARNING - Incompatible version of BootX !!!nnn"));
  376. btext_flushscreen();
  377. }
  378. #endif /* CONFIG_BOOTX_TEXT */
  380. /* New BootX enters kernel with MMU off, i/os are not allowed
  381.    here. This hack will have been done by the boostrap anyway.
  382. */
  383. if (bi->version < 4) {
  384. /*
  385.  * XXX If this is an iMac, turn off the USB controller.
  386.  */
  387. model = (char *) early_get_property
  388. (r4 + bi->deviceTreeOffset, 4, RELOC("model"));
  389. if (model
  390.     && (strcmp(model, RELOC("iMac,1")) == 0
  391. || strcmp(model, RELOC("PowerMac1,1")) == 0)) {
  392. out_le32((unsigned *)0x80880008, 1); /* XXX */
  393. }
  394. }
  396. /* Move klimit to enclose device tree, args, ramdisk, etc... */
  397. if (bi->version < 5) {
  398. space = bi->deviceTreeOffset + bi->deviceTreeSize;
  399. if (bi->ramDisk)
  400. space = bi->ramDisk + bi->ramDiskSize;
  401. } else
  402. space = bi->totalParamsSize;
  403. RELOC(klimit) = PTRUNRELOC((char *) bi + space);
  405. /* New BootX will have flushed all TLBs and enters kernel with
  406.    MMU switched OFF, so this should not be useful anymore.
  407. */
  408. if (bi->version < 4) {
  409. /*
  410.  * Touch each page to make sure the PTEs for them
  411.  * are in the hash table - the aim is to try to avoid
  412.  * getting DSI exceptions while copying the kernel image.
  413.  */
  414. for (ptr = (KERNELBASE + offset) & PAGE_MASK;
  415.      ptr < (unsigned long)bi + space; ptr += PAGE_SIZE)
  416. x = *(volatile unsigned long *)ptr;
  417. }
  419. #ifdef CONFIG_BOOTX_TEXT
  420. /*
  421.  * Note that after we call prepare_disp_BAT, we can't do
  422.  * prom_draw*, flushscreen or clearscreen until we turn the MMU
  423.  * on, since prepare_disp_BAT sets disp_bi->logicalDisplayBase
  424.  * to a virtual address.
  425.  */
  426. btext_prepare_BAT();
  427. #endif
  428. }
  430. #ifdef CONFIG_PPC64BRIDGE
  431. /*
  432.  * Set up a hash table with a set of entries in it to map the
  433.  * first 64MB of RAM.  This is used on 64-bit machines since
  434.  * some of them don't have BATs.
  435.  * We assume the PTE will fit in the primary PTEG.
  436.  */
  438. static inline void make_pte(unsigned long htab, unsigned int hsize,
  439.     unsigned int va, unsigned int pa, int mode)
  440. {
  441. unsigned int *pteg;
  442. unsigned int hash, i, vsid;
  444. vsid = ((va >> 28) * 0x111) << 12;
  445. hash = ((va ^ vsid) >> 5) & 0x7fff80;
  446. pteg = (unsigned int *)(htab + (hash & (hsize - 1)));
  447. for (i = 0; i < 8; ++i, pteg += 4) {
  448. if ((pteg[1] & 1) == 0) {
  449. pteg[1] = vsid | ((va >> 16) & 0xf80) | 1;
  450. pteg[3] = pa | mode;
  451. break;
  452. }
  453. }
  454. }
  456. extern unsigned long _SDR1;
  457. extern PTE *Hash;
  458. extern unsigned long Hash_size;
  460. static void __init
  461. prom_alloc_htab(void)
  462. {
  463. unsigned int hsize;
  464. unsigned long htab;
  465. unsigned int addr;
  466. unsigned long offset = reloc_offset();
  468. /*
  469.  * Because of OF bugs we can't use the "claim" client
  470.  * interface to allocate memory for the hash table.
  471.  * This code is only used on 64-bit PPCs, and the only
  472.  * 64-bit PPCs at the moment are RS/6000s, and their
  473.  * OF is based at 0xc00000 (the 12M point), so we just
  474.  * arbitrarily use the 0x800000 - 0xc00000 region for the
  475.  * hash table.
  476.  *  -- paulus.
  477.  */
  478. #ifdef CONFIG_POWER4
  479. hsize = 4 << 20; /* POWER4 has no BATs */
  480. #else
  481. hsize = 2 << 20;
  482. #endif /* CONFIG_POWER4 */
  483. htab = (8 << 20);
  484. RELOC(Hash) = (void *)(htab + KERNELBASE);
  485. RELOC(Hash_size) = hsize;
  486. RELOC(_SDR1) = htab + __ilog2(hsize) - 18;
  488. /*
  489.  * Put in PTEs for the first 64MB of RAM
  490.  */
  491. cacheable_memzero((void *)htab, hsize);
  492. for (addr = 0; addr < 0x4000000; addr += 0x1000)
  493. make_pte(htab, hsize, addr + KERNELBASE, addr,
  494.  _PAGE_ACCESSED | _PAGE_COHERENT | PP_RWXX);
  495. }
  496. #endif /* CONFIG_PPC64BRIDGE */
  498. static void __init
  499. prom_instantiate_rtas(void)
  500. {
  501. ihandle prom_rtas;
  502. unsigned int i;
  503. struct prom_args prom_args;
  504. unsigned long offset = reloc_offset();
  506. prom_rtas = call_prom(RELOC("finddevice"), 1, 1, RELOC("/rtas"));
  507. if (prom_rtas == (void *) -1)
  508. return;
  510. RELOC(rtas_size) = 0;
  511. call_prom(RELOC("getprop"), 4, 1, prom_rtas,
  512.   RELOC("rtas-size"), &RELOC(rtas_size), sizeof(rtas_size));
  513. prom_print(RELOC("instantiating rtas"));
  514. if (RELOC(rtas_size) == 0) {
  515. RELOC(rtas_data) = 0;
  516. } else {
  517. /*
  518.  * Ask OF for some space for RTAS.
  519.  * Actually OF has bugs so we just arbitrarily
  520.  * use memory at the 6MB point.
  521.  */
  522. RELOC(rtas_data) = 6 << 20;
  523. prom_print(RELOC(" at "));
  524. prom_print_hex(RELOC(rtas_data));
  525. }
  527. prom_rtas = call_prom(RELOC("open"), 1, 1, RELOC("/rtas"));
  528. prom_print(RELOC("..."));
  529. prom_args.service = RELOC("call-method");
  530. prom_args.nargs = 3;
  531. prom_args.nret = 2;
  532. prom_args.args[0] = RELOC("instantiate-rtas");
  533. prom_args.args[1] = prom_rtas;
  534. prom_args.args[2] = (void *) RELOC(rtas_data);
  535. RELOC(prom)(&prom_args);
  536. i = 0;
  537. if (prom_args.args[3] == 0)
  538. i = (unsigned int)prom_args.args[4];
  539. RELOC(rtas_entry) = i;
  540. if ((RELOC(rtas_entry) == -1) || (RELOC(rtas_entry) == 0))
  541. prom_print(RELOC(" failedn"));
  542. else
  543. prom_print(RELOC(" donen"));
  544. }
  546. /*
  547.  * We enter here early on, when the Open Firmware prom is still
  548.  * handling exceptions and the MMU hash table for us.
  549.  */
  550. unsigned long __init
  551. prom_init(int r3, int r4, prom_entry pp)
  552. {
  553. unsigned long mem;
  554. ihandle prom_mmu;
  555. unsigned long offset = reloc_offset();
  556. int l;
  557. char *p, *d;
  558.   unsigned long phys;
  560.   /* Default */
  561.   phys = offset + KERNELBASE;
  563. /* First get a handle for the stdout device */
  564. RELOC(prom) = pp;
  565. RELOC(prom_chosen) = call_prom(RELOC("finddevice"), 1, 1,
  566.        RELOC("/chosen"));
  567. if (RELOC(prom_chosen) == (void *)-1)
  568. prom_exit();
  569. if ((int) call_prom(RELOC("getprop"), 4, 1, RELOC(prom_chosen),
  570.     RELOC("stdout"), &RELOC(prom_stdout),
  571.     sizeof(prom_stdout)) <= 0)
  572. prom_exit();
  574. /* Get the full OF pathname of the stdout device */
  575. mem = (unsigned long) RELOC(klimit) + offset;
  576. p = (char *) mem;
  577. memset(p, 0, 256);
  578. call_prom(RELOC("instance-to-path"), 3, 1, RELOC(prom_stdout), p, 255);
  579. RELOC(of_stdout_device) = PTRUNRELOC(p);
  580. mem += strlen(p) + 1;
  582. /* Get the boot device and translate it to a full OF pathname. */
  583. p = (char *) mem;
  584. l = (int) call_prom(RELOC("getprop"), 4, 1, RELOC(prom_chosen),
  585.     RELOC("bootpath"), p, 1<<20);
  586. if (l > 0) {
  587. p[l] = 0; /* should already be null-terminated */
  588. RELOC(bootpath) = PTRUNRELOC(p);
  589. mem += l + 1;
  590. d = (char *) mem;
  591. *d = 0;
  592. call_prom(RELOC("canon"), 3, 1, p, d, 1<<20);
  593. RELOC(bootdevice) = PTRUNRELOC(d);
  594. mem = ALIGN(mem + strlen(d) + 1);
  595. }
  597. prom_instantiate_rtas();
  599. #ifdef CONFIG_PPC64BRIDGE
  600. /*
  601.  * Find out how much memory we have and allocate a
  602.  * suitably-sized hash table.
  603.  */
  604. prom_alloc_htab();
  605. #endif
  607. mem = check_display(mem);
  609. prom_print(RELOC("copying OF device tree..."));
  610. mem = copy_device_tree(mem, mem + (1<<20));
  611. prom_print(RELOC("donen"));
  613. #ifdef CONFIG_SMP
  614. prom_hold_cpus(mem);
  615. #endif
  617. RELOC(klimit) = (char *) (mem - offset);
  619. /* If we are already running at 0xc0000000, we assume we were loaded by
  620.  * an OF bootloader which did set a BAT for us. This breaks OF translate
  621.  * so we force phys to be 0
  622.  */
  623. if (offset == 0)
  624. phys = 0;
  625. else {
  626.       if ((int) call_prom(RELOC("getprop"), 4, 1, RELOC(prom_chosen),
  627.     RELOC("mmu"), &prom_mmu, sizeof(prom_mmu)) <= 0) {
  628. prom_print(RELOC(" no MMU foundn"));
  629.     } else {
  630. int nargs;
  631. struct prom_args prom_args;
  632. nargs = 4;
  633. prom_args.service = RELOC("call-method");
  634. prom_args.nargs = nargs;
  635. prom_args.nret = 4;
  636. prom_args.args[0] = RELOC("translate");
  637. prom_args.args[1] = prom_mmu;
  638. prom_args.args[2] = (void *)(offset + KERNELBASE);
  639. prom_args.args[3] = (void *)1;
  640. RELOC(prom)(&prom_args);
  642. /* We assume the phys. address size is 3 cells */
  643. if (prom_args.args[nargs] != 0)
  644. prom_print(RELOC(" (translate failed)n"));
  645. else
  646. phys = (unsigned long)prom_args.args[nargs+3];
  647.     }
  648. }
  650. #ifdef CONFIG_BOOTX_TEXT
  651. if (RELOC(prom_disp_node) != 0)
  652. setup_disp_fake_bi(RELOC(prom_disp_node));
  653. #endif
  655. /* Use quiesce call to get OF to shut down any devices it's using */
  656. prom_print(RELOC("Calling quiesce ...n"));
  657. call_prom(RELOC("quiesce"), 0, 0);
  659. #ifdef CONFIG_BOOTX_TEXT
  660. if (RELOC(prom_disp_node) != 0)
  661. btext_prepare_BAT();
  662. #endif
  664. prom_print(RELOC("returning "));
  665. prom_print_hex(phys);
  666. prom_print(RELOC(" from prom_initn"));
  667. RELOC(prom_stdout) = 0;
  669. return phys;
  670. }
  672. void phys_call_rtas(int service, int nargs, int nret, ...)
  673. {
  674. va_list list;
  675. union {
  676. unsigned long words[16];
  677. double align;
  678. } u;
  679. unsigned long offset = reloc_offset();
  680. void (*rtas)(void *, unsigned long);
  681. int i;
  683. u.words[0] = service;
  684. u.words[1] = nargs;
  685. u.words[2] = nret;
  686. va_start(list, nret);
  687. for (i = 0; i < nargs; ++i)
  688. u.words[i+3] = va_arg(list, unsigned long);
  689. va_end(list);
  691. rtas = (void (*)(void *, unsigned long)) RELOC(rtas_entry);
  692. rtas(&u, RELOC(rtas_data));
  693. }
  695. static int __init
  696. prom_set_color(ihandle ih, int i, int r, int g, int b)
  697. {
  698. struct prom_args prom_args;
  699. unsigned long offset = reloc_offset();
  701. prom_args.service = RELOC("call-method");
  702. prom_args.nargs = 6;
  703. prom_args.nret = 1;
  704. prom_args.args[0] = RELOC("color!");
  705. prom_args.args[1] = ih;
  706. prom_args.args[2] = (void *) i;
  707. prom_args.args[3] = (void *) b;
  708. prom_args.args[4] = (void *) g;
  709. prom_args.args[5] = (void *) r;
  710. RELOC(prom)(&prom_args);
  711. return (int) prom_args.args[6];
  712. }
  714. /*
  715.  * If we have a display that we don't know how to drive,
  716.  * we will want to try to execute OF's open method for it
  717.  * later.  However, OF will probably fall over if we do that
  718.  * we've taken over the MMU.
  719.  * So we check whether we will need to open the display,
  720.  * and if so, open it now.
  721.  */
  722. static unsigned long __init
  723. check_display(unsigned long mem)
  724. {
  725. phandle node;
  726. ihandle ih;
  727. int i;
  728. unsigned long offset = reloc_offset();
  729. char type[16], *path;
  730. static unsigned char default_colors[] = {
  731. 0x00, 0x00, 0x00,
  732. 0x00, 0x00, 0xaa,
  733. 0x00, 0xaa, 0x00,
  734. 0x00, 0xaa, 0xaa,
  735. 0xaa, 0x00, 0x00,
  736. 0xaa, 0x00, 0xaa,
  737. 0xaa, 0xaa, 0x00,
  738. 0xaa, 0xaa, 0xaa,
  739. 0x55, 0x55, 0x55,
  740. 0x55, 0x55, 0xff,
  741. 0x55, 0xff, 0x55,
  742. 0x55, 0xff, 0xff,
  743. 0xff, 0x55, 0x55,
  744. 0xff, 0x55, 0xff,
  745. 0xff, 0xff, 0x55,
  746. 0xff, 0xff, 0xff
  747. };
  749. RELOC(prom_disp_node) = 0;
  751. for (node = 0; prom_next_node(&node); ) {
  752. type[0] = 0;
  753. call_prom(RELOC("getprop"), 4, 1, node, RELOC("device_type"),
  754.   type, sizeof(type));
  755. if (strcmp(type, RELOC("display")) != 0)
  756. continue;
  757. /* It seems OF doesn't null-terminate the path :-( */
  758. path = (char *) mem;
  759. memset(path, 0, 256);
  760. if ((int) call_prom(RELOC("package-to-path"), 3, 1,
  761.     node, path, 255) < 0)
  762. continue;
  764. /*
  765.  * If this display is the device that OF is using for stdout,
  766.  * move it to the front of the list.
  767.  */
  768. mem += strlen(path) + 1;
  769. i = RELOC(prom_num_displays)++;
  770. if (RELOC(of_stdout_device) != 0 && i > 0
  771.     && strcmp(PTRRELOC(RELOC(of_stdout_device)), path) == 0) {
  772. for (; i > 0; --i) {
  773. RELOC(prom_display_paths[i])
  774. = RELOC(prom_display_paths[i-1]);
  775. RELOC(prom_display_nodes[i])
  776. = RELOC(prom_display_nodes[i-1]);
  777. }
  778. }
  779. RELOC(prom_display_paths[i]) = PTRUNRELOC(path);
  780. RELOC(prom_display_nodes[i]) = node;
  781. if (i == 0)
  782. RELOC(prom_disp_node) = node;
  783. if (RELOC(prom_num_displays) >= FB_MAX)
  784. break;
  785. }
  787. try_again:
  788. /*
  789.  * Open the first display and set its colormap.
  790.  */
  791. if (RELOC(prom_num_displays) > 0) {
  792. path = PTRRELOC(RELOC(prom_display_paths[0]));
  793. prom_print(RELOC("opening display "));
  794. prom_print(path);
  795. ih = call_prom(RELOC("open"), 1, 1, path);
  796. if (ih == 0 || ih == (ihandle) -1) {
  797. prom_print(RELOC("... failedn"));
  798. for (i=1; i<RELOC(prom_num_displays); i++) {
  799. RELOC(prom_display_paths[i-1]) = RELOC(prom_display_paths[i]);
  800. RELOC(prom_display_nodes[i-1]) = RELOC(prom_display_nodes[i]);
  801. }
  802. if (--RELOC(prom_num_displays) > 0)
  803. RELOC(prom_disp_node) = RELOC(prom_display_nodes[0]);
  804. else
  805. RELOC(prom_disp_node) = NULL;
  806. goto try_again;
  807. } else {
  808. prom_print(RELOC("... okn"));
  809. /*
  810.  * Setup a usable color table when the appropriate
  811.  * method is available.
  812.  * Should update this to use set-colors.
  813.  */
  814. for (i = 0; i < 32; i++)
  815. if (prom_set_color(ih, i, RELOC(default_colors)[i*3],
  816.    RELOC(default_colors)[i*3+1],
  817.    RELOC(default_colors)[i*3+2]) != 0)
  818. break;
  820. #ifdef CONFIG_FB
  821. for (i = 0; i < LINUX_LOGO_COLORS; i++)
  822. if (prom_set_color(ih, i + 32,
  823.    RELOC(linux_logo_red)[i],
  824.    RELOC(linux_logo_green)[i],
  825.    RELOC(linux_logo_blue)[i]) != 0)
  826. break;
  827. #endif /* CONFIG_FB */
  828. }
  829. }
  831. return ALIGN(mem);
  832. }
  834. /* This function will enable the early boot text when doing OF booting. This
  835.  * way, xmon output should work too
  836.  */
  837. #ifdef CONFIG_BOOTX_TEXT
  838. static void __init
  839. setup_disp_fake_bi(ihandle dp)
  840. {
  841. int width = 640, height = 480, depth = 8, pitch;
  842. unsigned address;
  843. unsigned long offset = reloc_offset();
  844. struct pci_reg_property addrs[8];
  845. int i, naddrs;
  846. char name[32];
  847. char *getprop = RELOC("getprop");
  849. prom_print(RELOC("Initializing fake screen: "));
  851. memset(name, 0, sizeof(name));
  852. call_prom(getprop, 4, 1, dp, RELOC("name"), name, sizeof(name));
  853. name[sizeof(name)-1] = 0;
  854. prom_print(name);
  855. prom_print(RELOC("n"));
  856. call_prom(getprop, 4, 1, dp, RELOC("width"), &width, sizeof(width));
  857. call_prom(getprop, 4, 1, dp, RELOC("height"), &height, sizeof(height));
  858. call_prom(getprop, 4, 1, dp, RELOC("depth"), &depth, sizeof(depth));
  859. pitch = width * ((depth + 7) / 8);
  860. call_prom(getprop, 4, 1, dp, RELOC("linebytes"),
  861.   &pitch, sizeof(pitch));
  862. if (pitch == 1)
  863. pitch = 0x1000; /* for strange IBM display */
  864. address = 0;
  865. call_prom(getprop, 4, 1, dp, RELOC("address"),
  866.   &address, sizeof(address));
  867. if (address == 0) {
  868. /* look for an assigned address with a size of >= 1MB */
  869. naddrs = (int) call_prom(getprop, 4, 1, dp,
  870. RELOC("assigned-addresses"),
  871. addrs, sizeof(addrs));
  872. naddrs /= sizeof(struct pci_reg_property);
  873. for (i = 0; i < naddrs; ++i) {
  874. if (addrs[i].size_lo >= (1 << 20)) {
  875. address = addrs[i].addr.a_lo;
  876. /* use the BE aperture if possible */
  877. if (addrs[i].size_lo >= (16 << 20))
  878. address += (8 << 20);
  879. break;
  880. }
  881. }
  882. if (address == 0) {
  883. prom_print(RELOC("Failed to get addressn"));
  884. return;
  885. }
  886. }
  887. /* kludge for valkyrie */
  888. if (strcmp(name, RELOC("valkyrie")) == 0)
  889. address += 0x1000;
  891. btext_setup_display(width, height, depth, pitch, address);
  892. }
  893. #endif
  895. static int __init
  896. prom_next_node(phandle *nodep)
  897. {
  898. phandle node;
  899. unsigned long offset = reloc_offset();
  901. if ((node = *nodep) != 0
  902.     && (*nodep = call_prom(RELOC("child"), 1, 1, node)) != 0)
  903. return 1;
  904. if ((*nodep = call_prom(RELOC("peer"), 1, 1, node)) != 0)
  905. return 1;
  906. for (;;) {
  907. if ((node = call_prom(RELOC("parent"), 1, 1, node)) == 0)
  908. return 0;
  909. if ((*nodep = call_prom(RELOC("peer"), 1, 1, node)) != 0)
  910. return 1;
  911. }
  912. }
  914. /*
  915.  * Make a copy of the device tree from the PROM.
  916.  */
  917. static unsigned long __init
  918. copy_device_tree(unsigned long mem_start, unsigned long mem_end)
  919. {
  920. phandle root;
  921. unsigned long new_start;
  922. struct device_node **allnextp;
  923. unsigned long offset = reloc_offset();
  925. root = call_prom(RELOC("peer"), 1, 1, (phandle)0);
  926. if (root == (phandle)0) {
  927. prom_print(RELOC("couldn't get device tree rootn"));
  928. prom_exit();
  929. }
  930. allnextp = &RELOC(allnodes);
  931. mem_start = ALIGN(mem_start);
  932. new_start = inspect_node(root, 0, mem_start, mem_end, &allnextp);
  933. *allnextp = 0;
  934. return new_start;
  935. }
  937. static unsigned long __init
  938. inspect_node(phandle node, struct device_node *dad,
  939.      unsigned long mem_start, unsigned long mem_end,
  940.      struct device_node ***allnextpp)
  941. {
  942. int l;
  943. phandle child;
  944. struct device_node *np;
  945. struct property *pp, **prev_propp;
  946. char *prev_name, *namep;
  947. unsigned char *valp;
  948. unsigned long offset = reloc_offset();
  950. np = (struct device_node *) mem_start;
  951. mem_start += sizeof(struct device_node);
  952. memset(np, 0, sizeof(*np));
  953. np->node = node;
  954. **allnextpp = PTRUNRELOC(np);
  955. *allnextpp = &np->allnext;
  956. if (dad != 0) {
  957. np->parent = PTRUNRELOC(dad);
  958. /* we temporarily use the `next' field as `last_child'. */
  959. if (dad->next == 0)
  960. dad->child = PTRUNRELOC(np);
  961. else
  962. dad->next->sibling = PTRUNRELOC(np);
  963. dad->next = np;
  964. }
  966. /* get and store all properties */
  967. prev_propp = &np->properties;
  968. prev_name = RELOC("");
  969. for (;;) {
  970. pp = (struct property *) mem_start;
  971. namep = (char *) (pp + 1);
  972. pp->name = PTRUNRELOC(namep);
  973. if ((int) call_prom(RELOC("nextprop"), 3, 1, node, prev_name,
  974.     namep) <= 0)
  975. break;
  976. mem_start = ALIGN((unsigned long)namep + strlen(namep) + 1);
  977. prev_name = namep;
  978. valp = (unsigned char *) mem_start;
  979. pp->value = PTRUNRELOC(valp);
  980. pp->length = (int)
  981. call_prom(RELOC("getprop"), 4, 1, node, namep,
  982.   valp, mem_end - mem_start);
  983. if (pp->length < 0)
  984. continue;
  985. #ifdef MAX_PROPERTY_LENGTH
  986. if (pp->length > MAX_PROPERTY_LENGTH)
  987. continue; /* ignore this property */
  988. #endif
  989. mem_start = ALIGN(mem_start + pp->length);
  990. *prev_propp = PTRUNRELOC(pp);
  991. prev_propp = &pp->next;
  992. }
  993. if (np->node != NULL) {
  994. /* Add a "linux,phandle" property" */
  995. pp = (struct property *) mem_start;
  996. *prev_propp = PTRUNRELOC(pp);
  997. prev_propp = &pp->next;
  998. namep = (char *) (pp + 1);
  999. pp->name = PTRUNRELOC(namep);
  1000. strcpy(namep, RELOC("linux,phandle"));
  1001. mem_start = ALIGN((unsigned long)namep + strlen(namep) + 1);
  1002. pp->value = (unsigned char *) PTRUNRELOC(&np->node);
  1003. pp->length = sizeof(np->node);
  1004. }
  1005. *prev_propp = NULL;
  1007. /* get the node's full name */
  1008. l = (int) call_prom(RELOC("package-to-path"), 3, 1, node,
  1009.     (char *) mem_start, mem_end - mem_start);
  1010. if (l >= 0) {
  1011. np->full_name = PTRUNRELOC((char *) mem_start);
  1012. *(char *)(mem_start + l) = 0;
  1013. mem_start = ALIGN(mem_start + l + 1);
  1014. }
  1016. /* do all our children */
  1017. child = call_prom(RELOC("child"), 1, 1, node);
  1018. while (child != (void *)0) {
  1019. mem_start = inspect_node(child, np, mem_start, mem_end,
  1020.  allnextpp);
  1021. child = call_prom(RELOC("peer"), 1, 1, child);
  1022. }
  1024. return mem_start;
  1025. }
  1027. /*
  1028.  * finish_device_tree is called once things are running normally
  1029.  * (i.e. with text and data mapped to the address they were linked at).
  1030.  * It traverses the device tree and fills in the name, type,
  1031.  * {n_}addrs and {n_}intrs fields of each node.
  1032.  */
  1033. void __init
  1034. finish_device_tree(void)
  1035. {
  1036. unsigned long mem = (unsigned long) klimit;
  1037. struct device_node *np;
  1039. /* All newworld pmac machines and CHRPs now use the interrupt tree */
  1040. for (np = allnodes; np != NULL; np = np->allnext) {
  1041. if (get_property(np, "interrupt-parent", 0)) {
  1042. use_of_interrupt_tree = 1;
  1043. break;
  1044. }
  1045. }
  1046. if (_machine == _MACH_Pmac && use_of_interrupt_tree)
  1047. pmac_newworld = 1;
  1049. #ifdef CONFIG_BOOTX_TEXT
  1050. if (boot_infos && pmac_newworld) {
  1051. prom_print("WARNING ! BootX/miBoot booting is not supported on this machinen");
  1052. prom_print("          You should use an Open Firmware bootloadern");
  1053. }
  1054. #endif /* CONFIG_BOOTX_TEXT */
  1056. if (use_of_interrupt_tree) {
  1057. /*
  1058.  * We want to find out here how many interrupt-controller
  1059.  * nodes there are, and if we are booted from BootX,
  1060.  * we need a pointer to the first (and hopefully only)
  1061.  * such node.  But we can't use find_devices here since
  1062.  * np->name has not been set yet.  -- paulus
  1063.  */
  1064. int n = 0;
  1065. char *name, *ic;
  1066. int iclen;
  1068. for (np = allnodes; np != NULL; np = np->allnext) {
  1069. ic = get_property(np, "interrupt-controller", &iclen);
  1070. name = get_property(np, "name", NULL);
  1071. /* checking iclen makes sure we don't get a false
  1072.    match on /chosen.interrupt_controller */
  1073. if ((name != NULL
  1074.      && strcmp(name, "interrupt-controller") == 0)
  1075.     || (ic != NULL && iclen == 0)) {
  1076. if (n == 0)
  1077. dflt_interrupt_controller = np;
  1078. ++n;
  1079. }
  1080. }
  1081. num_interrupt_controllers = n;
  1082. }
  1084. mem = finish_node(allnodes, mem, NULL, 1, 1);
  1085. dev_tree_size = mem - (unsigned long) allnodes;
  1086. klimit = (char *) mem;
  1087. }
  1089. /*
  1090.  * early_get_property is used to access the device tree image prepared
  1091.  * by BootX very early on, before the pointers in it have been relocated.
  1092.  */
  1093. static void * __init
  1094. early_get_property(unsigned long base, unsigned long node, char *prop)
  1095. {
  1096. struct device_node *np = (struct device_node *)(base + node);
  1097. struct property *pp;
  1099. for (pp = np->properties; pp != 0; pp = pp->next) {
  1100. pp = (struct property *) (base + (unsigned long)pp);
  1101. if (strcmp((char *)((unsigned long)pp->name + base),
  1102.    prop) == 0) {
  1103. return (void *)((unsigned long)pp->value + base);
  1104. }
  1105. }
  1106. return 0;
  1107. }
  1109. static unsigned long __init
  1110. finish_node(struct device_node *np, unsigned long mem_start,
  1111.     interpret_func *ifunc, int naddrc, int nsizec)
  1112. {
  1113. struct device_node *child;
  1114. int *ip;
  1116. np->name = get_property(np, "name", 0);
  1117. np->type = get_property(np, "device_type", 0);
  1119. if (!np->name)
  1120. np->name = "<NULL>";
  1121. if (!np->type)
  1122. np->type = "<NULL>";
  1124. /* get the device addresses and interrupts */
  1125. if (ifunc != NULL)
  1126. mem_start = ifunc(np, mem_start, naddrc, nsizec);
  1128. if (use_of_interrupt_tree)
  1129. mem_start = finish_node_interrupts(np, mem_start);
  1131. /* Look for #address-cells and #size-cells properties. */
  1132. ip = (int *) get_property(np, "#address-cells", 0);
  1133. if (ip != NULL)
  1134. naddrc = *ip;
  1135. ip = (int *) get_property(np, "#size-cells", 0);
  1136. if (ip != NULL)
  1137. nsizec = *ip;
  1139. /* 
  1140.  * The F50 sets the name to 'display' and 'compatible' to what we
  1141.  * expect for the name. -- Cort
  1142.  *
  1143.  * But sometimes you get a 'display' name for non-OF cards, and thus
  1144.  * no compatible property.  And very rarely we won't have a name
  1145.  * property either. -- Tom
  1146.  */
  1147. if (!strcmp(np->name, "display"))
  1148. np->name = get_property(np, "compatible", 0);
  1149. if (!np->name)
  1150. np->name = get_property(np, "name", 0);
  1152. if (np->parent == NULL)
  1153. ifunc = interpret_root_props;
  1154. else if (np->type == 0)
  1155. ifunc = NULL;
  1156. else if (!strcmp(np->type, "pci") || !strcmp(np->type, "vci"))
  1157. ifunc = interpret_pci_props;
  1158. else if (!strcmp(np->type, "dbdma"))
  1159. ifunc = interpret_dbdma_props;
  1160. else if (!strcmp(np->type, "mac-io")
  1161.  || ifunc == interpret_macio_props)
  1162. ifunc = interpret_macio_props;
  1163. else if (!strcmp(np->type, "isa"))
  1164. ifunc = interpret_isa_props;
  1165. else if (!strcmp(np->name, "uni-n"))
  1166. ifunc = interpret_root_props;
  1167. else if (!((ifunc == interpret_dbdma_props
  1168.     || ifunc == interpret_macio_props)
  1169.    && (!strcmp(np->type, "escc")
  1170.        || !strcmp(np->type, "media-bay"))))
  1171. ifunc = NULL;
  1173. /* if we were booted from BootX, convert the full name */
  1174. if (boot_infos
  1175.     && strncmp(np->full_name, "Devices:device-tree", 19) == 0) {
  1176. if (np->full_name[19] == 0) {
  1177. strcpy(np->full_name, "/");
  1178. } else if (np->full_name[19] == ':') {
  1179. char *p = np->full_name + 19;
  1180. np->full_name = p;
  1181. for (; *p; ++p)
  1182. if (*p == ':')
  1183. *p = '/';
  1184. }
  1185. }
  1187. for (child = np->child; child != NULL; child = child->sibling)
  1188. mem_start = finish_node(child, mem_start, ifunc,
  1189. naddrc, nsizec);
  1191. return mem_start;
  1192. }
  1194. /*
  1195.  * Find the interrupt parent of a node.
  1196.  */
  1197. static struct device_node * __init
  1198. intr_parent(struct device_node *p)
  1199. {
  1200. phandle *parp;
  1202. parp = (phandle *) get_property(p, "interrupt-parent", NULL);
  1203. if (parp == NULL)
  1204. return p->parent;
  1205. p = find_phandle(*parp);
  1206. if (p != NULL)
  1207. return p;
  1208. /*
  1209.  * On a powermac booted with BootX, we don't get to know the
  1210.  * phandles for any nodes, so find_phandle will return NULL.
  1211.  * Fortunately these machines only have one interrupt controller
  1212.  * so there isn't in fact any ambiguity.  -- paulus
  1213.  */
  1214. if (num_interrupt_controllers == 1)
  1215. p = dflt_interrupt_controller;
  1216. return p;
  1217. }
  1219. /*
  1220.  * Find out the size of each entry of the interrupts property
  1221.  * for a node.
  1222.  */
  1223. static int __init
  1224. prom_n_intr_cells(struct device_node *np)
  1225. {
  1226. struct device_node *p;
  1227. unsigned int *icp;
  1229. for (p = np; (p = intr_parent(p)) != NULL; ) {
  1230. icp = (unsigned int *)
  1231. get_property(p, "#interrupt-cells", NULL);
  1232. if (icp != NULL)
  1233. return *icp;
  1234. if (get_property(p, "interrupt-controller", NULL) != NULL
  1235.     || get_property(p, "interrupt-map", NULL) != NULL) {
  1236. printk("oops, node %s doesn't have #interrupt-cellsn",
  1237.        p->full_name);
  1238. return 1;
  1239. }
  1240. }
  1241. printk("prom_n_intr_cells failed for %sn", np->full_name);
  1242. return 1;
  1243. }
  1245. /*
  1246.  * Map an interrupt from a device up to the platform interrupt
  1247.  * descriptor.
  1248.  */
  1249. static int __init
  1250. map_interrupt(unsigned int **irq, struct device_node **ictrler,
  1251.       struct device_node *np, unsigned int *ints, int nintrc)
  1252. {
  1253. struct device_node *p, *ipar;
  1254. unsigned int *imap, *imask, *ip;
  1255. int i, imaplen, match;
  1256. int newintrc, newaddrc;
  1257. unsigned int *reg;
  1258. int naddrc;
  1260. reg = (unsigned int *) get_property(np, "reg", NULL);
  1261. naddrc = prom_n_addr_cells(np);
  1262. p = intr_parent(np);
  1263. while (p != NULL) {
  1264. if (get_property(p, "interrupt-controller", NULL) != NULL)
  1265. /* this node is an interrupt controller, stop here */
  1266. break;
  1267. imap = (unsigned int *)
  1268. get_property(p, "interrupt-map", &imaplen);
  1269. if (imap == NULL) {
  1270. p = intr_parent(p);
  1271. continue;
  1272. }
  1273. imask = (unsigned int *)
  1274. get_property(p, "interrupt-map-mask", NULL);
  1275. if (imask == NULL) {
  1276. printk("oops, %s has interrupt-map but no maskn",
  1277.        p->full_name);
  1278. return 0;
  1279. }
  1280. imaplen /= sizeof(unsigned int);
  1281. match = 0;
  1282. ipar = NULL;
  1283. while (imaplen > 0 && !match) {
  1284. /* check the child-interrupt field */
  1285. match = 1;
  1286. for (i = 0; i < naddrc && match; ++i)
  1287. match = ((reg[i] ^ imap[i]) & imask[i]) == 0;
  1288. for (; i < naddrc + nintrc && match; ++i)
  1289. match = ((ints[i-naddrc] ^ imap[i]) & imask[i]) == 0;
  1290. imap += naddrc + nintrc;
  1291. imaplen -= naddrc + nintrc;
  1292. /* grab the interrupt parent */
  1293. ipar = find_phandle((phandle) *imap++);
  1294. --imaplen;
  1295. if (ipar == NULL && num_interrupt_controllers == 1)
  1296. /* cope with BootX not giving us phandles */
  1297. ipar = dflt_interrupt_controller;
  1298. if (ipar == NULL) {
  1299. printk("oops, no int parent %x in map of %sn",
  1300.        imap[-1], p->full_name);
  1301. return 0;
  1302. }
  1303. /* find the parent's # addr and intr cells */
  1304. ip = (unsigned int *)
  1305. get_property(ipar, "#interrupt-cells", NULL);
  1306. if (ip == NULL) {
  1307. printk("oops, no #interrupt-cells on %sn",
  1308.        ipar->full_name);
  1309. return 0;
  1310. }
  1311. newintrc = *ip;
  1312. ip = (unsigned int *)
  1313. get_property(ipar, "#address-cells", NULL);
  1314. newaddrc = (ip == NULL)? 0: *ip;
  1315. imap += newaddrc + newintrc;
  1316. imaplen -= newaddrc + newintrc;
  1317. }
  1318. if (imaplen < 0) {
  1319. printk("oops, error decoding int-map on %s, len=%dn",
  1320.        p->full_name, imaplen);
  1321. return 0;
  1322. }
  1323. if (!match) {
  1324. printk("oops, no match in %s int-map for %sn",
  1325.        p->full_name, np->full_name);
  1326. return 0;
  1327. }
  1328. p = ipar;
  1329. naddrc = newaddrc;
  1330. nintrc = newintrc;
  1331. ints = imap - nintrc;
  1332. reg = ints - naddrc;
  1333. }
  1334. if (p == NULL)
  1335. printk("hmmm, int tree for %s doesn't have ctrlern",
  1336.        np->full_name);
  1337. *irq = ints;
  1338. *ictrler = p;
  1339. return nintrc;
  1340. }
  1342. /*
  1343.  * New version of finish_node_interrupts.
  1344.  */
  1345. static unsigned long __init
  1346. finish_node_interrupts(struct device_node *np, unsigned long mem_start)
  1347. {
  1348. unsigned int *ints;
  1349. int intlen, intrcells;
  1350. int i, j, n, offset;
  1351. unsigned int *irq;
  1352. struct device_node *ic;
  1354. ints = (unsigned int *) get_property(np, "interrupts", &intlen);
  1355. if (ints == NULL)
  1356. return mem_start;
  1357. intrcells = prom_n_intr_cells(np);
  1358. intlen /= intrcells * sizeof(unsigned int);
  1359. np->n_intrs = intlen;
  1360. np->intrs = (struct interrupt_info *) mem_start;
  1361. mem_start += intlen * sizeof(struct interrupt_info);
  1363. for (i = 0; i < intlen; ++i) {
  1364. np->intrs[i].line = 0;
  1365. np->intrs[i].sense = 1;
  1366. n = map_interrupt(&irq, &ic, np, ints, intrcells);
  1367. if (n <= 0)
  1368. continue;
  1369. offset = 0;
  1370. /*
  1371.  * On a CHRP we have an 8259 which is subordinate to
  1372.  * the openpic in the interrupt tree, but we want the
  1373.  * openpic's interrupt numbers offsetted, not the 8259's.
  1374.  * So we apply the offset if the controller is at the
  1375.  * root of the interrupt tree, i.e. has no interrupt-parent.
  1376.  * This doesn't cope with the general case of multiple
  1377.  * cascaded interrupt controllers, but then neither will
  1378.  * irq.c at the moment either.  -- paulus
  1379.  */
  1380. if (num_interrupt_controllers > 1 && ic != NULL
  1381.     && get_property(ic, "interrupt-parent", NULL) == NULL)
  1382. offset = 16;
  1383. np->intrs[i].line = irq[0] + offset;
  1384. if (n > 1)
  1385. np->intrs[i].sense = irq[1];
  1386. if (n > 2) {
  1387. printk("hmmm, got %d intr cells for %s:", n,
  1388.        np->full_name);
  1389. for (j = 0; j < n; ++j)
  1390. printk(" %d", irq[j]);
  1391. printk("n");
  1392. }
  1393. ints += intrcells;
  1394. }
  1396. return mem_start;
  1397. }
  1399. /*
  1400.  * When BootX makes a copy of the device tree from the MacOS
  1401.  * Name Registry, it is in the format we use but all of the pointers
  1402.  * are offsets from the start of the tree.
  1403.  * This procedure updates the pointers.
  1404.  */
  1405. void __init
  1406. relocate_nodes(void)
  1407. {
  1408. unsigned long base;
  1409. struct device_node *np;
  1410. struct property *pp;
  1412. #define ADDBASE(x) (x = (x)? ((typeof (x))((unsigned long)(x) + base)): 0)
  1414. base = (unsigned long) boot_infos + boot_infos->deviceTreeOffset;
  1415. allnodes = (struct device_node *)(base + 4);
  1416. for (np = allnodes; np != 0; np = np->allnext) {
  1417. ADDBASE(np->full_name);
  1418. ADDBASE(np->properties);
  1419. ADDBASE(np->parent);
  1420. ADDBASE(np->child);
  1421. ADDBASE(np->sibling);
  1422. ADDBASE(np->allnext);
  1423. for (pp = np->properties; pp != 0; pp = pp->next) {
  1424. ADDBASE(pp->name);
  1425. ADDBASE(pp->value);
  1426. ADDBASE(pp->next);
  1427. }
  1428. }
  1429. }
  1431. int
  1432. prom_n_addr_cells(struct device_node* np)
  1433. {
  1434. int* ip;
  1435. do {
  1436. if (np->parent)
  1437. np = np->parent;
  1438. ip = (int *) get_property(np, "#address-cells", 0);
  1439. if (ip != NULL)
  1440. return *ip;
  1441. } while (np->parent);
  1442. /* No #address-cells property for the root node, default to 1 */
  1443. return 1;
  1444. }
  1446. int
  1447. prom_n_size_cells(struct device_node* np)
  1448. {
  1449. int* ip;
  1450. do {
  1451. if (np->parent)
  1452. np = np->parent;
  1453. ip = (int *) get_property(np, "#size-cells", 0);
  1454. if (ip != NULL)
  1455. return *ip;
  1456. } while (np->parent);
  1457. /* No #size-cells property for the root node, default to 1 */
  1458. return 1;
  1459. }
  1461. static unsigned long __init
  1462. interpret_pci_props(struct device_node *np, unsigned long mem_start,
  1463.     int naddrc, int nsizec)
  1464. {
  1465. struct address_range *adr;
  1466. struct pci_reg_property *pci_addrs;
  1467. int i, l, *ip;
  1469. pci_addrs = (struct pci_reg_property *)
  1470. get_property(np, "assigned-addresses", &l);
  1471. if (pci_addrs != 0 && l >= sizeof(struct pci_reg_property)) {
  1472. i = 0;
  1473. adr = (struct address_range *) mem_start;
  1474. while ((l -= sizeof(struct pci_reg_property)) >= 0) {
  1475. /* XXX assumes PCI addresses mapped 1-1 to physical */
  1476. adr[i].space = pci_addrs[i].addr.a_hi;
  1477. adr[i].address = pci_addrs[i].addr.a_lo;
  1478. adr[i].size = pci_addrs[i].size_lo;
  1479. ++i;
  1480. }
  1481. np->addrs = adr;
  1482. np->n_addrs = i;
  1483. mem_start += i * sizeof(struct address_range);
  1484. }
  1486. if (use_of_interrupt_tree)
  1487. return mem_start;
  1489. ip = (int *) get_property(np, "AAPL,interrupts", &l);
  1490. if (ip == 0 && np->parent)
  1491. ip = (int *) get_property(np->parent, "AAPL,interrupts", &l);
  1492. if (ip == 0)
  1493. ip = (int *) get_property(np, "interrupts", &l);
  1494. if (ip != 0) {
  1495. np->intrs = (struct interrupt_info *) mem_start;
  1496. np->n_intrs = l / sizeof(int);
  1497. mem_start += np->n_intrs * sizeof(struct interrupt_info);
  1498. for (i = 0; i < np->n_intrs; ++i) {
  1499. np->intrs[i].line = *ip++;
  1500. np->intrs[i].sense = 1;
  1501. }
  1502. }
  1504. return mem_start;
  1505. }
  1507. static unsigned long __init
  1508. interpret_dbdma_props(struct device_node *np, unsigned long mem_start,
  1509.       int naddrc, int nsizec)
  1510. {
  1511. struct reg_property *rp;
  1512. struct address_range *adr;
  1513. unsigned long base_address;
  1514. int i, l, *ip;
  1515. struct device_node *db;
  1517. base_address = 0;
  1518. for (db = np->parent; db != NULL; db = db->parent) {
  1519. if (!strcmp(db->type, "dbdma") && db->n_addrs != 0) {
  1520. base_address = db->addrs[0].address;
  1521. break;
  1522. }
  1523. }
  1525. rp = (struct reg_property *) get_property(np, "reg", &l);
  1526. if (rp != 0 && l >= sizeof(struct reg_property)) {
  1527. i = 0;
  1528. adr = (struct address_range *) mem_start;
  1529. while ((l -= sizeof(struct reg_property)) >= 0) {
  1530. adr[i].space = 2;
  1531. adr[i].address = rp[i].address + base_address;
  1532. adr[i].size = rp[i].size;
  1533. ++i;
  1534. }
  1535. np->addrs = adr;
  1536. np->n_addrs = i;
  1537. mem_start += i * sizeof(struct address_range);
  1538. }
  1540. if (use_of_interrupt_tree)
  1541. return mem_start;
  1543. ip = (int *) get_property(np, "AAPL,interrupts", &l);
  1544. if (ip == 0)
  1545. ip = (int *) get_property(np, "interrupts", &l);
  1546. if (ip != 0) {
  1547. np->intrs = (struct interrupt_info *) mem_start;
  1548. np->n_intrs = l / sizeof(int);
  1549. mem_start += np->n_intrs * sizeof(struct interrupt_info);
  1550. for (i = 0; i < np->n_intrs; ++i) {
  1551. np->intrs[i].line = *ip++;
  1552. np->intrs[i].sense = 1;
  1553. }
  1554. }
  1556. return mem_start;
  1557. }
  1559. static unsigned long __init
  1560. interpret_macio_props(struct device_node *np, unsigned long mem_start,
  1561.       int naddrc, int nsizec)
  1562. {
  1563. struct reg_property *rp;
  1564. struct address_range *adr;
  1565. unsigned long base_address;
  1566. int i, l, *ip;
  1567. struct device_node *db;
  1569. base_address = 0;
  1570. for (db = np->parent; db != NULL; db = db->parent) {
  1571. if (!strcmp(db->type, "mac-io") && db->n_addrs != 0) {
  1572. base_address = db->addrs[0].address;
  1573. break;
  1574. }
  1575. }
  1577. rp = (struct reg_property *) get_property(np, "reg", &l);
  1578. if (rp != 0 && l >= sizeof(struct reg_property)) {
  1579. i = 0;
  1580. adr = (struct address_range *) mem_start;
  1581. while ((l -= sizeof(struct reg_property)) >= 0) {
  1582. adr[i].space = 2;
  1583. adr[i].address = rp[i].address + base_address;
  1584. adr[i].size = rp[i].size;
  1585. ++i;
  1586. }
  1587. np->addrs = adr;
  1588. np->n_addrs = i;
  1589. mem_start += i * sizeof(struct address_range);
  1590. }
  1592. if (use_of_interrupt_tree)
  1593. return mem_start;
  1595. ip = (int *) get_property(np, "interrupts", &l);
  1596. if (ip == 0)
  1597. ip = (int *) get_property(np, "AAPL,interrupts", &l);
  1598. if (ip != 0) {
  1599. np->intrs = (struct interrupt_info *) mem_start;
  1600. np->n_intrs = l / sizeof(int);
  1601. for (i = 0; i < np->n_intrs; ++i) {
  1602. np->intrs[i].line = *ip++;
  1603. np->intrs[i].sense = 1;
  1604. }
  1605. mem_start += np->n_intrs * sizeof(struct interrupt_info);
  1606. }
  1608. return mem_start;
  1609. }
  1611. static unsigned long __init
  1612. interpret_isa_props(struct device_node *np, unsigned long mem_start,
  1613.     int naddrc, int nsizec)
  1614. {
  1615. struct isa_reg_property *rp;
  1616. struct address_range *adr;
  1617. int i, l, *ip;
  1619. rp = (struct isa_reg_property *) get_property(np, "reg", &l);
  1620. if (rp != 0 && l >= sizeof(struct isa_reg_property)) {
  1621. i = 0;
  1622. adr = (struct address_range *) mem_start;
  1623. while ((l -= sizeof(struct reg_property)) >= 0) {
  1624. adr[i].space = rp[i].space;
  1625. adr[i].address = rp[i].address
  1626. + (adr[i].space? 0: _ISA_MEM_BASE);
  1627. adr[i].size = rp[i].size;
  1628. ++i;
  1629. }
  1630. np->addrs = adr;
  1631. np->n_addrs = i;
  1632. mem_start += i * sizeof(struct address_range);
  1633. }
  1635. if (use_of_interrupt_tree)
  1636. return mem_start;
  1638. ip = (int *) get_property(np, "interrupts", &l);
  1639. if (ip != 0) {
  1640. np->intrs = (struct interrupt_info *) mem_start;
  1641. np->n_intrs = l / (2 * sizeof(int));
  1642. mem_start += np->n_intrs * sizeof(struct interrupt_info);
  1643. for (i = 0; i < np->n_intrs; ++i) {
  1644. np->intrs[i].line = *ip++;
  1645. np->intrs[i].sense = *ip++;
  1646. }
  1647. }
  1649. return mem_start;
  1650. }
  1652. static unsigned long __init
  1653. interpret_root_props(struct device_node *np, unsigned long mem_start,
  1654.      int naddrc, int nsizec)
  1655. {
  1656. struct address_range *adr;
  1657. int i, l, *ip;
  1658. unsigned int *rp;
  1659. int rpsize = (naddrc + nsizec) * sizeof(unsigned int);
  1661. rp = (unsigned int *) get_property(np, "reg", &l);
  1662. if (rp != 0 && l >= rpsize) {
  1663. i = 0;
  1664. adr = (struct address_range *) mem_start;
  1665. while ((l -= rpsize) >= 0) {
  1666. adr[i].space = (naddrc >= 2? rp[naddrc-2]: 2);
  1667. adr[i].address = rp[naddrc - 1];
  1668. adr[i].size = rp[naddrc + nsizec - 1];
  1669. ++i;
  1670. rp += naddrc + nsizec;
  1671. }
  1672. np->addrs = adr;
  1673. np->n_addrs = i;
  1674. mem_start += i * sizeof(struct address_range);
  1675. }
  1677. if (use_of_interrupt_tree)
  1678. return mem_start;
  1680. ip = (int *) get_property(np, "AAPL,interrupts", &l);
  1681. if (ip == 0)
  1682. ip = (int *) get_property(np, "interrupts", &l);
  1683. if (ip != 0) {
  1684. np->intrs = (struct interrupt_info *) mem_start;
  1685. np->n_intrs = l / sizeof(int);
  1686. mem_start += np->n_intrs * sizeof(struct interrupt_info);
  1687. for (i = 0; i < np->n_intrs; ++i) {
  1688. np->intrs[i].line = *ip++;
  1689. np->intrs[i].sense = 1;
  1690. }
  1691. }
  1693. return mem_start;
  1694. }
  1696. /*
  1697.  * Work out the sense (active-low level / active-high edge)
  1698.  * of each interrupt from the device tree.
  1699.  */
  1700. void __init
  1701. prom_get_irq_senses(unsigned char *senses, int off, int max)
  1702. {
  1703. struct device_node *np;
  1704. int i, j;
  1706. /* default to level-triggered */
  1707. memset(senses, 1, max - off);
  1708. if (!use_of_interrupt_tree)
  1709. return;
  1711. for (np = allnodes; np != 0; np = np->allnext) {
  1712. for (j = 0; j < np->n_intrs; j++) {
  1713. i = np->intrs[j].line;
  1714. if (i >= off && i < max)
  1715. senses[i-off] = np->intrs[j].sense;
  1716. }
  1717. }
  1718. }
  1720. /*
  1721.  * Construct and return a list of the device_nodes with a given name.
  1722.  */
  1723. struct device_node *
  1724. find_devices(const char *name)
  1725. {
  1726. struct device_node *head, **prevp, *np;
  1728. prevp = &head;
  1729. for (np = allnodes; np != 0; np = np->allnext) {
  1730. if (np->name != 0 && strcasecmp(np->name, name) == 0) {
  1731. *prevp = np;
  1732. prevp = &np->next;
  1733. }
  1734. }
  1735. *prevp = 0;
  1736. return head;
  1737. }
  1739. /*
  1740.  * Construct and return a list of the device_nodes with a given type.
  1741.  */
  1742. struct device_node *
  1743. find_type_devices(const char *type)
  1744. {
  1745. struct device_node *head, **prevp, *np;
  1747. prevp = &head;
  1748. for (np = allnodes; np != 0; np = np->allnext) {
  1749. if (np->type != 0 && strcasecmp(np->type, type) == 0) {
  1750. *prevp = np;
  1751. prevp = &np->next;
  1752. }
  1753. }
  1754. *prevp = 0;
  1755. return head;
  1756. }
  1758. /*
  1759.  * Returns all nodes linked together
  1760.  */
  1761. struct device_node * __openfirmware
  1762. find_all_nodes(void)
  1763. {
  1764. struct device_node *head, **prevp, *np;
  1766. prevp = &head;
  1767. for (np = allnodes; np != 0; np = np->allnext) {
  1768. *prevp = np;
  1769. prevp = &np->next;
  1770. }
  1771. *prevp = 0;
  1772. return head;
  1773. }
  1775. /* Checks if the given "compat" string matches one of the strings in
  1776.  * the device's "compatible" property
  1777.  */
  1778. int
  1779. device_is_compatible(struct device_node *device, const char *compat)
  1780. {
  1781. const char* cp;
  1782. int cplen, l;
  1784. cp = (char *) get_property(device, "compatible", &cplen);
  1785. if (cp == NULL)
  1786. return 0;
  1787. while (cplen > 0) {
  1788. if (strncasecmp(cp, compat, strlen(compat)) == 0)
  1789. return 1;
  1790. l = strlen(cp) + 1;
  1791. cp += l;
  1792. cplen -= l;
  1793. }
  1795. return 0;
  1796. }
  1799. /*
  1800.  * Indicates whether the root node has a given value in its
  1801.  * compatible property.
  1802.  */
  1803. int
  1804. machine_is_compatible(const char *compat)
  1805. {
  1806. struct device_node *root;
  1808. root = find_path_device("/");
  1809. if (root == 0)
  1810. return 0;
  1811. return device_is_compatible(root, compat);
  1812. }
  1814. /*
  1815.  * Construct and return a list of the device_nodes with a given type
  1816.  * and compatible property.
  1817.  */
  1818. struct device_node *
  1819. find_compatible_devices(const char *type, const char *compat)
  1820. {
  1821. struct device_node *head, **prevp, *np;
  1823. prevp = &head;
  1824. for (np = allnodes; np != 0; np = np->allnext) {
  1825. if (type != NULL
  1826.     && !(np->type != 0 && strcasecmp(np->type, type) == 0))
  1827. continue;
  1828. if (device_is_compatible(np, compat)) {
  1829. *prevp = np;
  1830. prevp = &np->next;
  1831. }
  1832. }
  1833. *prevp = 0;
  1834. return head;
  1835. }
  1837. /*
  1838.  * Find the device_node with a given full_name.
  1839.  */
  1840. struct device_node *
  1841. find_path_device(const char *path)
  1842. {
  1843. struct device_node *np;
  1845. for (np = allnodes; np != 0; np = np->allnext)
  1846. if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0)
  1847. return np;
  1848. return NULL;
  1849. }
  1851. /*
  1852.  * Find the device_node with a given phandle.
  1853.  */
  1854. static struct device_node * __init
  1855. find_phandle(phandle ph)
  1856. {
  1857. struct device_node *np;
  1859. for (np = allnodes; np != 0; np = np->allnext)
  1860. if (np->node == ph)
  1861. return np;
  1862. return NULL;
  1863. }
  1865. /*
  1866.  * Find a property with a given name for a given node
  1867.  * and return the value.
  1868.  */
  1869. unsigned char *
  1870. get_property(struct device_node *np, const char *name, int *lenp)
  1871. {
  1872. struct property *pp;
  1874. for (pp = np->properties; pp != 0; pp = pp->next)
  1875. if (pp->name != NULL && strcmp(pp->name, name) == 0) {
  1876. if (lenp != 0)
  1877. *lenp = pp->length;
  1878. return pp->value;
  1879. }
  1880. return 0;
  1881. }
  1883. /*
  1884.  * Add a property to a node
  1885.  */
  1886. void __openfirmware
  1887. prom_add_property(struct device_node* np, struct property* prop)
  1888. {
  1889. struct property **next = &np->properties;
  1891. prop->next = NULL;
  1892. while (*next)
  1893. next = &(*next)->next;
  1894. *next = prop;
  1895. }
  1897. /* I quickly hacked that one, check against spec ! */
  1898. static inline unsigned long __openfirmware
  1899. bus_space_to_resource_flags(unsigned int bus_space)
  1900. {
  1901. u8 space = (bus_space >> 24) & 0xf;
  1902. if (space == 0)
  1903. space = 0x02;
  1904. if (space == 0x02)
  1905. return IORESOURCE_MEM;
  1906. else if (space == 0x01)
  1907. return IORESOURCE_IO;
  1908. else {
  1909. printk(KERN_WARNING "prom.c: bus_space_to_resource_flags(), space: %xn",
  1910.      bus_space);
  1911. return 0;
  1912. }
  1913. }
  1915. static struct resource* __openfirmware
  1916. find_parent_pci_resource(struct pci_dev* pdev, struct address_range *range)
  1917. {
  1918. unsigned long mask;
  1919. int i;
  1921. /* Check this one */ 
  1922. mask = bus_space_to_resource_flags(range->space);
  1923. for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
  1924. if ((pdev->resource[i].flags & mask) == mask &&
  1925. pdev->resource[i].start <= range->address &&
  1926. pdev->resource[i].end > range->address) {
  1927. if ((range->address + range->size - 1) > pdev->resource[i].end) {
  1928. /* Add better message */
  1929. printk(KERN_WARNING "PCI/OF resource overlap !n");
  1930. return NULL;
  1931. }
  1932. break;
  1933. }
  1934. }
  1935. if (i == DEVICE_COUNT_RESOURCE)
  1936. return NULL;
  1937. return &pdev->resource[i];
  1938. }
  1940. /*
  1941.  * Request an OF device resource. Currently handles child of PCI devices,
  1942.  * or other nodes attached to the root node. Ultimately, put some
  1943.  * link to resources in the OF node.
  1944.  * WARNING: out_resource->name should be initialized before calling this
  1945.  * function.
  1946.  */
  1947. struct resource* __openfirmware
  1948. request_OF_resource(struct device_node* node, int index, const char* name_postfix)
  1949. {
  1950. struct pci_dev* pcidev;
  1951. u8 pci_bus, pci_devfn;
  1952. unsigned long iomask;
  1953. struct device_node* nd;
  1954. struct resource* parent;
  1955. struct resource *res = NULL;
  1956. int nlen, plen;
  1958. if (index >= node->n_addrs)
  1959. goto fail;
  1961. /* Sanity check on bus space */
  1962. iomask = bus_space_to_resource_flags(node->addrs[index].space);
  1963. if (iomask & IORESOURCE_MEM)
  1964. parent = &iomem_resource;
  1965. else if (iomask & IORESOURCE_IO)
  1966. parent = &ioport_resource;
  1967. else
  1968. goto fail;
  1970. /* Find a PCI parent if any */
  1971. nd = node;
  1972. pcidev = NULL;
  1973. while(nd) {
  1974. if (!pci_device_from_OF_node(nd, &pci_bus, &pci_devfn))
  1975. pcidev = pci_find_slot(pci_bus, pci_devfn);
  1976. if (pcidev) break;
  1977. nd = nd->parent;
  1978. }
  1979. if (pcidev)
  1980. parent = find_parent_pci_resource(pcidev, &node->addrs[index]);
  1981. if (!parent) {
  1982. printk(KERN_WARNING "request_OF_resource(%s), parent not foundn",
  1983. node->name);
  1984. goto fail;
  1985. }
  1987. res = __request_region(parent, node->addrs[index].address, node->addrs[index].size, NULL);
  1988. if (!res)
  1989. goto fail;
  1990. nlen = strlen(node->name);
  1991. plen = name_postfix ? strlen(name_postfix) : 0;
  1992. res->name = (const char *)kmalloc(nlen+plen+1, GFP_KERNEL);
  1993. if (res->name) {
  1994. strcpy((char *)res->name, node->name);
  1995. if (plen)
  1996. strcpy((char *)res->name+nlen, name_postfix);
  1997. }
  1998. return res;
  1999. fail:
  2000. return NULL;
  2001. }
  2003. int __openfirmware
  2004. release_OF_resource(struct device_node* node, int index)
  2005. {
  2006. struct pci_dev* pcidev;
  2007. u8 pci_bus, pci_devfn;
  2008. unsigned long iomask;
  2009. struct device_node* nd;
  2010. struct resource* parent;
  2011. struct resource *res = NULL;
  2013. if (index >= node->n_addrs)
  2014. return -EINVAL;
  2016. /* Sanity check on bus space */
  2017. iomask = bus_space_to_resource_flags(node->addrs[index].space);
  2018. if (iomask & IORESOURCE_MEM)
  2019. parent = &iomem_resource;
  2020. else if (iomask & IORESOURCE_IO)
  2021. parent = &ioport_resource;
  2022. else
  2023. return -EINVAL;
  2025. /* Find a PCI parent if any */
  2026. nd = node;
  2027. pcidev = NULL;
  2028. while(nd) {
  2029. if (!pci_device_from_OF_node(nd, &pci_bus, &pci_devfn))
  2030. pcidev = pci_find_slot(pci_bus, pci_devfn);
  2031. if (pcidev) break;
  2032. nd = nd->parent;
  2033. }
  2034. if (pcidev)
  2035. parent = find_parent_pci_resource(pcidev, &node->addrs[index]);
  2036. if (!parent) {
  2037. printk(KERN_WARNING "request_OF_resource(%s), parent not foundn",
  2038. node->name);
  2039. return -ENODEV;
  2040. }
  2042. /* Find us in the parent */
  2043. res = parent->child;
  2044. while (res) {
  2045. if (res->start == node->addrs[index].address &&
  2046.     res->end == (res->start + node->addrs[index].size - 1))
  2047.      break;
  2048. res = res->sibling;
  2049. }
  2050. if (!res)
  2051. return -ENODEV;
  2053. if (res->name) {
  2054. kfree(res->name);
  2055. res->name = NULL;
  2056. }
  2057. release_resource(res);
  2058. kfree(res);
  2060. return 0;
  2061. }
  2063. #if 0
  2064. void __openfirmware
  2065. print_properties(struct device_node *np)
  2066. {
  2067. struct property *pp;
  2068. char *cp;
  2069. int i, n;
  2071. for (pp = np->properties; pp != 0; pp = pp->next) {
  2072. printk(KERN_INFO "%s", pp->name);
  2073. for (i = strlen(pp->name); i < 16; ++i)
  2074. printk(" ");
  2075. cp = (char *) pp->value;
  2076. for (i = pp->length; i > 0; --i, ++cp)
  2077. if ((i > 1 && (*cp < 0x20 || *cp > 0x7e))
  2078.     || (i == 1 && *cp != 0))
  2079. break;
  2080. if (i == 0 && pp->length > 1) {
  2081. /* looks like a string */
  2082. printk(" %sn", (char *) pp->value);
  2083. } else {
  2084. /* dump it in hex */
  2085. n = pp->length;
  2086. if (n > 64)
  2087. n = 64;
  2088. if (pp->length % 4 == 0) {
  2089. unsigned int *p = (unsigned int *) pp->value;
  2091. n /= 4;
  2092. for (i = 0; i < n; ++i) {
  2093. if (i != 0 && (i % 4) == 0)
  2094. printk("n                ");
  2095. printk(" %08x", *p++);
  2096. }
  2097. } else {
  2098. unsigned char *bp = pp->value;
  2100. for (i = 0; i < n; ++i) {
  2101. if (i != 0 && (i % 16) == 0)
  2102. printk("n                ");
  2103. printk(" %02x", *bp++);
  2104. }
  2105. }
  2106. printk("n");
  2107. if (pp->length > 64)
  2108. printk("                 ... (length = %d)n",
  2109.        pp->length);
  2110. }
  2111. }
  2112. }
  2113. #endif
  2115. static spinlock_t rtas_lock = SPIN_LOCK_UNLOCKED;
  2117. /* this can be called after setup -- Cort */
  2118. int __openfirmware
  2119. call_rtas(const char *service, int nargs, int nret,
  2120.   unsigned long *outputs, ...)
  2121. {
  2122. va_list list;
  2123. int i;
  2124. unsigned long s;
  2125. struct device_node *rtas;
  2126. int *tokp;
  2127. union {
  2128. unsigned long words[16];
  2129. double align;
  2130. } u;
  2132. rtas = find_devices("rtas");
  2133. if (rtas == NULL)
  2134. return -1;
  2135. tokp = (int *) get_property(rtas, service, NULL);
  2136. if (tokp == NULL) {
  2137. printk(KERN_ERR "No RTAS service called %sn", service);
  2138. return -1;
  2139. }
  2140. u.words[0] = *tokp;
  2141. u.words[1] = nargs;
  2142. u.words[2] = nret;
  2143. va_start(list, outputs);
  2144. for (i = 0; i < nargs; ++i)
  2145. u.words[i+3] = va_arg(list, unsigned long);
  2146. va_end(list);
  2148. /* Shouldn't we enable kernel FP here ? enter_rtas will play
  2149.  * with MSR_FE0|MSR_FE1|MSR_FP so I assume rtas might use
  2150.  * floating points. If that's the case, then we need to make
  2151.  * sure any lazy FP context is backed up
  2152.  * --BenH
  2153.  */
  2154. spin_lock_irqsave(&rtas_lock, s);
  2155. enter_rtas((void *)__pa(&u));
  2156. spin_unlock_irqrestore(&rtas_lock, s);
  2158. if (nret > 1 && outputs != NULL)
  2159. for (i = 0; i < nret-1; ++i)
  2160. outputs[i] = u.words[i+nargs+4];
  2161. return u.words[nargs+3];
  2162. }
  2164. void __init
  2165. abort()
  2166. {
  2167. #ifdef CONFIG_XMON
  2168. xmon(NULL);
  2169. #endif
  2170. for (;;)
  2171. prom_exit();
  2172. }