1 /*- 2 * Copyright (c) 1994 Charles M. Hannum. All rights reserved. 3 * Copyright (c) 1996 Christopher G. Demetriou. All rights reserved. 4 * Copyright (c) 1997, Stefan Esser <se@freebsd.org> 5 * Copyright (c) 2000, Michael Smith <msmith@freebsd.org> 6 * Copyright (c) 2000, BSDi 7 * Copyright (c) 2003, Thomas Moestl <tmm@FreeBSD.org> 8 * All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice unmodified, this list of conditions, and the following 15 * disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include <sys/param.h> 36 #include <sys/bus.h> 37 #include <sys/kernel.h> 38 #include <sys/libkern.h> 39 #include <sys/module.h> 40 #include <sys/pciio.h> 41 42 #include <dev/ofw/ofw_bus.h> 43 #include <dev/ofw/ofw_bus_subr.h> 44 #include <dev/ofw/ofw_pci.h> 45 #include <dev/ofw/openfirm.h> 46 47 #include <machine/bus.h> 48 #include <machine/resource.h> 49 50 #include <dev/pci/pcireg.h> 51 #include <dev/pci/pcivar.h> 52 #include <dev/pci/pci_private.h> 53 54 #include "pcib_if.h" 55 #include "pci_if.h" 56 57 /* Helper functions */ 58 static int find_node_intr(phandle_t, u_int32_t *, u_int32_t *); 59 static int ofw_pci_find_intline(phandle_t node, uint32_t *irqs); 60 static void ofw_pci_fixup_node(device_t dev, phandle_t node); 61 62 /* Methods */ 63 static device_probe_t ofw_pcibus_probe; 64 static device_attach_t ofw_pcibus_attach; 65 static pci_assign_interrupt_t ofw_pcibus_assign_interrupt; 66 static ofw_bus_get_devinfo_t ofw_pcibus_get_devinfo; 67 68 static device_method_t ofw_pcibus_methods[] = { 69 /* Device interface */ 70 DEVMETHOD(device_probe, ofw_pcibus_probe), 71 DEVMETHOD(device_attach, ofw_pcibus_attach), 72 73 /* PCI interface */ 74 DEVMETHOD(pci_assign_interrupt, ofw_pcibus_assign_interrupt), 75 76 /* ofw_bus interface */ 77 DEVMETHOD(ofw_bus_get_devinfo, ofw_pcibus_get_devinfo), 78 DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), 79 DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), 80 DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), 81 DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), 82 DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), 83 84 { 0, 0 } 85 }; 86 87 struct ofw_pcibus_devinfo { 88 struct pci_devinfo opd_dinfo; 89 struct ofw_bus_devinfo opd_obdinfo; 90 }; 91 92 static devclass_t pci_devclass; 93 94 DEFINE_CLASS_1(pci, ofw_pcibus_driver, ofw_pcibus_methods, 1 /* no softc */, 95 pci_driver); 96 DRIVER_MODULE(ofw_pcibus, pcib, ofw_pcibus_driver, pci_devclass, 0, 0); 97 MODULE_VERSION(ofw_pcibus, 1); 98 MODULE_DEPEND(ofw_pcibus, pci, 1, 1, 1); 99 100 static int 101 ofw_pcibus_probe(device_t dev) 102 { 103 if (ofw_bus_get_node(dev) == 0) 104 return (ENXIO); 105 device_set_desc(dev, "OFW PCI bus"); 106 107 return (0); 108 } 109 110 static int 111 ofw_pcibus_attach(device_t dev) 112 { 113 device_t pcib; 114 struct ofw_pci_register pcir; 115 struct ofw_pcibus_devinfo *dinfo; 116 phandle_t node, child; 117 u_int busno, domain, func, slot; 118 119 pcib = device_get_parent(dev); 120 domain = pcib_get_domain(dev); 121 busno = pcib_get_bus(dev); 122 if (bootverbose) 123 device_printf(dev, "domain=%d, physical bus=%d\n", 124 domain, busno); 125 node = ofw_bus_get_node(dev); 126 127 for (child = OF_child(node); child != 0; child = OF_peer(child)) { 128 if (OF_getprop(child, "reg", &pcir, sizeof(pcir)) == -1) 129 continue; 130 slot = OFW_PCI_PHYS_HI_DEVICE(pcir.phys_hi); 131 func = OFW_PCI_PHYS_HI_FUNCTION(pcir.phys_hi); 132 133 /* Some OFW device trees contain dupes. */ 134 if (pci_find_dbsf(domain, busno, slot, func) != NULL) 135 continue; 136 137 ofw_pci_fixup_node(pcib, child); 138 139 dinfo = (struct ofw_pcibus_devinfo *)pci_read_device(pcib, 140 domain, busno, slot, func, sizeof(*dinfo)); 141 142 if (dinfo == NULL) 143 continue; 144 145 /* Set up OFW devinfo */ 146 if (ofw_bus_gen_setup_devinfo(&dinfo->opd_obdinfo, child) != 147 0) { 148 pci_freecfg((struct pci_devinfo *)dinfo); 149 continue; 150 } 151 152 pci_add_child(dev, (struct pci_devinfo *)dinfo); 153 154 /* 155 * Some devices don't have an intpin set, but do have 156 * interrupts. Add them to the appropriate resource list. 157 */ 158 if (dinfo->opd_dinfo.cfg.intpin == 0) { 159 uint32_t irqs[4]; 160 161 if (ofw_pci_find_intline(child, irqs) > 0) 162 resource_list_add(&dinfo->opd_dinfo.resources, 163 SYS_RES_IRQ, 0, irqs[0], irqs[0], 1); 164 } 165 } 166 167 return (bus_generic_attach(dev)); 168 } 169 170 static int 171 ofw_pcibus_assign_interrupt(device_t dev, device_t child) 172 { 173 uint32_t irqs[4]; 174 175 device_printf(child,"Assigning interrupt\n"); 176 177 if (ofw_pci_find_intline(ofw_bus_get_node(child), irqs) < 0) 178 return PCI_INVALID_IRQ; 179 180 device_printf(child,"IRQ %d\n",irqs[0]); 181 182 return irqs[0]; 183 184 // return (PCIB_ROUTE_INTERRUPT(device_get_parent(dev), child, intr)); 185 } 186 187 static const struct ofw_bus_devinfo * 188 ofw_pcibus_get_devinfo(device_t bus, device_t dev) 189 { 190 struct ofw_pcibus_devinfo *dinfo; 191 192 dinfo = device_get_ivars(dev); 193 return (&dinfo->opd_obdinfo); 194 } 195 196 static void 197 ofw_pci_fixup_node(device_t dev, phandle_t node) 198 { 199 uint32_t csr, intr, irqs[4]; 200 struct ofw_pci_register addr[8]; 201 int len, i; 202 203 len = OF_getprop(node, "assigned-addresses", addr, sizeof(addr)); 204 if (len < (int)sizeof(struct ofw_pci_register)) { 205 return; 206 } 207 208 csr = PCIB_READ_CONFIG(dev, OFW_PCI_PHYS_HI_BUS(addr[0].phys_hi), 209 OFW_PCI_PHYS_HI_DEVICE(addr[0].phys_hi), 210 OFW_PCI_PHYS_HI_FUNCTION(addr[0].phys_hi), PCIR_COMMAND, 4); 211 csr &= ~(PCIM_CMD_PORTEN | PCIM_CMD_MEMEN); 212 213 for (i = 0; i < len / sizeof(struct ofw_pci_register); i++) { 214 switch (addr[i].phys_hi & OFW_PCI_PHYS_HI_SPACEMASK) { 215 case OFW_PCI_PHYS_HI_SPACE_IO: 216 csr |= PCIM_CMD_PORTEN; 217 break; 218 case OFW_PCI_PHYS_HI_SPACE_MEM32: 219 csr |= PCIM_CMD_MEMEN; 220 break; 221 } 222 } 223 224 PCIB_WRITE_CONFIG(dev, OFW_PCI_PHYS_HI_BUS(addr[0].phys_hi), 225 OFW_PCI_PHYS_HI_DEVICE(addr[0].phys_hi), 226 OFW_PCI_PHYS_HI_FUNCTION(addr[0].phys_hi), PCIR_COMMAND, csr, 4); 227 228 if (ofw_pci_find_intline(node, irqs) != -1) { 229 intr = PCIB_READ_CONFIG(dev, 230 OFW_PCI_PHYS_HI_BUS(addr[0].phys_hi), 231 OFW_PCI_PHYS_HI_DEVICE(addr[0].phys_hi), 232 OFW_PCI_PHYS_HI_FUNCTION(addr[0].phys_hi), PCIR_INTLINE, 2); 233 intr &= ~(0xff); 234 intr |= irqs[0] & 0xff; 235 PCIB_WRITE_CONFIG(dev, 236 OFW_PCI_PHYS_HI_BUS(addr[0].phys_hi), 237 OFW_PCI_PHYS_HI_DEVICE(addr[0].phys_hi), 238 OFW_PCI_PHYS_HI_FUNCTION(addr[0].phys_hi), PCIR_INTLINE, 239 intr, 2); 240 } 241 } 242 243 static int 244 ofw_pci_find_intline(phandle_t node, uint32_t *irqs) 245 { 246 uint32_t npintr, paddr[4]; 247 struct ofw_pci_register addr[8]; 248 int len; 249 250 len = OF_getprop(node, "assigned-addresses", addr, sizeof(addr)); 251 if (len < (int)sizeof(struct ofw_pci_register)) 252 return -1; 253 /* 254 * Create PCI interrupt-map array element. pci-mid/pci-lo 255 * aren't required, but the 'interrupts' property needs 256 * to be appended 257 */ 258 npintr = 0; 259 OF_getprop(node, "interrupts", &npintr, 4); 260 paddr[0] = addr[0].phys_hi; 261 paddr[1] = 0; 262 paddr[2] = 0; 263 paddr[3] = npintr; 264 265 return find_node_intr(node, paddr, irqs); 266 } 267 268 static int 269 find_node_intr(phandle_t node, u_int32_t *addr, u_int32_t *intr) 270 { 271 phandle_t parent, iparent; 272 int len, mlen, match, i; 273 u_int32_t map[160], *mp, imask[8], maskedaddr[8], icells; 274 char name[32]; 275 276 len = OF_getprop(node, "AAPL,interrupts", intr, 4); 277 if (len == 4) { 278 return (len); 279 } 280 281 parent = OF_parent(node); 282 len = OF_getprop(parent, "interrupt-map", map, sizeof(map)); 283 mlen = OF_getprop(parent, "interrupt-map-mask", imask, sizeof(imask)); 284 285 if (len == -1 || mlen == -1) 286 goto nomap; 287 288 memcpy(maskedaddr, addr, mlen); 289 for (i = 0; i < mlen/4; i++) 290 maskedaddr[i] &= imask[i]; 291 292 mp = map; 293 while (len > mlen) { 294 match = bcmp(maskedaddr, mp, mlen); 295 mp += mlen / 4; 296 len -= mlen; 297 298 /* 299 * We must read "#interrupt-cells" for each time because 300 * interrupt-parent may be different. 301 */ 302 iparent = *mp++; 303 len -= 4; 304 if (OF_getprop(iparent, "#interrupt-cells", &icells, 4) != 4) 305 goto nomap; 306 307 /* Found. */ 308 if (match == 0) { 309 bcopy(mp, intr, icells * 4); 310 return (icells * 4); 311 } 312 313 mp += icells; 314 len -= icells * 4; 315 } 316 317 nomap: 318 /* 319 * Check for local properties indicating interrupts 320 */ 321 322 len = OF_getprop(node, "interrupts", intr, 16); 323 if (OF_getprop(node, "interrupt-parent", &iparent, sizeof(iparent)) == 324 sizeof(iparent)) { 325 OF_getprop(iparent, "#interrupt-cells", &icells, sizeof(icells)); 326 for (i = 0; i < len/icells/4; i++) 327 intr[i] = intr[i*icells]; 328 329 return (len); 330 } 331 332 333 /* 334 * If the node has no interrupt property and the parent is a PCI 335 * bridge, use the parent's interrupt. This occurs on a PCI slot. 336 */ 337 bzero(name, sizeof(name)); 338 OF_getprop(parent, "name", name, sizeof(name)); 339 if (strcmp(name, "pci-bridge") == 0) { 340 len = OF_getprop(parent, "AAPL,interrupts", intr, 4); 341 if (len == 4) { 342 return (len); 343 } 344 345 /* 346 * XXX I don't know what is the correct local address. 347 * XXX Use the first entry for now. 348 */ 349 len = OF_getprop(parent, "interrupt-map", map, sizeof(map)); 350 if (len >= 36) { 351 addr = &map[5]; 352 /* XXX Use 0 for 'interrupts' for compat */ 353 return (find_node_intr(parent, addr, intr)); 354 } 355 } 356 357 return (-1); 358 } 359 360