| 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 | } |
| 120 | |
| 121 | /** |
| 122 | * Search the device tree for the best MAC address to use. 'mac-address' is |
| 123 | * checked first, because that is supposed to contain to "most recent" MAC |
| 124 | * address. If that isn't set, then 'local-mac-address' is checked next, |
| 125 | * because that is the default address. If that isn't set, then the obsolete |
| 126 | * 'address' is checked, just in case we're using an old device tree. |
| 127 | * |
| 128 | * Note that the 'address' property is supposed to contain a virtual address of |
| 129 | * the register set, but some DTS files have redefined that property to be the |
| 130 | * MAC address. |
| 131 | * |
| 132 | * All-zero MAC addresses are rejected, because those could be properties that |
| 133 | * exist in the device tree, but were not set by U-Boot. For example, the |
| 134 | * DTS could define 'mac-address' and 'local-mac-address', with zero MAC |
| 135 | * addresses. Some older U-Boots only initialized 'local-mac-address'. In |
| 136 | * this case, the real MAC is in 'local-mac-address', and 'mac-address' exists |
| 137 | * but is all zeros. |
| 138 | */ |
| 139 | const void *of_get_mac_address(struct device_node *np) |
| 140 | { |
| 141 | struct property *pp; |
| 142 | |
| 143 | pp = of_find_property(np, "mac-address", NULL); |
| 144 | if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value)) |
| 145 | return pp->value; |
| 146 | |
| 147 | pp = of_find_property(np, "local-mac-address", NULL); |
| 148 | if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value)) |
| 149 | return pp->value; |
| 150 | |
| 151 | pp = of_find_property(np, "address", NULL); |
| 152 | if (pp && (pp->length == 6) && is_valid_ether_addr(pp->value)) |
| 153 | return pp->value; |
| 154 | |
| 155 | return NULL; |
| 156 | } |
| 157 | EXPORT_SYMBOL(of_get_mac_address); |