27c27
< __FBSDID("$FreeBSD: head/sys/powerpc/powermac/uninorthpci.c 227843 2011-11-22 21:28:20Z marius $");
---
> __FBSDID("$FreeBSD: head/sys/powerpc/powermac/uninorthpci.c 230993 2012-02-04 19:54:13Z nwhitehorn $");
51a52
> #include <powerpc/ofw/ofw_pci.h>
68,78d68
< * Bus interface.
< */
< static int uninorth_read_ivar(device_t, device_t, int,
< uintptr_t *);
< static struct resource * uninorth_alloc_resource(device_t bus,
< device_t child, int type, int *rid, u_long start,
< u_long end, u_long count, u_int flags);
< static int uninorth_activate_resource(device_t bus, device_t child,
< int type, int rid, struct resource *res);
<
< /*
81d70
< static int uninorth_maxslots(device_t);
86d74
< static int uninorth_route_interrupt(device_t, device_t, int);
89,94d76
< * OFW Bus interface
< */
<
< static phandle_t uninorth_get_node(device_t bus, device_t dev);
<
< /*
108,114d89
< /* Bus interface */
< DEVMETHOD(bus_read_ivar, uninorth_read_ivar),
< DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
< DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
< DEVMETHOD(bus_alloc_resource, uninorth_alloc_resource),
< DEVMETHOD(bus_activate_resource, uninorth_activate_resource),
<
116d90
< DEVMETHOD(pcib_maxslots, uninorth_maxslots),
119d92
< DEVMETHOD(pcib_route_interrupt, uninorth_route_interrupt),
121,123d93
< /* ofw_bus interface */
< DEVMETHOD(ofw_bus_get_node, uninorth_get_node),
<
127,132d96
< static driver_t uninorth_driver = {
< "pcib",
< uninorth_methods,
< sizeof(struct uninorth_softc)
< };
<
134a99,100
> DEFINE_CLASS_1(pcib, uninorth_driver, uninorth_methods,
> sizeof(struct uninorth_softc), ofw_pci_driver);
171,173c137
< u_int32_t reg[3], busrange[2];
< struct uninorth_range *rp, *io, *mem[2];
< int nmem, i, error;
---
> u_int32_t reg[3];
181,183d144
< if (OF_getprop(node, "bus-range", busrange, sizeof(busrange)) != 8)
< return (ENXIO);
<
191,192d151
< sc->sc_dev = dev;
< sc->sc_node = node;
200d158
< sc->sc_bus = busrange[0];
202,294c160
< bzero(sc->sc_range, sizeof(sc->sc_range));
< if (sc->sc_ver >= 3) {
< /*
< * On Apple U3 systems, we have an otherwise standard
< * Uninorth controller driving AGP. The one difference
< * is that it uses a new PCI ranges format, so do the
< * translation.
< */
<
< struct uninorth_range64 range64[6];
< bzero(range64, sizeof(range64));
<
< sc->sc_nrange = OF_getprop(node, "ranges", range64,
< sizeof(range64));
< for (i = 0; range64[i].pci_hi != 0; i++) {
< sc->sc_range[i].pci_hi = range64[i].pci_hi;
< sc->sc_range[i].pci_mid = range64[i].pci_mid;
< sc->sc_range[i].pci_lo = range64[i].pci_lo;
< sc->sc_range[i].host = range64[i].host_lo;
< sc->sc_range[i].size_hi = range64[i].size_hi;
< sc->sc_range[i].size_lo = range64[i].size_lo;
< }
< } else {
< sc->sc_nrange = OF_getprop(node, "ranges", sc->sc_range,
< sizeof(sc->sc_range));
< }
<
< if (sc->sc_nrange == -1) {
< device_printf(dev, "could not get ranges\n");
< return (ENXIO);
< }
<
< sc->sc_nrange /= sizeof(sc->sc_range[0]);
<
< sc->sc_range[6].pci_hi = 0;
< io = NULL;
< nmem = 0;
<
< for (rp = sc->sc_range; rp < sc->sc_range + sc->sc_nrange &&
< rp->pci_hi != 0; rp++) {
< switch (rp->pci_hi & OFW_PCI_PHYS_HI_SPACEMASK) {
< case OFW_PCI_PHYS_HI_SPACE_CONFIG:
< break;
< case OFW_PCI_PHYS_HI_SPACE_IO:
< io = rp;
< break;
< case OFW_PCI_PHYS_HI_SPACE_MEM32:
< mem[nmem] = rp;
< nmem++;
< break;
< case OFW_PCI_PHYS_HI_SPACE_MEM64:
< break;
< }
< }
<
< if (io == NULL) {
< device_printf(dev, "can't find io range\n");
< return (ENXIO);
< }
< sc->sc_io_rman.rm_type = RMAN_ARRAY;
< sc->sc_io_rman.rm_descr = "UniNorth PCI I/O Ports";
< sc->sc_iostart = io->host;
< if (rman_init(&sc->sc_io_rman) != 0 ||
< rman_manage_region(&sc->sc_io_rman, io->pci_lo,
< io->pci_lo + io->size_lo - 1) != 0) {
< panic("uninorth_attach: failed to set up I/O rman");
< }
<
< if (nmem == 0) {
< device_printf(dev, "can't find mem ranges\n");
< return (ENXIO);
< }
< sc->sc_mem_rman.rm_type = RMAN_ARRAY;
< sc->sc_mem_rman.rm_descr = "UniNorth PCI Memory";
< error = rman_init(&sc->sc_mem_rman);
< if (error) {
< device_printf(dev, "rman_init() failed. error = %d\n", error);
< return (error);
< }
< for (i = 0; i < nmem; i++) {
< error = rman_manage_region(&sc->sc_mem_rman, mem[i]->pci_lo,
< mem[i]->pci_lo + mem[i]->size_lo - 1);
< if (error) {
< device_printf(dev,
< "rman_manage_region() failed. error = %d\n", error);
< return (error);
< }
< }
<
< ofw_bus_setup_iinfo(node, &sc->sc_pci_iinfo, sizeof(cell_t));
<
< device_add_child(dev, "pci", device_get_unit(dev));
< return (bus_generic_attach(dev));
---
> return (ofw_pci_attach(dev));
297,303d162
< static int
< uninorth_maxslots(device_t dev)
< {
<
< return (PCI_SLOTMAX);
< }
<
357,493d215
< uninorth_route_interrupt(device_t bus, device_t dev, int pin)
< {
< struct uninorth_softc *sc;
< struct ofw_pci_register reg;
< uint32_t pintr, mintr;
< phandle_t iparent;
< uint8_t maskbuf[sizeof(reg) + sizeof(pintr)];
<
< sc = device_get_softc(bus);
< pintr = pin;
< if (ofw_bus_lookup_imap(ofw_bus_get_node(dev), &sc->sc_pci_iinfo, &reg,
< sizeof(reg), &pintr, sizeof(pintr), &mintr, sizeof(mintr),
< &iparent, maskbuf))
< return (MAP_IRQ(iparent, mintr));
<
< /* Maybe it's a real interrupt, not an intpin */
< if (pin > 4)
< return (pin);
<
< device_printf(bus, "could not route pin %d for device %d.%d\n",
< pin, pci_get_slot(dev), pci_get_function(dev));
< return (PCI_INVALID_IRQ);
< }
<
< static int
< uninorth_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
< {
< struct uninorth_softc *sc;
<
< sc = device_get_softc(dev);
<
< switch (which) {
< case PCIB_IVAR_DOMAIN:
< *result = device_get_unit(dev);
< return (0);
< case PCIB_IVAR_BUS:
< *result = sc->sc_bus;
< return (0);
< }
<
< return (ENOENT);
< }
<
< static struct resource *
< uninorth_alloc_resource(device_t bus, device_t child, int type, int *rid,
< u_long start, u_long end, u_long count, u_int flags)
< {
< struct uninorth_softc *sc;
< struct resource *rv;
< struct rman *rm;
< int needactivate;
<
< needactivate = flags & RF_ACTIVE;
< flags &= ~RF_ACTIVE;
<
< sc = device_get_softc(bus);
<
< switch (type) {
< case SYS_RES_MEMORY:
< rm = &sc->sc_mem_rman;
< break;
<
< case SYS_RES_IOPORT:
< rm = &sc->sc_io_rman;
< break;
<
< case SYS_RES_IRQ:
< return (bus_alloc_resource(bus, type, rid, start, end, count,
< flags));
<
< default:
< device_printf(bus, "unknown resource request from %s\n",
< device_get_nameunit(child));
< return (NULL);
< }
<
< rv = rman_reserve_resource(rm, start, end, count, flags, child);
< if (rv == NULL) {
< device_printf(bus, "failed to reserve resource for %s\n",
< device_get_nameunit(child));
< return (NULL);
< }
<
< rman_set_rid(rv, *rid);
<
< if (needactivate) {
< if (bus_activate_resource(child, type, *rid, rv) != 0) {
< device_printf(bus,
< "failed to activate resource for %s\n",
< device_get_nameunit(child));
< rman_release_resource(rv);
< return (NULL);
< }
< }
<
< return (rv);
< }
<
< static int
< uninorth_activate_resource(device_t bus, device_t child, int type, int rid,
< struct resource *res)
< {
< void *p;
< struct uninorth_softc *sc;
<
< sc = device_get_softc(bus);
<
< if (type == SYS_RES_IRQ)
< return (bus_activate_resource(bus, type, rid, res));
<
< if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
< vm_offset_t start;
<
< start = (vm_offset_t)rman_get_start(res);
< /*
< * For i/o-ports, convert the start address to the
< * uninorth PCI i/o window
< */
< if (type == SYS_RES_IOPORT)
< start += sc->sc_iostart;
<
< if (bootverbose)
< printf("uninorth mapdev: start %zx, len %ld\n", start,
< rman_get_size(res));
<
< p = pmap_mapdev(start, (vm_size_t)rman_get_size(res));
< if (p == NULL)
< return (ENOMEM);
< rman_set_virtual(res, p);
< rman_set_bustag(res, &bs_le_tag);
< rman_set_bushandle(res, (u_long)p);
< }
<
< return (rman_activate_resource(res));
< }
<
< static int
500,501c222,223
< if (resource_int_value(device_get_name(sc->sc_dev),
< device_get_unit(sc->sc_dev), "skipslot", &pass) == 0) {
---
> if (resource_int_value(device_get_name(sc->pci_sc.sc_dev),
> device_get_unit(sc->pci_sc.sc_dev), "skipslot", &pass) == 0) {
513c235
< if (sc->sc_bus == bus && sc->sc_ver < 4) {
---
> if (sc->pci_sc.sc_bus == bus && sc->sc_ver < 4) {
537,547d258
< static phandle_t
< uninorth_get_node(device_t bus, device_t dev)
< {
< struct uninorth_softc *sc;
<
< sc = device_get_softc(bus);
< /* We only have one child, the PCI bus, which needs our own node. */
<
< return sc->sc_node;
< }
<