diff options
Diffstat (limited to 'sys/powerpc/ofw/ofw_pcibus.c')
| -rw-r--r-- | sys/powerpc/ofw/ofw_pcibus.c | 359 |
1 files changed, 359 insertions, 0 deletions
diff --git a/sys/powerpc/ofw/ofw_pcibus.c b/sys/powerpc/ofw/ofw_pcibus.c new file mode 100644 index 000000000000..916d98bc57b7 --- /dev/null +++ b/sys/powerpc/ofw/ofw_pcibus.c @@ -0,0 +1,359 @@ +/*- + * Copyright (c) 1994 Charles M. Hannum. All rights reserved. + * Copyright (c) 1996 Christopher G. Demetriou. All rights reserved. + * Copyright (c) 1997, Stefan Esser <se@freebsd.org> + * Copyright (c) 2000, Michael Smith <msmith@freebsd.org> + * Copyright (c) 2000, BSDi + * Copyright (c) 2003, Thomas Moestl <tmm@FreeBSD.org> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice unmodified, this list of conditions, and the following + * disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/cdefs.h> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/bus.h> +#include <sys/kernel.h> +#include <sys/libkern.h> +#include <sys/module.h> +#include <sys/pciio.h> + +#include <dev/ofw/ofw_bus.h> +#include <dev/ofw/ofw_bus_subr.h> +#include <dev/ofw/ofw_pci.h> +#include <dev/ofw/openfirm.h> + +#include <machine/bus.h> +#include <machine/resource.h> + +#include <dev/pci/pcireg.h> +#include <dev/pci/pcivar.h> +#include <dev/pci/pci_private.h> + +#include "pcib_if.h" +#include "pci_if.h" + +/* Helper functions */ +static int find_node_intr(phandle_t, u_int32_t *, u_int32_t *); +static int ofw_pci_find_intline(phandle_t node, uint32_t *irqs); +static void ofw_pci_fixup_node(device_t dev, phandle_t node); + +/* Methods */ +static device_probe_t ofw_pcibus_probe; +static device_attach_t ofw_pcibus_attach; +static pci_assign_interrupt_t ofw_pcibus_assign_interrupt; +static ofw_bus_get_devinfo_t ofw_pcibus_get_devinfo; + +static device_method_t ofw_pcibus_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, ofw_pcibus_probe), + DEVMETHOD(device_attach, ofw_pcibus_attach), + + /* PCI interface */ + DEVMETHOD(pci_assign_interrupt, ofw_pcibus_assign_interrupt), + + /* ofw_bus interface */ + DEVMETHOD(ofw_bus_get_devinfo, ofw_pcibus_get_devinfo), + DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), + DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), + DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), + DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), + DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), + + { 0, 0 } +}; + +struct ofw_pcibus_devinfo { + struct pci_devinfo opd_dinfo; + struct ofw_bus_devinfo opd_obdinfo; +}; + +static devclass_t pci_devclass; + +DEFINE_CLASS_1(pci, ofw_pcibus_driver, ofw_pcibus_methods, 1 /* no softc */, + pci_driver); +DRIVER_MODULE(ofw_pcibus, pcib, ofw_pcibus_driver, pci_devclass, 0, 0); +MODULE_VERSION(ofw_pcibus, 1); +MODULE_DEPEND(ofw_pcibus, pci, 1, 1, 1); + +static int +ofw_pcibus_probe(device_t dev) +{ + if (ofw_bus_get_node(dev) == 0) + return (ENXIO); + device_set_desc(dev, "OFW PCI bus"); + + return (0); +} + +static int +ofw_pcibus_attach(device_t dev) +{ + device_t pcib; + struct ofw_pci_register pcir; + struct ofw_pcibus_devinfo *dinfo; + phandle_t node, child; + u_int busno, domain, func, slot; + + pcib = device_get_parent(dev); + domain = pcib_get_domain(dev); + busno = pcib_get_bus(dev); + if (bootverbose) + device_printf(dev, "domain=%d, physical bus=%d\n", + domain, busno); + node = ofw_bus_get_node(dev); + + for (child = OF_child(node); child != 0; child = OF_peer(child)) { + if (OF_getprop(child, "reg", &pcir, sizeof(pcir)) == -1) + continue; + slot = OFW_PCI_PHYS_HI_DEVICE(pcir.phys_hi); + func = OFW_PCI_PHYS_HI_FUNCTION(pcir.phys_hi); + + /* Some OFW device trees contain dupes. */ + if (pci_find_dbsf(domain, busno, slot, func) != NULL) + continue; + + ofw_pci_fixup_node(pcib, child); + + dinfo = (struct ofw_pcibus_devinfo *)pci_read_device(pcib, + domain, busno, slot, func, sizeof(*dinfo)); + + if (dinfo == NULL) + continue; + + /* Set up OFW devinfo */ + if (ofw_bus_gen_setup_devinfo(&dinfo->opd_obdinfo, child) != + 0) { + pci_freecfg((struct pci_devinfo *)dinfo); + continue; + } + + pci_add_child(dev, (struct pci_devinfo *)dinfo); + + /* + * Some devices don't have an intpin set, but do have + * interrupts. Add them to the appropriate resource list. + */ + if (dinfo->opd_dinfo.cfg.intpin == 0) { + uint32_t irqs[4]; + + if (ofw_pci_find_intline(child, irqs) > 0) + resource_list_add(&dinfo->opd_dinfo.resources, + SYS_RES_IRQ, 0, irqs[0], irqs[0], 1); + } + } + + return (bus_generic_attach(dev)); +} + +static int +ofw_pcibus_assign_interrupt(device_t dev, device_t child) +{ + uint32_t irqs[4]; + + device_printf(child,"Assigning interrupt\n"); + + if (ofw_pci_find_intline(ofw_bus_get_node(child), irqs) < 0) + return PCI_INVALID_IRQ; + + device_printf(child,"IRQ %d\n",irqs[0]); + + return irqs[0]; + +// return (PCIB_ROUTE_INTERRUPT(device_get_parent(dev), child, intr)); +} + +static const struct ofw_bus_devinfo * +ofw_pcibus_get_devinfo(device_t bus, device_t dev) +{ + struct ofw_pcibus_devinfo *dinfo; + + dinfo = device_get_ivars(dev); + return (&dinfo->opd_obdinfo); +} + +static void +ofw_pci_fixup_node(device_t dev, phandle_t node) +{ + uint32_t csr, intr, irqs[4]; + struct ofw_pci_register addr[8]; + int len, i; + + len = OF_getprop(node, "assigned-addresses", addr, sizeof(addr)); + if (len < (int)sizeof(struct ofw_pci_register)) { + return; + } + + csr = PCIB_READ_CONFIG(dev, OFW_PCI_PHYS_HI_BUS(addr[0].phys_hi), + OFW_PCI_PHYS_HI_DEVICE(addr[0].phys_hi), + OFW_PCI_PHYS_HI_FUNCTION(addr[0].phys_hi), PCIR_COMMAND, 4); + csr &= ~(PCIM_CMD_PORTEN | PCIM_CMD_MEMEN); + + for (i = 0; i < len / sizeof(struct ofw_pci_register); i++) { + switch (addr[i].phys_hi & OFW_PCI_PHYS_HI_SPACEMASK) { + case OFW_PCI_PHYS_HI_SPACE_IO: + csr |= PCIM_CMD_PORTEN; + break; + case OFW_PCI_PHYS_HI_SPACE_MEM32: + csr |= PCIM_CMD_MEMEN; + break; + } + } + + PCIB_WRITE_CONFIG(dev, OFW_PCI_PHYS_HI_BUS(addr[0].phys_hi), + OFW_PCI_PHYS_HI_DEVICE(addr[0].phys_hi), + OFW_PCI_PHYS_HI_FUNCTION(addr[0].phys_hi), PCIR_COMMAND, csr, 4); + + if (ofw_pci_find_intline(node, irqs) != -1) { + intr = PCIB_READ_CONFIG(dev, + OFW_PCI_PHYS_HI_BUS(addr[0].phys_hi), + OFW_PCI_PHYS_HI_DEVICE(addr[0].phys_hi), + OFW_PCI_PHYS_HI_FUNCTION(addr[0].phys_hi), PCIR_INTLINE, 2); + intr &= ~(0xff); + intr |= irqs[0] & 0xff; + PCIB_WRITE_CONFIG(dev, + OFW_PCI_PHYS_HI_BUS(addr[0].phys_hi), + OFW_PCI_PHYS_HI_DEVICE(addr[0].phys_hi), + OFW_PCI_PHYS_HI_FUNCTION(addr[0].phys_hi), PCIR_INTLINE, + intr, 2); + } +} + +static int +ofw_pci_find_intline(phandle_t node, uint32_t *irqs) +{ + uint32_t npintr, paddr[4]; + struct ofw_pci_register addr[8]; + int len; + + len = OF_getprop(node, "assigned-addresses", addr, sizeof(addr)); + if (len < (int)sizeof(struct ofw_pci_register)) + return -1; + /* + * Create PCI interrupt-map array element. pci-mid/pci-lo + * aren't required, but the 'interrupts' property needs + * to be appended + */ + npintr = 0; + OF_getprop(node, "interrupts", &npintr, 4); + paddr[0] = addr[0].phys_hi; + paddr[1] = 0; + paddr[2] = 0; + paddr[3] = npintr; + + return find_node_intr(node, paddr, irqs); +} + +static int +find_node_intr(phandle_t node, u_int32_t *addr, u_int32_t *intr) +{ + phandle_t parent, iparent; + int len, mlen, match, i; + u_int32_t map[160], *mp, imask[8], maskedaddr[8], icells; + char name[32]; + + len = OF_getprop(node, "AAPL,interrupts", intr, 4); + if (len == 4) { + return (len); + } + + parent = OF_parent(node); + len = OF_getprop(parent, "interrupt-map", map, sizeof(map)); + mlen = OF_getprop(parent, "interrupt-map-mask", imask, sizeof(imask)); + + if (len == -1 || mlen == -1) + goto nomap; + + memcpy(maskedaddr, addr, mlen); + for (i = 0; i < mlen/4; i++) + maskedaddr[i] &= imask[i]; + + mp = map; + while (len > mlen) { + match = bcmp(maskedaddr, mp, mlen); + mp += mlen / 4; + len -= mlen; + + /* + * We must read "#interrupt-cells" for each time because + * interrupt-parent may be different. + */ + iparent = *mp++; + len -= 4; + if (OF_getprop(iparent, "#interrupt-cells", &icells, 4) != 4) + goto nomap; + + /* Found. */ + if (match == 0) { + bcopy(mp, intr, icells * 4); + return (icells * 4); + } + + mp += icells; + len -= icells * 4; + } + +nomap: + /* + * Check for local properties indicating interrupts + */ + + len = OF_getprop(node, "interrupts", intr, 16); + if (OF_getprop(node, "interrupt-parent", &iparent, sizeof(iparent)) == + sizeof(iparent)) { + OF_getprop(iparent, "#interrupt-cells", &icells, sizeof(icells)); + for (i = 0; i < len/icells/4; i++) + intr[i] = intr[i*icells]; + + return (len); + } + + + /* + * If the node has no interrupt property and the parent is a PCI + * bridge, use the parent's interrupt. This occurs on a PCI slot. + */ + bzero(name, sizeof(name)); + OF_getprop(parent, "name", name, sizeof(name)); + if (strcmp(name, "pci-bridge") == 0) { + len = OF_getprop(parent, "AAPL,interrupts", intr, 4); + if (len == 4) { + return (len); + } + + /* + * XXX I don't know what is the correct local address. + * XXX Use the first entry for now. + */ + len = OF_getprop(parent, "interrupt-map", map, sizeof(map)); + if (len >= 36) { + addr = &map[5]; + /* XXX Use 0 for 'interrupts' for compat */ + return (find_node_intr(parent, addr, intr)); + } + } + + return (-1); +} + |