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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
prom.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：29k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

prom.c：源码内容
  1. /*
  2.  * BK Id: %F% %I% %G% %U% %#%
  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 <linux/config.h>
  15. #include <linux/kernel.h>
  16. #include <linux/string.h>
  17. #include <linux/init.h>
  18. #include <linux/version.h>
  19. #include <linux/threads.h>
  20. #include <linux/spinlock.h>
  21. #include <linux/pci.h>
  22. #include <linux/slab.h>
  24. #include <asm/sections.h>
  25. #include <asm/prom.h>
  26. #include <asm/page.h>
  27. #include <asm/processor.h>
  28. #include <asm/irq.h>
  29. #include <asm/open_pic.h>
  30. #include <asm/system.h>
  31. #include <asm/btext.h>
  32. #include <asm/pci-bridge.h>
  34. struct pci_address {
  35. unsigned a_hi;
  36. unsigned a_mid;
  37. unsigned a_lo;
  38. };
  40. struct pci_reg_property {
  41. struct pci_address addr;
  42. unsigned size_hi;
  43. unsigned size_lo;
  44. };
  46. struct isa_reg_property {
  47. unsigned space;
  48. unsigned address;
  49. unsigned size;
  50. };
  52. typedef unsigned long interpret_func(struct device_node *, unsigned long,
  53.      int, int);
  54. static interpret_func interpret_pci_props;
  55. static interpret_func interpret_dbdma_props;
  56. static interpret_func interpret_isa_props;
  57. static interpret_func interpret_macio_props;
  58. static interpret_func interpret_root_props;
  60. extern char *klimit;
  62. /* Set for a newworld or CHRP machine */
  63. int use_of_interrupt_tree;
  64. struct device_node *dflt_interrupt_controller;
  65. int num_interrupt_controllers;
  67. int pmac_newworld;
  69. extern unsigned int rtas_entry;  /* physical pointer */
  71. extern struct device_node *allnodes;
  73. static unsigned long finish_node(struct device_node *, unsigned long,
  74.  interpret_func *, int, int);
  75. static unsigned long finish_node_interrupts(struct device_node *, unsigned long);
  77. extern void enter_rtas(void *);
  78. void phys_call_rtas(int, int, int, ...);
  80. extern char cmd_line[512]; /* XXX */
  81. extern boot_infos_t *boot_infos;
  82. unsigned long dev_tree_size;
  84. void __openfirmware
  85. phys_call_rtas(int service, int nargs, int nret, ...)
  86. {
  87. va_list list;
  88. union {
  89. unsigned long words[16];
  90. double align;
  91. } u;
  92. void (*rtas)(void *, unsigned long);
  93. int i;
  95. u.words[0] = service;
  96. u.words[1] = nargs;
  97. u.words[2] = nret;
  98. va_start(list, nret);
  99. for (i = 0; i < nargs; ++i)
  100. u.words[i+3] = va_arg(list, unsigned long);
  101. va_end(list);
  103. rtas = (void (*)(void *, unsigned long)) rtas_entry;
  104. rtas(&u, rtas_data);
  105. }
  107. /*
  108.  * finish_device_tree is called once things are running normally
  109.  * (i.e. with text and data mapped to the address they were linked at).
  110.  * It traverses the device tree and fills in the name, type,
  111.  * {n_}addrs and {n_}intrs fields of each node.
  112.  */
  113. void __init
  114. finish_device_tree(void)
  115. {
  116. unsigned long mem = (unsigned long) klimit;
  117. struct device_node *np;
  119. /* All newworld pmac machines and CHRPs now use the interrupt tree */
  120. for (np = allnodes; np != NULL; np = np->allnext) {
  121. if (get_property(np, "interrupt-parent", 0)) {
  122. use_of_interrupt_tree = 1;
  123. break;
  124. }
  125. }
  126. if (_machine == _MACH_Pmac && use_of_interrupt_tree)
  127. pmac_newworld = 1;
  129. #ifdef CONFIG_BOOTX_TEXT
  130. if (boot_infos && pmac_newworld) {
  131. prom_print("WARNING ! BootX/miBoot booting is not supported on this machinen");
  132. prom_print("          You should use an Open Firmware bootloadern");
  133. }
  134. #endif /* CONFIG_BOOTX_TEXT */
  136. if (use_of_interrupt_tree) {
  137. /*
  138.  * We want to find out here how many interrupt-controller
  139.  * nodes there are, and if we are booted from BootX,
  140.  * we need a pointer to the first (and hopefully only)
  141.  * such node.  But we can't use find_devices here since
  142.  * np->name has not been set yet.  -- paulus
  143.  */
  144. int n = 0;
  145. char *name, *ic;
  146. int iclen;
  148. for (np = allnodes; np != NULL; np = np->allnext) {
  149. ic = get_property(np, "interrupt-controller", &iclen);
  150. name = get_property(np, "name", NULL);
  151. /* checking iclen makes sure we don't get a false
  152.    match on /chosen.interrupt_controller */
  153. if ((name != NULL
  154.      && strcmp(name, "interrupt-controller") == 0)
  155.     || (ic != NULL && iclen == 0 && strcmp(name, "AppleKiwi"))) {
  156. if (n == 0)
  157. dflt_interrupt_controller = np;
  158. ++n;
  159. }
  160. }
  161. num_interrupt_controllers = n;
  162. }
  164. mem = finish_node(allnodes, mem, NULL, 1, 1);
  165. dev_tree_size = mem - (unsigned long) allnodes;
  166. klimit = (char *) mem;
  167. }
  169. static unsigned long __init
  170. finish_node(struct device_node *np, unsigned long mem_start,
  171.     interpret_func *ifunc, int naddrc, int nsizec)
  172. {
  173. struct device_node *child;
  174. int *ip;
  176. np->name = get_property(np, "name", 0);
  177. np->type = get_property(np, "device_type", 0);
  179. if (!np->name)
  180. np->name = "<NULL>";
  181. if (!np->type)
  182. np->type = "<NULL>";
  184. /* get the device addresses and interrupts */
  185. if (ifunc != NULL)
  186. mem_start = ifunc(np, mem_start, naddrc, nsizec);
  188. if (use_of_interrupt_tree)
  189. mem_start = finish_node_interrupts(np, mem_start);
  191. /* Look for #address-cells and #size-cells properties. */
  192. ip = (int *) get_property(np, "#address-cells", 0);
  193. if (ip != NULL)
  194. naddrc = *ip;
  195. ip = (int *) get_property(np, "#size-cells", 0);
  196. if (ip != NULL)
  197. nsizec = *ip;
  199. if (np->parent == NULL)
  200. ifunc = interpret_root_props;
  201. else if (np->type == 0)
  202. ifunc = NULL;
  203. else if (!strcmp(np->type, "pci") || !strcmp(np->type, "vci"))
  204. ifunc = interpret_pci_props;
  205. else if (!strcmp(np->type, "dbdma"))
  206. ifunc = interpret_dbdma_props;
  207. else if (!strcmp(np->type, "mac-io")
  208.  || ifunc == interpret_macio_props)
  209. ifunc = interpret_macio_props;
  210. else if (!strcmp(np->type, "isa"))
  211. ifunc = interpret_isa_props;
  212. else if (!strcmp(np->name, "uni-n"))
  213. ifunc = interpret_root_props;
  214. else if (!((ifunc == interpret_dbdma_props
  215.     || ifunc == interpret_macio_props)
  216.    && (!strcmp(np->type, "escc")
  217.        || !strcmp(np->type, "media-bay"))))
  218. ifunc = NULL;
  220. /* if we were booted from BootX, convert the full name */
  221. if (boot_infos
  222.     && strncmp(np->full_name, "Devices:device-tree", 19) == 0) {
  223. if (np->full_name[19] == 0) {
  224. strcpy(np->full_name, "/");
  225. } else if (np->full_name[19] == ':') {
  226. char *p = np->full_name + 19;
  227. np->full_name = p;
  228. for (; *p; ++p)
  229. if (*p == ':')
  230. *p = '/';
  231. }
  232. }
  234. for (child = np->child; child != NULL; child = child->sibling)
  235. mem_start = finish_node(child, mem_start, ifunc,
  236. naddrc, nsizec);
  238. return mem_start;
  239. }
  241. /*
  242.  * Find the interrupt parent of a node.
  243.  */
  244. static struct device_node * __init
  245. intr_parent(struct device_node *p)
  246. {
  247. phandle *parp;
  249. parp = (phandle *) get_property(p, "interrupt-parent", NULL);
  250. if (parp == NULL)
  251. return p->parent;
  252. p = find_phandle(*parp);
  253. if (p != NULL)
  254. return p;
  255. /*
  256.  * On a powermac booted with BootX, we don't get to know the
  257.  * phandles for any nodes, so find_phandle will return NULL.
  258.  * Fortunately these machines only have one interrupt controller
  259.  * so there isn't in fact any ambiguity.  -- paulus
  260.  */
  261. if (num_interrupt_controllers == 1)
  262. p = dflt_interrupt_controller;
  263. return p;
  264. }
  266. /*
  267.  * Find out the size of each entry of the interrupts property
  268.  * for a node.
  269.  */
  270. static int __init
  271. prom_n_intr_cells(struct device_node *np)
  272. {
  273. struct device_node *p;
  274. unsigned int *icp;
  276. for (p = np; (p = intr_parent(p)) != NULL; ) {
  277. icp = (unsigned int *)
  278. get_property(p, "#interrupt-cells", NULL);
  279. if (icp != NULL)
  280. return *icp;
  281. if (get_property(p, "interrupt-controller", NULL) != NULL
  282.     || get_property(p, "interrupt-map", NULL) != NULL) {
  283. printk("oops, node %s doesn't have #interrupt-cellsn",
  284.        p->full_name);
  285. return 1;
  286. }
  287. }
  288. printk("prom_n_intr_cells failed for %sn", np->full_name);
  289. return 1;
  290. }
  292. /*
  293.  * Map an interrupt from a device up to the platform interrupt
  294.  * descriptor.
  295.  */
  296. static int __init
  297. map_interrupt(unsigned int **irq, struct device_node **ictrler,
  298.       struct device_node *np, unsigned int *ints, int nintrc)
  299. {
  300. struct device_node *p, *ipar;
  301. unsigned int *imap, *imask, *ip;
  302. int i, imaplen, match;
  303. int newintrc, newaddrc;
  304. unsigned int *reg;
  305. int naddrc;
  307. reg = (unsigned int *) get_property(np, "reg", NULL);
  308. naddrc = prom_n_addr_cells(np);
  309. p = intr_parent(np);
  310. while (p != NULL) {
  311. if (get_property(p, "interrupt-controller", NULL) != NULL)
  312. /* this node is an interrupt controller, stop here */
  313. break;
  314. imap = (unsigned int *)
  315. get_property(p, "interrupt-map", &imaplen);
  316. if (imap == NULL) {
  317. p = intr_parent(p);
  318. continue;
  319. }
  320. imask = (unsigned int *)
  321. get_property(p, "interrupt-map-mask", NULL);
  322. if (imask == NULL) {
  323. printk("oops, %s has interrupt-map but no maskn",
  324.        p->full_name);
  325. return 0;
  326. }
  327. imaplen /= sizeof(unsigned int);
  328. match = 0;
  329. ipar = NULL;
  330. while (imaplen > 0 && !match) {
  331. /* check the child-interrupt field */
  332. match = 1;
  333. for (i = 0; i < naddrc && match; ++i)
  334. match = ((reg[i] ^ imap[i]) & imask[i]) == 0;
  335. for (; i < naddrc + nintrc && match; ++i)
  336. match = ((ints[i-naddrc] ^ imap[i]) & imask[i]) == 0;
  337. imap += naddrc + nintrc;
  338. imaplen -= naddrc + nintrc;
  339. /* grab the interrupt parent */
  340. ipar = find_phandle((phandle) *imap++);
  341. --imaplen;
  342. if (ipar == NULL && num_interrupt_controllers == 1)
  343. /* cope with BootX not giving us phandles */
  344. ipar = dflt_interrupt_controller;
  345. if (ipar == NULL) {
  346. printk("oops, no int parent %x in map of %sn",
  347.        imap[-1], p->full_name);
  348. return 0;
  349. }
  350. /* find the parent's # addr and intr cells */
  351. ip = (unsigned int *)
  352. get_property(ipar, "#interrupt-cells", NULL);
  353. if (ip == NULL) {
  354. printk("oops, no #interrupt-cells on %sn",
  355.        ipar->full_name);
  356. return 0;
  357. }
  358. newintrc = *ip;
  359. ip = (unsigned int *)
  360. get_property(ipar, "#address-cells", NULL);
  361. newaddrc = (ip == NULL)? 0: *ip;
  362. imap += newaddrc + newintrc;
  363. imaplen -= newaddrc + newintrc;
  364. }
  365. if (imaplen < 0) {
  366. printk("oops, error decoding int-map on %s, len=%dn",
  367.        p->full_name, imaplen);
  368. return 0;
  369. }
  370. if (!match) {
  371. printk("oops, no match in %s int-map for %sn",
  372.        p->full_name, np->full_name);
  373. return 0;
  374. }
  375. p = ipar;
  376. naddrc = newaddrc;
  377. nintrc = newintrc;
  378. ints = imap - nintrc;
  379. reg = ints - naddrc;
  380. }
  381. if (p == NULL)
  382. printk("hmmm, int tree for %s doesn't have ctrlern",
  383.        np->full_name);
  384. *irq = ints;
  385. *ictrler = p;
  386. return nintrc;
  387. }
  389. /*
  390.  * New version of finish_node_interrupts.
  391.  */
  392. static unsigned long __init
  393. finish_node_interrupts(struct device_node *np, unsigned long mem_start)
  394. {
  395. unsigned int *ints;
  396. int intlen, intrcells;
  397. int i, j, n, offset;
  398. unsigned int *irq;
  399. struct device_node *ic;
  401. ints = (unsigned int *) get_property(np, "interrupts", &intlen);
  402. if (ints == NULL)
  403. return mem_start;
  404. intrcells = prom_n_intr_cells(np);
  405. intlen /= intrcells * sizeof(unsigned int);
  406. np->n_intrs = intlen;
  407. np->intrs = (struct interrupt_info *) mem_start;
  408. mem_start += intlen * sizeof(struct interrupt_info);
  410. for (i = 0; i < intlen; ++i) {
  411. np->intrs[i].line = 0;
  412. np->intrs[i].sense = 1;
  413. n = map_interrupt(&irq, &ic, np, ints, intrcells);
  414. if (n <= 0)
  415. continue;
  416. offset = 0;
  417. /*
  418.  * On a CHRP we have an 8259 which is subordinate to
  419.  * the openpic in the interrupt tree, but we want the
  420.  * openpic's interrupt numbers offsetted, not the 8259's.
  421.  * So we apply the offset if the controller is at the
  422.  * root of the interrupt tree, i.e. has no interrupt-parent.
  423.  * This doesn't cope with the general case of multiple
  424.  * cascaded interrupt controllers, but then neither will
  425.  * irq.c at the moment either.  -- paulus
  426.  */
  427. if (num_interrupt_controllers > 1 && ic != NULL
  428.     && get_property(ic, "interrupt-parent", NULL) == NULL)
  429. offset = 16;
  430. np->intrs[i].line = irq[0] + offset;
  431. if (n > 1)
  432. np->intrs[i].sense = irq[1];
  433. if (n > 2) {
  434. printk("hmmm, got %d intr cells for %s:", n,
  435.        np->full_name);
  436. for (j = 0; j < n; ++j)
  437. printk(" %d", irq[j]);
  438. printk("n");
  439. }
  440. ints += intrcells;
  441. }
  443. return mem_start;
  444. }
  446. /*
  447.  * When BootX makes a copy of the device tree from the MacOS
  448.  * Name Registry, it is in the format we use but all of the pointers
  449.  * are offsets from the start of the tree.
  450.  * This procedure updates the pointers.
  451.  */
  452. void __init
  453. relocate_nodes(void)
  454. {
  455. unsigned long base;
  456. struct device_node *np;
  457. struct property *pp;
  459. #define ADDBASE(x) (x = (x)? ((typeof (x))((unsigned long)(x) + base)): 0)
  461. base = (unsigned long) boot_infos + boot_infos->deviceTreeOffset;
  462. allnodes = (struct device_node *)(base + 4);
  463. for (np = allnodes; np != 0; np = np->allnext) {
  464. ADDBASE(np->full_name);
  465. ADDBASE(np->properties);
  466. ADDBASE(np->parent);
  467. ADDBASE(np->child);
  468. ADDBASE(np->sibling);
  469. ADDBASE(np->allnext);
  470. for (pp = np->properties; pp != 0; pp = pp->next) {
  471. ADDBASE(pp->name);
  472. ADDBASE(pp->value);
  473. ADDBASE(pp->next);
  474. }
  475. }
  476. }
  478. int
  479. prom_n_addr_cells(struct device_node* np)
  480. {
  481. int* ip;
  482. do {
  483. if (np->parent)
  484. np = np->parent;
  485. ip = (int *) get_property(np, "#address-cells", 0);
  486. if (ip != NULL)
  487. return *ip;
  488. } while (np->parent);
  489. /* No #address-cells property for the root node, default to 1 */
  490. return 1;
  491. }
  493. int
  494. prom_n_size_cells(struct device_node* np)
  495. {
  496. int* ip;
  497. do {
  498. if (np->parent)
  499. np = np->parent;
  500. ip = (int *) get_property(np, "#size-cells", 0);
  501. if (ip != NULL)
  502. return *ip;
  503. } while (np->parent);
  504. /* No #size-cells property for the root node, default to 1 */
  505. return 1;
  506. }
  508. static unsigned long __init
  509. interpret_pci_props(struct device_node *np, unsigned long mem_start,
  510.     int naddrc, int nsizec)
  511. {
  512. struct address_range *adr;
  513. struct pci_reg_property *pci_addrs;
  514. int i, l, *ip;
  516. pci_addrs = (struct pci_reg_property *)
  517. get_property(np, "assigned-addresses", &l);
  518. if (pci_addrs != 0 && l >= sizeof(struct pci_reg_property)) {
  519. i = 0;
  520. adr = (struct address_range *) mem_start;
  521. while ((l -= sizeof(struct pci_reg_property)) >= 0) {
  522. /* XXX assumes PCI addresses mapped 1-1 to physical */
  523. adr[i].space = pci_addrs[i].addr.a_hi;
  524. adr[i].address = pci_addrs[i].addr.a_lo;
  525. adr[i].size = pci_addrs[i].size_lo;
  526. ++i;
  527. }
  528. np->addrs = adr;
  529. np->n_addrs = i;
  530. mem_start += i * sizeof(struct address_range);
  531. }
  533. if (use_of_interrupt_tree)
  534. return mem_start;
  536. ip = (int *) get_property(np, "AAPL,interrupts", &l);
  537. if (ip == 0 && np->parent)
  538. ip = (int *) get_property(np->parent, "AAPL,interrupts", &l);
  539. if (ip == 0)
  540. ip = (int *) get_property(np, "interrupts", &l);
  541. if (ip != 0) {
  542. np->intrs = (struct interrupt_info *) mem_start;
  543. np->n_intrs = l / sizeof(int);
  544. mem_start += np->n_intrs * sizeof(struct interrupt_info);
  545. for (i = 0; i < np->n_intrs; ++i) {
  546. np->intrs[i].line = *ip++;
  547. np->intrs[i].sense = 1;
  548. }
  549. }
  551. return mem_start;
  552. }
  554. static unsigned long __init
  555. interpret_dbdma_props(struct device_node *np, unsigned long mem_start,
  556.       int naddrc, int nsizec)
  557. {
  558. struct reg_property *rp;
  559. struct address_range *adr;
  560. unsigned long base_address;
  561. int i, l, *ip;
  562. struct device_node *db;
  564. base_address = 0;
  565. for (db = np->parent; db != NULL; db = db->parent) {
  566. if (!strcmp(db->type, "dbdma") && db->n_addrs != 0) {
  567. base_address = db->addrs[0].address;
  568. break;
  569. }
  570. }
  572. rp = (struct reg_property *) get_property(np, "reg", &l);
  573. if (rp != 0 && l >= sizeof(struct reg_property)) {
  574. i = 0;
  575. adr = (struct address_range *) mem_start;
  576. while ((l -= sizeof(struct reg_property)) >= 0) {
  577. adr[i].space = 2;
  578. adr[i].address = rp[i].address + base_address;
  579. adr[i].size = rp[i].size;
  580. ++i;
  581. }
  582. np->addrs = adr;
  583. np->n_addrs = i;
  584. mem_start += i * sizeof(struct address_range);
  585. }
  587. if (use_of_interrupt_tree)
  588. return mem_start;
  590. ip = (int *) get_property(np, "AAPL,interrupts", &l);
  591. if (ip == 0)
  592. ip = (int *) get_property(np, "interrupts", &l);
  593. if (ip != 0) {
  594. np->intrs = (struct interrupt_info *) mem_start;
  595. np->n_intrs = l / sizeof(int);
  596. mem_start += np->n_intrs * sizeof(struct interrupt_info);
  597. for (i = 0; i < np->n_intrs; ++i) {
  598. np->intrs[i].line = *ip++;
  599. np->intrs[i].sense = 1;
  600. }
  601. }
  603. return mem_start;
  604. }
  606. static unsigned long __init
  607. interpret_macio_props(struct device_node *np, unsigned long mem_start,
  608.       int naddrc, int nsizec)
  609. {
  610. struct reg_property *rp;
  611. struct address_range *adr;
  612. unsigned long base_address;
  613. int i, l, *ip;
  614. struct device_node *db;
  616. base_address = 0;
  617. for (db = np->parent; db != NULL; db = db->parent) {
  618. if (!strcmp(db->type, "mac-io") && db->n_addrs != 0) {
  619. base_address = db->addrs[0].address;
  620. break;
  621. }
  622. }
  624. rp = (struct reg_property *) get_property(np, "reg", &l);
  625. if (rp != 0 && l >= sizeof(struct reg_property)) {
  626. i = 0;
  627. adr = (struct address_range *) mem_start;
  628. while ((l -= sizeof(struct reg_property)) >= 0) {
  629. adr[i].space = 2;
  630. adr[i].address = rp[i].address + base_address;
  631. adr[i].size = rp[i].size;
  632. ++i;
  633. }
  634. np->addrs = adr;
  635. np->n_addrs = i;
  636. mem_start += i * sizeof(struct address_range);
  637. }
  639. if (use_of_interrupt_tree)
  640. return mem_start;
  642. ip = (int *) get_property(np, "interrupts", &l);
  643. if (ip == 0)
  644. ip = (int *) get_property(np, "AAPL,interrupts", &l);
  645. if (ip != 0) {
  646. np->intrs = (struct interrupt_info *) mem_start;
  647. np->n_intrs = l / sizeof(int);
  648. for (i = 0; i < np->n_intrs; ++i) {
  649. np->intrs[i].line = *ip++;
  650. np->intrs[i].sense = 1;
  651. }
  652. mem_start += np->n_intrs * sizeof(struct interrupt_info);
  653. }
  655. return mem_start;
  656. }
  658. static unsigned long __init
  659. interpret_isa_props(struct device_node *np, unsigned long mem_start,
  660.     int naddrc, int nsizec)
  661. {
  662. struct isa_reg_property *rp;
  663. struct address_range *adr;
  664. int i, l, *ip;
  666. rp = (struct isa_reg_property *) get_property(np, "reg", &l);
  667. if (rp != 0 && l >= sizeof(struct isa_reg_property)) {
  668. i = 0;
  669. adr = (struct address_range *) mem_start;
  670. while ((l -= sizeof(struct reg_property)) >= 0) {
  671. adr[i].space = rp[i].space;
  672. adr[i].address = rp[i].address
  673. + (adr[i].space? 0: _ISA_MEM_BASE);
  674. adr[i].size = rp[i].size;
  675. ++i;
  676. }
  677. np->addrs = adr;
  678. np->n_addrs = i;
  679. mem_start += i * sizeof(struct address_range);
  680. }
  682. if (use_of_interrupt_tree)
  683. return mem_start;
  685. ip = (int *) get_property(np, "interrupts", &l);
  686. if (ip != 0) {
  687. np->intrs = (struct interrupt_info *) mem_start;
  688. np->n_intrs = l / (2 * sizeof(int));
  689. mem_start += np->n_intrs * sizeof(struct interrupt_info);
  690. for (i = 0; i < np->n_intrs; ++i) {
  691. np->intrs[i].line = *ip++;
  692. np->intrs[i].sense = *ip++;
  693. }
  694. }
  696. return mem_start;
  697. }
  699. static unsigned long __init
  700. interpret_root_props(struct device_node *np, unsigned long mem_start,
  701.      int naddrc, int nsizec)
  702. {
  703. struct address_range *adr;
  704. int i, l, *ip;
  705. unsigned int *rp;
  706. int rpsize = (naddrc + nsizec) * sizeof(unsigned int);
  708. rp = (unsigned int *) get_property(np, "reg", &l);
  709. if (rp != 0 && l >= rpsize) {
  710. i = 0;
  711. adr = (struct address_range *) mem_start;
  712. while ((l -= rpsize) >= 0) {
  713. adr[i].space = (naddrc >= 2? rp[naddrc-2]: 2);
  714. adr[i].address = rp[naddrc - 1];
  715. adr[i].size = rp[naddrc + nsizec - 1];
  716. ++i;
  717. rp += naddrc + nsizec;
  718. }
  719. np->addrs = adr;
  720. np->n_addrs = i;
  721. mem_start += i * sizeof(struct address_range);
  722. }
  724. if (use_of_interrupt_tree)
  725. return mem_start;
  727. ip = (int *) get_property(np, "AAPL,interrupts", &l);
  728. if (ip == 0)
  729. ip = (int *) get_property(np, "interrupts", &l);
  730. if (ip != 0) {
  731. np->intrs = (struct interrupt_info *) mem_start;
  732. np->n_intrs = l / sizeof(int);
  733. mem_start += np->n_intrs * sizeof(struct interrupt_info);
  734. for (i = 0; i < np->n_intrs; ++i) {
  735. np->intrs[i].line = *ip++;
  736. np->intrs[i].sense = 1;
  737. }
  738. }
  740. return mem_start;
  741. }
  743. /*
  744.  * Work out the sense (active-low level / active-high edge)
  745.  * of each interrupt from the device tree.
  746.  */
  747. void __init
  748. prom_get_irq_senses(unsigned char *senses, int off, int max)
  749. {
  750. struct device_node *np;
  751. int i, j;
  753. /* default to level-triggered */
  754. memset(senses, 1, max - off);
  755. if (!use_of_interrupt_tree)
  756. return;
  758. for (np = allnodes; np != 0; np = np->allnext) {
  759. for (j = 0; j < np->n_intrs; j++) {
  760. i = np->intrs[j].line;
  761. if (i >= off && i < max)
  762. senses[i-off] = np->intrs[j].sense;
  763. }
  764. }
  765. }
  767. /*
  768.  * Construct and return a list of the device_nodes with a given name.
  769.  */
  770. struct device_node *
  771. find_devices(const char *name)
  772. {
  773. struct device_node *head, **prevp, *np;
  775. prevp = &head;
  776. for (np = allnodes; np != 0; np = np->allnext) {
  777. if (np->name != 0 && strcasecmp(np->name, name) == 0) {
  778. *prevp = np;
  779. prevp = &np->next;
  780. }
  781. }
  782. *prevp = 0;
  783. return head;
  784. }
  786. /*
  787.  * Construct and return a list of the device_nodes with a given type.
  788.  */
  789. struct device_node *
  790. find_type_devices(const char *type)
  791. {
  792. struct device_node *head, **prevp, *np;
  794. prevp = &head;
  795. for (np = allnodes; np != 0; np = np->allnext) {
  796. if (np->type != 0 && strcasecmp(np->type, type) == 0) {
  797. *prevp = np;
  798. prevp = &np->next;
  799. }
  800. }
  801. *prevp = 0;
  802. return head;
  803. }
  805. /*
  806.  * Returns all nodes linked together
  807.  */
  808. struct device_node * __openfirmware
  809. find_all_nodes(void)
  810. {
  811. struct device_node *head, **prevp, *np;
  813. prevp = &head;
  814. for (np = allnodes; np != 0; np = np->allnext) {
  815. *prevp = np;
  816. prevp = &np->next;
  817. }
  818. *prevp = 0;
  819. return head;
  820. }
  822. /* Checks if the given "compat" string matches one of the strings in
  823.  * the device's "compatible" property
  824.  */
  825. int
  826. device_is_compatible(struct device_node *device, const char *compat)
  827. {
  828. const char* cp;
  829. int cplen, l;
  831. cp = (char *) get_property(device, "compatible", &cplen);
  832. if (cp == NULL)
  833. return 0;
  834. while (cplen > 0) {
  835. if (strncasecmp(cp, compat, strlen(compat)) == 0)
  836. return 1;
  837. l = strlen(cp) + 1;
  838. cp += l;
  839. cplen -= l;
  840. }
  842. return 0;
  843. }
  846. /*
  847.  * Indicates whether the root node has a given value in its
  848.  * compatible property.
  849.  */
  850. int
  851. machine_is_compatible(const char *compat)
  852. {
  853. struct device_node *root;
  855. root = find_path_device("/");
  856. if (root == 0)
  857. return 0;
  858. return device_is_compatible(root, compat);
  859. }
  861. /*
  862.  * Construct and return a list of the device_nodes with a given type
  863.  * and compatible property.
  864.  */
  865. struct device_node *
  866. find_compatible_devices(const char *type, const char *compat)
  867. {
  868. struct device_node *head, **prevp, *np;
  870. prevp = &head;
  871. for (np = allnodes; np != 0; np = np->allnext) {
  872. if (type != NULL
  873.     && !(np->type != 0 && strcasecmp(np->type, type) == 0))
  874. continue;
  875. if (device_is_compatible(np, compat)) {
  876. *prevp = np;
  877. prevp = &np->next;
  878. }
  879. }
  880. *prevp = 0;
  881. return head;
  882. }
  884. /*
  885.  * Find the device_node with a given full_name.
  886.  */
  887. struct device_node *
  888. find_path_device(const char *path)
  889. {
  890. struct device_node *np;
  892. for (np = allnodes; np != 0; np = np->allnext)
  893. if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0)
  894. return np;
  895. return NULL;
  896. }
  898. /*
  899.  * Find the device_node with a given phandle.
  900.  */
  901. struct device_node * __init
  902. find_phandle(phandle ph)
  903. {
  904. struct device_node *np;
  906. for (np = allnodes; np != 0; np = np->allnext)
  907. if (np->node == ph)
  908. return np;
  909. return NULL;
  910. }
  912. /*
  913.  * Find a property with a given name for a given node
  914.  * and return the value.
  915.  */
  916. unsigned char *
  917. get_property(struct device_node *np, const char *name, int *lenp)
  918. {
  919. struct property *pp;
  921. for (pp = np->properties; pp != 0; pp = pp->next)
  922. if (pp->name != NULL && strcmp(pp->name, name) == 0) {
  923. if (lenp != 0)
  924. *lenp = pp->length;
  925. return pp->value;
  926. }
  927. return 0;
  928. }
  930. /*
  931.  * Add a property to a node
  932.  */
  933. void __openfirmware
  934. prom_add_property(struct device_node* np, struct property* prop)
  935. {
  936. struct property **next = &np->properties;
  938. prop->next = NULL;
  939. while (*next)
  940. next = &(*next)->next;
  941. *next = prop;
  942. }
  944. /* I quickly hacked that one, check against spec ! */
  945. static inline unsigned long __openfirmware
  946. bus_space_to_resource_flags(unsigned int bus_space)
  947. {
  948. u8 space = (bus_space >> 24) & 0xf;
  949. if (space == 0)
  950. space = 0x02;
  951. if (space == 0x02)
  952. return IORESOURCE_MEM;
  953. else if (space == 0x01)
  954. return IORESOURCE_IO;
  955. else {
  956. printk(KERN_WARNING "prom.c: bus_space_to_resource_flags(), space: %xn",
  957.      bus_space);
  958. return 0;
  959. }
  960. }
  962. static struct resource* __openfirmware
  963. find_parent_pci_resource(struct pci_dev* pdev, struct address_range *range)
  964. {
  965. unsigned long mask;
  966. int i;
  968. /* Check this one */ 
  969. mask = bus_space_to_resource_flags(range->space);
  970. for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
  971. if ((pdev->resource[i].flags & mask) == mask &&
  972. pdev->resource[i].start <= range->address &&
  973. pdev->resource[i].end > range->address) {
  974. if ((range->address + range->size - 1) > pdev->resource[i].end) {
  975. /* Add better message */
  976. printk(KERN_WARNING "PCI/OF resource overlap !n");
  977. return NULL;
  978. }
  979. break;
  980. }
  981. }
  982. if (i == DEVICE_COUNT_RESOURCE)
  983. return NULL;
  984. return &pdev->resource[i];
  985. }
  987. /*
  988.  * Request an OF device resource. Currently handles child of PCI devices,
  989.  * or other nodes attached to the root node. Ultimately, put some
  990.  * link to resources in the OF node.
  991.  * WARNING: out_resource->name should be initialized before calling this
  992.  * function.
  993.  */
  994. struct resource* __openfirmware
  995. request_OF_resource(struct device_node* node, int index, const char* name_postfix)
  996. {
  997. struct pci_dev* pcidev;
  998. u8 pci_bus, pci_devfn;
  999. unsigned long iomask;
  1000. struct device_node* nd;
  1001. struct resource* parent;
  1002. struct resource *res = NULL;
  1003. int nlen, plen;
  1005. if (index >= node->n_addrs)
  1006. goto fail;
  1008. /* Sanity check on bus space */
  1009. iomask = bus_space_to_resource_flags(node->addrs[index].space);
  1010. if (iomask & IORESOURCE_MEM)
  1011. parent = &iomem_resource;
  1012. else if (iomask & IORESOURCE_IO)
  1013. parent = &ioport_resource;
  1014. else
  1015. goto fail;
  1017. /* Find a PCI parent if any */
  1018. nd = node;
  1019. pcidev = NULL;
  1020. while(nd) {
  1021. if (!pci_device_from_OF_node(nd, &pci_bus, &pci_devfn))
  1022. pcidev = pci_find_slot(pci_bus, pci_devfn);
  1023. if (pcidev) break;
  1024. nd = nd->parent;
  1025. }
  1026. if (pcidev)
  1027. parent = find_parent_pci_resource(pcidev, &node->addrs[index]);
  1028. if (!parent) {
  1029. printk(KERN_WARNING "request_OF_resource(%s), parent not foundn",
  1030. node->name);
  1031. goto fail;
  1032. }
  1034. res = __request_region(parent, node->addrs[index].address, node->addrs[index].size, NULL);
  1035. if (!res)
  1036. goto fail;
  1037. nlen = strlen(node->name);
  1038. plen = name_postfix ? strlen(name_postfix) : 0;
  1039. res->name = (const char *)kmalloc(nlen+plen+1, GFP_KERNEL);
  1040. if (res->name) {
  1041. strcpy((char *)res->name, node->name);
  1042. if (plen)
  1043. strcpy((char *)res->name+nlen, name_postfix);
  1044. }
  1045. return res;
  1046. fail:
  1047. return NULL;
  1048. }
  1050. int __openfirmware
  1051. release_OF_resource(struct device_node* node, int index)
  1052. {
  1053. struct pci_dev* pcidev;
  1054. u8 pci_bus, pci_devfn;
  1055. unsigned long iomask;
  1056. struct device_node* nd;
  1057. struct resource* parent;
  1058. struct resource *res = NULL;
  1060. if (index >= node->n_addrs)
  1061. return -EINVAL;
  1063. /* Sanity check on bus space */
  1064. iomask = bus_space_to_resource_flags(node->addrs[index].space);
  1065. if (iomask & IORESOURCE_MEM)
  1066. parent = &iomem_resource;
  1067. else if (iomask & IORESOURCE_IO)
  1068. parent = &ioport_resource;
  1069. else
  1070. return -EINVAL;
  1072. /* Find a PCI parent if any */
  1073. nd = node;
  1074. pcidev = NULL;
  1075. while(nd) {
  1076. if (!pci_device_from_OF_node(nd, &pci_bus, &pci_devfn))
  1077. pcidev = pci_find_slot(pci_bus, pci_devfn);
  1078. if (pcidev) break;
  1079. nd = nd->parent;
  1080. }
  1081. if (pcidev)
  1082. parent = find_parent_pci_resource(pcidev, &node->addrs[index]);
  1083. if (!parent) {
  1084. printk(KERN_WARNING "request_OF_resource(%s), parent not foundn",
  1085. node->name);
  1086. return -ENODEV;
  1087. }
  1089. /* Find us in the parent */
  1090. res = parent->child;
  1091. while (res) {
  1092. if (res->start == node->addrs[index].address &&
  1093.     res->end == (res->start + node->addrs[index].size - 1))
  1094.      break;
  1095. res = res->sibling;
  1096. }
  1097. if (!res)
  1098. return -ENODEV;
  1100. if (res->name) {
  1101. kfree(res->name);
  1102. res->name = NULL;
  1103. }
  1104. release_resource(res);
  1105. kfree(res);
  1107. return 0;
  1108. }
  1110. #if 0
  1111. void __openfirmware
  1112. print_properties(struct device_node *np)
  1113. {
  1114. struct property *pp;
  1115. char *cp;
  1116. int i, n;
  1118. for (pp = np->properties; pp != 0; pp = pp->next) {
  1119. printk(KERN_INFO "%s", pp->name);
  1120. for (i = strlen(pp->name); i < 16; ++i)
  1121. printk(" ");
  1122. cp = (char *) pp->value;
  1123. for (i = pp->length; i > 0; --i, ++cp)
  1124. if ((i > 1 && (*cp < 0x20 || *cp > 0x7e))
  1125.     || (i == 1 && *cp != 0))
  1126. break;
  1127. if (i == 0 && pp->length > 1) {
  1128. /* looks like a string */
  1129. printk(" %sn", (char *) pp->value);
  1130. } else {
  1131. /* dump it in hex */
  1132. n = pp->length;
  1133. if (n > 64)
  1134. n = 64;
  1135. if (pp->length % 4 == 0) {
  1136. unsigned int *p = (unsigned int *) pp->value;
  1138. n /= 4;
  1139. for (i = 0; i < n; ++i) {
  1140. if (i != 0 && (i % 4) == 0)
  1141. printk("n                ");
  1142. printk(" %08x", *p++);
  1143. }
  1144. } else {
  1145. unsigned char *bp = pp->value;
  1147. for (i = 0; i < n; ++i) {
  1148. if (i != 0 && (i % 16) == 0)
  1149. printk("n                ");
  1150. printk(" %02x", *bp++);
  1151. }
  1152. }
  1153. printk("n");
  1154. if (pp->length > 64)
  1155. printk("                 ... (length = %d)n",
  1156.        pp->length);
  1157. }
  1158. }
  1159. }
  1160. #endif
  1162. static spinlock_t rtas_lock = SPIN_LOCK_UNLOCKED;
  1164. /* this can be called after setup -- Cort */
  1165. int __openfirmware
  1166. call_rtas(const char *service, int nargs, int nret,
  1167.   unsigned long *outputs, ...)
  1168. {
  1169. va_list list;
  1170. int i;
  1171. unsigned long s;
  1172. struct device_node *rtas;
  1173. int *tokp;
  1174. union {
  1175. unsigned long words[16];
  1176. double align;
  1177. } u;
  1179. rtas = find_devices("rtas");
  1180. if (rtas == NULL)
  1181. return -1;
  1182. tokp = (int *) get_property(rtas, service, NULL);
  1183. if (tokp == NULL) {
  1184. printk(KERN_ERR "No RTAS service called %sn", service);
  1185. return -1;
  1186. }
  1187. u.words[0] = *tokp;
  1188. u.words[1] = nargs;
  1189. u.words[2] = nret;
  1190. va_start(list, outputs);
  1191. for (i = 0; i < nargs; ++i)
  1192. u.words[i+3] = va_arg(list, unsigned long);
  1193. va_end(list);
  1195. /*
  1196.  * RTAS doesn't use floating point.
  1197.  * Or at least, according to the CHRP spec we enter RTAS
  1198.  * with FP disabled, and it doesn't change the FP registers.
  1199.  *  -- paulus.
  1200.  */
  1201. spin_lock_irqsave(&rtas_lock, s);
  1202. enter_rtas((void *)__pa(&u));
  1203. spin_unlock_irqrestore(&rtas_lock, s);
  1205. if (nret > 1 && outputs != NULL)
  1206. for (i = 0; i < nret-1; ++i)
  1207. outputs[i] = u.words[i+nargs+4];
  1208. return u.words[nargs+3];
  1209. }