/*      $NetBSD: ebus.c,v 1.69 2022/01/22 11:49:17 thorpej Exp $        */

/*
* Copyright (c) 1999, 2000, 2001 Matthew R. Green
* 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, 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>
__KERNEL_RCSID(0, "$NetBSD: ebus.c,v 1.69 2022/01/22 11:49:17 thorpej Exp $");

#include "opt_ddb.h"

/*
* UltraSPARC 5 and beyond ebus support.
*
* note that this driver is not complete:
*      - interrupt establish is written and appears to work
*      - bus map code is written and appears to work
*      - ebus2 DMA code is completely unwritten, we just punt to
*        the iommu.
*/

#ifdef DEBUG
#define EDB_PROM        0x01
#define EDB_CHILD       0x02
#define EDB_INTRMAP     0x04
#define EDB_BUSMAP      0x08
#define EDB_BUSDMA      0x10
#define EDB_INTR        0x20
int ebus_debug = 0x0;
#define DPRINTF(l, s)   do { if (ebus_debug & l) printf s; } while (0)
#else
#define DPRINTF(l, s)
#endif

#include <sys/param.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/errno.h>
#include <sys/extent.h>
#include <sys/malloc.h>
#include <sys/kmem.h>
#include <sys/systm.h>
#include <sys/time.h>

#define _SPARC_BUS_DMA_PRIVATE
#include <sys/bus.h>
#include <machine/autoconf.h>
#include <machine/openfirm.h>

#include <dev/pci/pcivar.h>
#include <dev/pci/pcireg.h>
#include <dev/pci/pcidevs.h>

#include <dev/ebus/ebusreg.h>
#include <dev/ebus/ebusvar.h>
#include <sparc64/dev/ebusvar.h>

int     ebus_match(device_t, cfdata_t, void *);
void    ebus_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(ebus, sizeof(struct ebus_softc),
   ebus_match, ebus_attach, NULL, NULL);

/*
* here are our bus space and bus DMA routines.
*/
static int _ebus_bus_map(bus_space_tag_t, bus_addr_t, bus_size_t, int, vaddr_t,
       bus_space_handle_t *);
static void *ebus_intr_establish(bus_space_tag_t, int, int, int (*)(void *),
       void *, void(*)(void));

int
ebus_match(device_t parent, cfdata_t match, void *aux)
{
       struct pci_attach_args *pa = aux;
       char *name;
       int node;

       /* Only attach if there's a PROM node. */
       node = PCITAG_NODE(pa->pa_tag);
       if (node == -1)
               return (0);

       if (PCI_CLASS(pa->pa_class) != PCI_CLASS_BRIDGE)
               return (0);

       /* Match a real ebus */
       name = prom_getpropstring(node, "name");
       if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_SUN &&
           PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_SUN_EBUS &&
               strcmp(name, "ebus") == 0)
               return (1);

       /* Or a real ebus III */
       if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_SUN &&
           PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_SUN_EBUSIII &&
               strcmp(name, "ebus") == 0)
               return (1);

       /* Or a PCI-ISA bridge XXX I hope this is on-board. */
       if (PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_BRIDGE_ISA) {
               return (1);
       }

       /* Or the Altera bridge on SPARCle */
       if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_ALTERA &&
           PCI_PRODUCT(pa->pa_id) == 0 &&
               strcmp(name, "ebus") == 0)
               return (1);

       return (0);
}

/*
* attach an ebus and all its children.  this code is modeled
* after the sbus code which does similar things.
*/
void
ebus_attach(device_t parent, device_t self, void *aux)
{
       struct ebus_softc *sc = device_private(self);
       struct pci_attach_args *pa = aux;
       struct ebus_attach_args eba;
       struct ebus_interrupt_map_mask *immp;
       int node, nmapmask, error;
       char devinfo[256];

       sc->sc_dev = self;

       aprint_naive("\n");

       pci_devinfo(pa->pa_id, pa->pa_class, 0, devinfo, sizeof(devinfo));
       aprint_normal(": %s, revision 0x%02x\n", devinfo,
           PCI_REVISION(pa->pa_class));

       sc->sc_memtag = pa->pa_memt;
       sc->sc_iotag = pa->pa_iot;
       sc->sc_childbustag = ebus_alloc_bus_tag(sc, PCI_MEMORY_BUS_SPACE);
       sc->sc_dmatag = pa->pa_dmat;

       node = PCITAG_NODE(pa->pa_tag);
       if (node == -1)
               panic("could not find ebus node");

       sc->sc_node = node;

       /*
        * fill in our softc with information from the prom
        */
       sc->sc_intmap = NULL;
       sc->sc_range = NULL;
       sc->sc_nintmap = 0;
       error = prom_getprop(node, "interrupt-map",
                       sizeof(struct ebus_interrupt_map),
                       &sc->sc_nintmap, &sc->sc_intmap);
       switch (error) {
       case 0:
               immp = &sc->sc_intmapmask;
               nmapmask = sizeof(*immp);
               error = prom_getprop(node, "interrupt-map-mask",
                           sizeof(struct ebus_interrupt_map_mask), &nmapmask,
                           &immp);
               if (error)
                       panic("could not get ebus interrupt-map-mask, error %d",
                           error);
               if (nmapmask != 1)
                       panic("ebus interrupt-map-mask is broken");
               break;
       case ENOENT:
               break;
       default:
               panic("ebus interrupt-map: error %d", error);
               break;
       }

       error = prom_getprop(node, "ranges", sizeof(struct ebus_ranges),
           &sc->sc_nrange, &sc->sc_range);
       if (error)
               panic("ebus ranges: error %d", error);

       /*
        * now attach all our children
        */
       DPRINTF(EDB_CHILD, ("ebus node %08x, searching children...\n", node));
       devhandle_t selfh = device_handle(self);
       for (node = firstchild(node); node; node = nextsibling(node)) {
               char *name = prom_getpropstring(node, "name");

               if (ebus_setup_attach_args(sc, node, &eba) != 0) {
                       aprint_error("ebus_attach: %s: incomplete\n", name);
                       continue;
               } else {
                       DPRINTF(EDB_CHILD, ("- found child `%s', attaching\n",
                           eba.ea_name));
                       (void)config_found(self, &eba, ebus_print,
                           CFARGS(.devhandle = prom_node_to_devhandle(selfh,
                                                                      node)));
               }
               ebus_destroy_attach_args(&eba);
       }
}

int     ebus_setup_attach_args(struct ebus_softc *, int,
           struct ebus_attach_args *);
int
ebus_setup_attach_args(struct ebus_softc *sc, int node,
       struct ebus_attach_args *ea)
{
       int     n, rv;

       memset(ea, 0, sizeof(struct ebus_attach_args));
       n = 0;
       rv = prom_getprop(node, "name", 1, &n, &ea->ea_name);
       if (rv != 0)
               return (rv);
       KASSERT(ea->ea_name[n-1] == '\0');

       ea->ea_node = node;
       ea->ea_bustag = sc->sc_childbustag;
       ea->ea_dmatag = sc->sc_dmatag;

       rv = prom_getprop(node, "reg", sizeof(struct ebus_regs), &ea->ea_nreg,
           &ea->ea_reg);
       if (rv)
               return (rv);

       rv = prom_getprop(node, "address", sizeof(uint32_t), &ea->ea_nvaddr,
           &ea->ea_vaddr);
       if (rv != ENOENT) {
               if (rv)
                       return (rv);

               if (ea->ea_nreg != ea->ea_nvaddr)
                       printf("ebus loses: device %s: %d regs and %d addrs\n",
                           ea->ea_name, ea->ea_nreg, ea->ea_nvaddr);
       } else
               ea->ea_nvaddr = 0;

       if (prom_getprop(node, "interrupts", sizeof(uint32_t), &ea->ea_nintr,
           &ea->ea_intr))
               ea->ea_nintr = 0;
       else
               ebus_find_ino(sc, ea);

       return (0);
}

void
ebus_destroy_attach_args(struct ebus_attach_args *ea)
{

       if (ea->ea_name)
               free((void *)ea->ea_name, M_DEVBUF);
       if (ea->ea_reg)
               free((void *)ea->ea_reg, M_DEVBUF);
       if (ea->ea_intr)
               free((void *)ea->ea_intr, M_DEVBUF);
       if (ea->ea_vaddr)
               free((void *)ea->ea_vaddr, M_DEVBUF);
}

int
ebus_print(void *aux, const char *p)
{
       struct ebus_attach_args *ea = aux;
       int i;

       if (p)
               aprint_normal("%s at %s", ea->ea_name, p);
       for (i = 0; i < ea->ea_nreg; i++)
               aprint_normal("%s %x-%x", i == 0 ? " addr" : ",",
                   ea->ea_reg[i].lo,
                   ea->ea_reg[i].lo + ea->ea_reg[i].size - 1);
       for (i = 0; i < ea->ea_nintr; i++)
               aprint_normal(" ipl %x", ea->ea_intr[i]);
       return (UNCONF);
}


/*
* find the INO values for each interrupt and fill them in.
*
* for each "reg" property of this device, mask its hi and lo
* values with the "interrupt-map-mask"'s hi/lo values, and also
* mask the interrupt number with the interrupt mask.  search the
* "interrupt-map" list for matching values of hi, lo and interrupt
* to give the INO for this interrupt.
*/
void
ebus_find_ino(struct ebus_softc *sc, struct ebus_attach_args *ea)
{
       uint32_t hi, lo, intr;
       int i, j, k;

       if (sc->sc_nintmap == 0) {
               for (i = 0; i < ea->ea_nintr; i++) {
                       OF_mapintr(ea->ea_node, &ea->ea_intr[i],
                               sizeof(ea->ea_intr[0]),
                               sizeof(ea->ea_intr[0]));
               }
               return;
       }

       DPRINTF(EDB_INTRMAP,
           ("ebus_find_ino: searching %d interrupts", ea->ea_nintr));

       for (j = 0; j < ea->ea_nintr; j++) {

               intr = ea->ea_intr[j] & sc->sc_intmapmask.intr;

               DPRINTF(EDB_INTRMAP,
                   ("; intr %x masked to %x", ea->ea_intr[j], intr));
               for (i = 0; i < ea->ea_nreg; i++) {
                       hi = ea->ea_reg[i].hi & sc->sc_intmapmask.hi;
                       lo = ea->ea_reg[i].lo & sc->sc_intmapmask.lo;

                       DPRINTF(EDB_INTRMAP,
                           ("; reg hi.lo %08x.%08x masked to %08x.%08x",
                           ea->ea_reg[i].hi, ea->ea_reg[i].lo, hi, lo));
                       for (k = 0; k < sc->sc_nintmap; k++) {
                               DPRINTF(EDB_INTRMAP,
                                   ("; checking hi.lo %08x.%08x intr %x",
                                   sc->sc_intmap[k].hi, sc->sc_intmap[k].lo,
                                   sc->sc_intmap[k].intr));
                               if (hi == sc->sc_intmap[k].hi &&
                                   lo == sc->sc_intmap[k].lo &&
                                   intr == sc->sc_intmap[k].intr) {
                                       ea->ea_intr[j] =
                                           sc->sc_intmap[k].cintr;
                                       DPRINTF(EDB_INTRMAP,
                                           ("; FOUND IT! changing to %d\n",
                                           sc->sc_intmap[k].cintr));
                                       goto next_intr;
                               }
                       }
               }
next_intr:;
       }
}

/*
* bus space support.  <sparc64/dev/psychoreg.h> has a discussion
* about PCI physical addresses, which also applies to ebus.
*/
bus_space_tag_t
ebus_alloc_bus_tag(struct ebus_softc *sc, int type)
{
       bus_space_tag_t bt;

       bt = kmem_zalloc(sizeof(*bt), KM_SLEEP);
       bt->cookie = sc;
       bt->parent = sc->sc_memtag;
       bt->type = type;
       bt->sparc_bus_map = _ebus_bus_map;
       bt->sparc_bus_mmap = ebus_bus_mmap;
       bt->sparc_intr_establish = ebus_intr_establish;
       return (bt);
}

static int
_ebus_bus_map(bus_space_tag_t t, bus_addr_t ba, bus_size_t size, int flags,
       vaddr_t va, bus_space_handle_t *hp)
{
       struct ebus_softc *sc = t->cookie;
       paddr_t offset;
       u_int bar;
       int i, ss;

       bar = BUS_ADDR_IOSPACE(ba);
       offset = BUS_ADDR_PADDR(ba);

       DPRINTF(EDB_BUSMAP,
               ("\n_ebus_bus_map: bar %d offset %08x sz %x flags %x va %p\n",
                (int)bar, (uint32_t)offset, (uint32_t)size,
                flags, (void *)va));

       for (i = 0; i < sc->sc_nrange; i++) {
               bus_addr_t pciaddr;

               if (bar != sc->sc_range[i].child_hi)
                       continue;
               if (offset < sc->sc_range[i].child_lo ||
                   (offset + size) >
                     (sc->sc_range[i].child_lo + sc->sc_range[i].size))
                       continue;

               /* Isolate address space and find the right tag */
               ss = (sc->sc_range[i].phys_hi>>24)&3;
               switch (ss) {
               case 1: /* I/O space */
                       t = sc->sc_iotag;
                       break;
               case 2: /* Memory space */
                       t = sc->sc_memtag;
                       break;
               case 0: /* Config space */
               case 3: /* 64-bit Memory space */
               default: /* WTF? */
                       /* We don't handle these */
                       panic("_ebus_bus_map: illegal space %x", ss);
                       break;
               }
               pciaddr = ((bus_addr_t)sc->sc_range[i].phys_mid << 32UL) |
                                      sc->sc_range[i].phys_lo;
               pciaddr += offset;

               DPRINTF(EDB_BUSMAP,
                       ("_ebus_bus_map: mapping to PCI addr %x\n",
                        (uint32_t)pciaddr));

               /* pass it onto the psycho */
               return (bus_space_map(t, pciaddr, size, flags, hp));
       }
       DPRINTF(EDB_BUSMAP, (": FAILED\n"));
       return (EINVAL);
}

paddr_t
ebus_bus_mmap(bus_space_tag_t t, bus_addr_t paddr, off_t off, int prot,
       int flags)
{
       bus_addr_t offset = paddr;
       struct ebus_softc *sc = t->cookie;
       int i;

       for (i = 0; i < sc->sc_nrange; i++) {
               bus_addr_t paddr1 =
                   ((bus_addr_t)sc->sc_range[i].child_hi << 32) |
                   sc->sc_range[i].child_lo;

               if (offset != paddr1)
                       continue;

               DPRINTF(EDB_BUSMAP, ("\n_ebus_bus_mmap: mapping paddr %qx\n",
                   (unsigned long long)paddr1));
               return (bus_space_mmap(sc->sc_memtag, paddr1, off,
                                      prot, flags));
       }

       return (-1);
}

/*
* install an interrupt handler for a ebus device
*/
void *
ebus_intr_establish(bus_space_tag_t t, int pri, int level,
       int (*handler)(void *), void *arg, void (*fastvec)(void) /* ignored */)
{

       return (bus_intr_establish(t->parent, pri, level, handler, arg));
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.