arch/microblaze/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                 return of_irq_map_one(dn, 0, out_irq);
  29
  30         /* Ok, we don't, time to have fun. Let's start by building up an
  31          * interrupt spec.  we assume #interrupt-cells is 1, which is standard
  32          * for PCI. If you do different, then don't use that routine.
  33          */
  34         rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
  35         if (rc != 0)
  36                 return rc;
  37         /* No pin, exit */
  38         if (pin == 0)
  39                 return -ENODEV;
  40
  41         /* Now we walk up the PCI tree */
  42         lspec = pin;
  43         for (;;) {
  44                 /* Get the pci_dev of our parent */
  45                 ppdev = pdev->bus->self;
  46
  47                 /* Ouch, it's a host bridge... */
  48                 if (ppdev == NULL) {
  49                         struct pci_controller *host;
  50                         host = pci_bus_to_host(pdev->bus);
  51                         ppnode = host ? host->dn : NULL;
  52                         /* No node for host bridge ? give up */
  53                         if (ppnode == NULL)
  54                                 return -EINVAL;
  55                 } else
  56                         /* We found a P2P bridge, check if it has a node */
  57                         ppnode = pci_device_to_OF_node(ppdev);
  58
  59                 /* Ok, we have found a parent with a device-node, hand over to
  60                  * the OF parsing code.
  61                  * We build a unit address from the linux device to be used for
  62                  * resolution. Note that we use the linux bus number which may
  63                  * not match your firmware bus numbering.
  64                  * Fortunately, in most cases, interrupt-map-mask doesn't
  65                  * include the bus number as part of the matching.
  66                  * You should still be careful about that though if you intend
  67                  * to rely on this function (you ship  a firmware that doesn't
  68                  * create device nodes for all PCI devices).
  69                  */
  70                 if (ppnode)
  71                         break;
  72
  73                 /* We can only get here if we hit a P2P bridge with no node,
  74                  * let's do standard swizzling and try again
  75                  */
  76                 lspec = of_irq_pci_swizzle(PCI_SLOT(pdev->devfn), lspec);
  77                 pdev = ppdev;
  78         }
  79
  80         laddr[0] = (pdev->bus->number << 16)
  81                 | (pdev->devfn << 8);
  82         laddr[1]  = laddr[2] = 0;
  83         return of_irq_map_raw(ppnode, &lspec, 1, laddr, out_irq);
  84 }
  85 EXPORT_SYMBOL_GPL(of_irq_map_pci);
  86 #endif /* CONFIG_PCI */
  87
  88 void of_parse_dma_window(struct device_node *dn, const void *dma_window_prop,
  89                 unsigned long *busno, unsigned long *phys, unsigned long *size)
  90 {
  91         const u32 *dma_window;
  92         u32 cells;
  93         const unsigned char *prop;
  94
  95         dma_window = dma_window_prop;
  96
  97         /* busno is always one cell */
  98         *busno = *(dma_window++);
  99
 100         prop = of_get_property(dn, "ibm,#dma-address-cells", NULL);
 101         if (!prop)
 102                 prop = of_get_property(dn, "#address-cells", NULL);
 103
 104         cells = prop ? *(u32 *)prop : of_n_addr_cells(dn);
 105         *phys = of_read_number(dma_window, cells);
 106
 107         dma_window += cells;
 108
 109         prop = of_get_property(dn, "ibm,#dma-size-cells", NULL);
 110         cells = prop ? *(u32 *)prop : of_n_size_cells(dn);
 111         *size = of_read_number(dma_window, cells);
 112 }
 113
 114 /**
 115  * Search the device tree for the best MAC address to use.  'mac-address' is
 116  * checked first, because that is supposed to contain to "most recent" MAC
 117  * address. If that isn't set, then 'local-mac-address' is checked next,
 118  * because that is the default address.  If that isn't set, then the obsolete
 119  * 'address' is checked, just in case we're using an old device tree.
 120  *
 121  * Note that the 'address' property is supposed to contain a virtual address of
 122  * the register set, but some DTS files have redefined that property to be the
 123  * MAC address.
 124  *
 125  * All-zero MAC addresses are rejected, because those could be properties that
 126  * exist in the device tree, but were not set by U-Boot.  For example, the
 127  * DTS could define 'mac-address' and 'local-mac-address', with zero MAC
 128  * addresses.  Some older U-Boots only initialized 'local-mac-address'.  In
 129  * this case, the real MAC is in 'local-mac-address', and 'mac-address' exists
 130  * but is all zeros.
 131 */
 132 const void *of_get_mac_address(struct device_node *np)
 133 {
 134         struct property *pp;
 135
 136         pp = of_find_property(np, "mac-address", NULL);
 137         if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value))
 138                 return pp->value;
 139
 140         pp = of_find_property(np, "local-mac-address", NULL);
 141         if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value))
 142                 return pp->value;
 143
 144         pp = of_find_property(np, "address", NULL);
 145         if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value))
 146                 return pp->value;
 147
 148         return NULL;
 149 }
 150 EXPORT_SYMBOL(of_get_mac_address);