arch/powerpc/kernel/prom_parse.c

   1 #undef DEBUG
   2
   3 #include <linux/kernel.h>
   4 #include <linux/string.h>
   5 #include <linux/pci_regs.h>
   6 #include <linux/module.h>
   7 #include <linux/ioport.h>
   8 #include <linux/etherdevice.h>
   9 #include <linux/of_address.h>
  10 #include <asm/prom.h>
  11 #include <asm/pci-bridge.h>
  12
  13 #ifdef CONFIG_PCI
  14 int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq)
  15 {
  16         struct device_node *dn, *ppnode;
  17         struct pci_dev *ppdev;
  18         u32 lspec;
  19         u32 laddr[3];
  20         u8 pin;
  21         int rc;
  22
  23         /* Check if we have a device node, if yes, fallback to standard OF
  24          * parsing
  25          */
  26         dn = pci_device_to_OF_node(pdev);
  27         if (dn) {
  28                 rc = of_irq_map_one(dn, 0, out_irq);
  29                 if (!rc)
  30                         return rc;
  31         }
  32
  33         /* Ok, we don't, time to have fun. Let's start by building up an
  34          * interrupt spec.  we assume #interrupt-cells is 1, which is standard
  35          * for PCI. If you do different, then don't use that routine.
  36          */
  37         rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
  38         if (rc != 0)
  39                 return rc;
  40         /* No pin, exit */
  41         if (pin == 0)
  42                 return -ENODEV;
  43
  44         /* Now we walk up the PCI tree */
  45         lspec = pin;
  46         for (;;) {
  47                 /* Get the pci_dev of our parent */
  48                 ppdev = pdev->bus->self;
  49
  50                 /* Ouch, it's a host bridge... */
  51                 if (ppdev == NULL) {
  52 #ifdef CONFIG_PPC64
  53                         ppnode = pci_bus_to_OF_node(pdev->bus);
  54 #else
  55                         struct pci_controller *host;
  56                         host = pci_bus_to_host(pdev->bus);
  57                         ppnode = host ? host->dn : NULL;
  58 #endif
  59                         /* No node for host bridge ? give up */
  60                         if (ppnode == NULL)
  61                                 return -EINVAL;
  62                 } else
  63                         /* We found a P2P bridge, check if it has a node */
  64                         ppnode = pci_device_to_OF_node(ppdev);
  65
  66                 /* Ok, we have found a parent with a device-node, hand over to
  67                  * the OF parsing code.
  68                  * We build a unit address from the linux device to be used for
  69                  * resolution. Note that we use the linux bus number which may
  70                  * not match your firmware bus numbering.
  71                  * Fortunately, in most cases, interrupt-map-mask doesn't include
  72                  * the bus number as part of the matching.
  73                  * You should still be careful about that though if you intend
  74                  * to rely on this function (you ship  a firmware that doesn't
  75                  * create device nodes for all PCI devices).
  76                  */
  77                 if (ppnode)
  78                         break;
  79
  80                 /* We can only get here if we hit a P2P bridge with no node,
  81                  * let's do standard swizzling and try again
  82                  */
  83                 lspec = pci_swizzle_interrupt_pin(pdev, lspec);
  84                 pdev = ppdev;
  85         }
  86
  87         laddr[0] = (pdev->bus->number << 16)
  88                 | (pdev->devfn << 8);
  89         laddr[1]  = laddr[2] = 0;
  90         return of_irq_map_raw(ppnode, &lspec, 1, laddr, out_irq);
  91 }
  92 EXPORT_SYMBOL_GPL(of_irq_map_pci);
  93 #endif /* CONFIG_PCI */
  94
  95 void of_parse_dma_window(struct device_node *dn, const void *dma_window_prop,
  96                 unsigned long *busno, unsigned long *phys, unsigned long *size)
  97 {
  98         const u32 *dma_window;
  99         u32 cells;
 100         const unsigned char *prop;
 101
 102         dma_window = dma_window_prop;
 103
 104         /* busno is always one cell */
 105         *busno = *(dma_window++);
 106
 107         prop = of_get_property(dn, "ibm,#dma-address-cells", NULL);
 108         if (!prop)
 109                 prop = of_get_property(dn, "#address-cells", NULL);
 110
 111         cells = prop ? *(u32 *)prop : of_n_addr_cells(dn);
 112         *phys = of_read_number(dma_window, cells);
 113
 114         dma_window += cells;
 115
 116         prop = of_get_property(dn, "ibm,#dma-size-cells", NULL);
 117         cells = prop ? *(u32 *)prop : of_n_size_cells(dn);
 118         *size = of_read_number(dma_window, cells);
 119 }