diff options
| -rw-r--r-- | sys/arch/sparc64/dev/vpci.c | 449 |
1 files changed, 449 insertions, 0 deletions
diff --git a/sys/arch/sparc64/dev/vpci.c b/sys/arch/sparc64/dev/vpci.c new file mode 100644 index 00000000000..eb8853de193 --- /dev/null +++ b/sys/arch/sparc64/dev/vpci.c @@ -0,0 +1,449 @@ +/* $OpenBSD: vpci.c,v 1.1 2008/03/09 18:58:11 kettenis Exp $ */ +/* + * Copyright (c) 2008 Mark Kettenis <kettenis@openbsd.org> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/param.h> +#include <sys/device.h> +#include <sys/errno.h> +#include <sys/malloc.h> +#include <sys/systm.h> + +#include <uvm/uvm_extern.h> + +#define _SPARC_BUS_DMA_PRIVATE +#include <machine/bus.h> +#include <machine/autoconf.h> +#include <machine/hypervisor.h> +#include <machine/openfirm.h> + +#include <dev/pci/pcivar.h> +#include <dev/pci/pcireg.h> + +#include <sparc64/dev/viommuvar.h> + +extern struct sparc_pci_chipset _sparc_pci_chipset; + +struct vpci_range { + u_int32_t cspace; + u_int32_t child_hi; + u_int32_t child_lo; + u_int32_t phys_hi; + u_int32_t phys_lo; + u_int32_t size_hi; + u_int32_t size_lo; +}; + +struct vpci_pbm { + struct vpci_softc *vp_sc; + uint64_t vp_devhandle; + + struct vpci_range *vp_range; + pci_chipset_tag_t vp_pc; + int vp_nrange; + + bus_space_tag_t vp_memt; + bus_space_tag_t vp_iot; + bus_dma_tag_t vp_dmat; + struct iommu_state vp_is; +}; + +struct vpci_softc { + struct device sc_dv; + bus_dma_tag_t sc_dmat; + bus_space_tag_t sc_bust; +}; + +int vpci_match(struct device *, void *, void *); +void vpci_attach(struct device *, struct device *, void *); +void vpci_init_iommu(struct vpci_softc *, struct vpci_pbm *); +int vpci_print(void *, const char *); + +pci_chipset_tag_t vpci_alloc_chipset(struct vpci_pbm *, int, + pci_chipset_tag_t); +bus_space_tag_t vpci_alloc_mem_tag(struct vpci_pbm *); +bus_space_tag_t vpci_alloc_io_tag(struct vpci_pbm *); +bus_space_tag_t vpci_alloc_bus_tag(struct vpci_pbm *, const char *, + int, int, int); +bus_dma_tag_t vpci_alloc_dma_tag(struct vpci_pbm *); + +pcireg_t vpci_conf_read(pci_chipset_tag_t, pcitag_t, int); +void vpci_conf_write(pci_chipset_tag_t, pcitag_t, int, pcireg_t); + +int vpci_intr_map(struct pci_attach_args *, pci_intr_handle_t *); +int vpci_bus_map(bus_space_tag_t, bus_space_tag_t, bus_addr_t, + bus_size_t, int, bus_space_handle_t *); +paddr_t vpci_bus_mmap(bus_space_tag_t, bus_space_tag_t, bus_addr_t, off_t, + int, int); +void *vpci_intr_establish(bus_space_tag_t, bus_space_tag_t, int, int, int, + int (*)(void *), void *, const char *); +void vpci_intr_ack(struct intrhand *); + +int vpci_dmamap_create(bus_dma_tag_t, bus_dma_tag_t, bus_size_t, int, + bus_size_t, bus_size_t, int, bus_dmamap_t *); +void vpci_dmamap_destroy(bus_dma_tag_t, bus_dma_tag_t, bus_dmamap_t); +int vpci_dmamap_load(bus_dma_tag_t, bus_dma_tag_t, bus_dmamap_t, + void *, bus_size_t, struct proc *, int); +void vpci_dmamap_unload(bus_dma_tag_t, bus_dma_tag_t, bus_dmamap_t); +int vpci_dmamem_alloc(bus_dma_tag_t, bus_dma_tag_t, bus_size_t, + bus_size_t, bus_size_t, bus_dma_segment_t *, int, int *, int); +int vpci_dmamem_map(bus_dma_tag_t, bus_dma_tag_t, bus_dma_segment_t *, + int, size_t, caddr_t *, int); +void vpci_dmamem_unmap(bus_dma_tag_t, bus_dma_tag_t, caddr_t, size_t); + +int +vpci_match(struct device *parent, void *match, void *aux) +{ + struct mainbus_attach_args *ma = aux; + char compat[32]; + + if (strcmp(ma->ma_name, "pci") != 0) + return (0); + + if (OF_getprop(ma->ma_node, "compatible", compat, sizeof(compat)) == -1) + return (0); + + if (strcmp(compat, "SUNW,sun4v-pci") == 0) + return (1); + + return (0); +} + +void +vpci_attach(struct device *parent, struct device *self, void *aux) +{ + struct vpci_softc *sc = (struct vpci_softc *)self; + struct mainbus_attach_args *ma = aux; + struct pcibus_attach_args pba; + struct vpci_pbm *pbm; + int *busranges = NULL, nranges; + + sc->sc_dmat = ma->ma_dmatag; + sc->sc_bust = ma->ma_bustag; + + pbm = malloc(sizeof(*pbm), M_DEVBUF, M_NOWAIT | M_ZERO); + if (pbm == NULL) + panic("vpci: can't alloc vpci pbm"); + + pbm->vp_sc = sc; + pbm->vp_devhandle = (ma->ma_reg[0].ur_paddr >> 32) & 0x0fffffff; + + if (getprop(ma->ma_node, "ranges", sizeof(struct vpci_range), + &pbm->vp_nrange, (void **)&pbm->vp_range)) + panic("vpci: can't get ranges"); + + if (getprop(ma->ma_node, "bus-range", sizeof(int), &nranges, + (void **)&busranges)) + panic("vpci: can't get bus-range"); + + printf(": bus %d to %d, ", busranges[0], busranges[1]); + + pbm->vp_memt = vpci_alloc_mem_tag(pbm); + pbm->vp_iot = vpci_alloc_io_tag(pbm); + pbm->vp_dmat = vpci_alloc_dma_tag(pbm); + + pbm->vp_pc = vpci_alloc_chipset(pbm, ma->ma_node, &_sparc_pci_chipset); + pbm->vp_pc->bustag = pbm->vp_memt; + + vpci_init_iommu(sc, pbm); + + pba.pba_busname = "pci"; + pba.pba_domain = pci_ndomains++; + pba.pba_bus = busranges[0]; + pba.pba_bridgetag = NULL; + pba.pba_pc = pbm->vp_pc; + pba.pba_dmat = pbm->vp_dmat; + pba.pba_memt = pbm->vp_memt; + pba.pba_iot = pbm->vp_iot; + pba.pba_pc->conf_read = vpci_conf_read; + pba.pba_pc->conf_write = vpci_conf_write; + pba.pba_pc->intr_map = vpci_intr_map; + + free(busranges, M_DEVBUF); + + config_found(&sc->sc_dv, &pba, vpci_print); +} + +void +vpci_init_iommu(struct vpci_softc *sc, struct vpci_pbm *pbm) +{ + struct iommu_state *is = &pbm->vp_is; + int tsbsize = 8; + u_int32_t iobase = 0x80000000; + char *name; + + name = (char *)malloc(32, M_DEVBUF, M_NOWAIT); + if (name == NULL) + panic("couldn't malloc iommu name"); + snprintf(name, 32, "%s dvma", sc->sc_dv.dv_xname); + + viommu_init(name, is, tsbsize, iobase); + is->is_devhandle = pbm->vp_devhandle; +} + +int +vpci_print(void *aux, const char *p) +{ + if (p == NULL) + return (UNCONF); + return (QUIET); +} + +pcireg_t +vpci_conf_read(pci_chipset_tag_t pc, pcitag_t tag, int reg) +{ + struct vpci_pbm *pbm = pc->cookie; + uint64_t error_flag, data; + + hv_pci_config_get(pbm->vp_devhandle, PCITAG_OFFSET(tag), reg, 4, + &error_flag, &data); + + return (error_flag ? (pcireg_t)~0 : data); +} + +void +vpci_conf_write(pci_chipset_tag_t pc, pcitag_t tag, int reg, pcireg_t data) +{ + struct vpci_pbm *pbm = pc->cookie; + uint64_t error_flag; + + hv_pci_config_put(pbm->vp_devhandle, PCITAG_OFFSET(tag), reg, 4, + data, &error_flag); +} + +/* + * Bus-specific interrupt mapping + */ +int +vpci_intr_map(struct pci_attach_args *pa, pci_intr_handle_t *ihp) +{ + struct vpci_pbm *pbm = pa->pa_pc->cookie; + uint64_t devhandle = pbm->vp_devhandle; + uint64_t devino = INTINO(*ihp); + uint64_t sysino; + int err; + + if (*ihp != (pci_intr_handle_t)-1) { + err = hv_intr_devino_to_sysino(devhandle, devino, &sysino); + if (err != H_EOK) + return (-1); + + KASSERT(sysino == INTVEC(sysino)); + *ihp = sysino; + return (0); + } + + return (-1); +} + +bus_space_tag_t +vpci_alloc_mem_tag(struct vpci_pbm *pp) +{ + return (vpci_alloc_bus_tag(pp, "mem", + 0x02, /* 32-bit mem space (where's the #define???) */ + ASI_PRIMARY, ASI_PRIMARY_LITTLE)); +} + +bus_space_tag_t +vpci_alloc_io_tag(struct vpci_pbm *pp) +{ + return (vpci_alloc_bus_tag(pp, "io", + 0x01, /* IO space (where's the #define???) */ + ASI_PHYS_NON_CACHED_LITTLE, ASI_PHYS_NON_CACHED)); +} + +bus_space_tag_t +vpci_alloc_bus_tag(struct vpci_pbm *pbm, const char *name, int ss, + int asi, int sasi) +{ + struct vpci_softc *sc = pbm->vp_sc; + struct sparc_bus_space_tag *bt; + + bt = malloc(sizeof(*bt), M_DEVBUF, M_NOWAIT | M_ZERO); + if (bt == NULL) + panic("vpci: could not allocate bus tag"); + + snprintf(bt->name, sizeof(bt->name), "%s-pbm_%s(%d/%2.2x)", + sc->sc_dv.dv_xname, name, ss, asi); + + bt->cookie = pbm; + bt->parent = sc->sc_bust; + bt->default_type = ss; + bt->asi = asi; + bt->sasi = sasi; + bt->sparc_bus_map = vpci_bus_map; + bt->sparc_bus_mmap = vpci_bus_mmap; + bt->sparc_intr_establish = vpci_intr_establish; + return (bt); +} + +bus_dma_tag_t +vpci_alloc_dma_tag(struct vpci_pbm *pbm) +{ + struct vpci_softc *sc = pbm->vp_sc; + bus_dma_tag_t dt, pdt = sc->sc_dmat; + + dt = malloc(sizeof(*dt), M_DEVBUF, M_NOWAIT | M_ZERO); + if (dt == NULL) + panic("vpci: could not alloc dma tag"); + + dt->_cookie = pbm; + dt->_parent = pdt; + dt->_dmamap_create = vpci_dmamap_create; + dt->_dmamap_destroy = viommu_dvmamap_destroy; + dt->_dmamap_load = viommu_dvmamap_load; + dt->_dmamap_load_raw = viommu_dvmamap_load_raw; + dt->_dmamap_unload = viommu_dvmamap_unload; + dt->_dmamap_sync = viommu_dvmamap_sync; + dt->_dmamem_alloc = viommu_dvmamem_alloc; + dt->_dmamem_free = viommu_dvmamem_free; + dt->_dmamem_map = viommu_dvmamem_map; + dt->_dmamem_unmap = viommu_dvmamem_unmap; + return (dt); +} + +pci_chipset_tag_t +vpci_alloc_chipset(struct vpci_pbm *pbm, int node, pci_chipset_tag_t pc) +{ + pci_chipset_tag_t npc; + + npc = malloc(sizeof *npc, M_DEVBUF, M_NOWAIT); + if (npc == NULL) + panic("vpci: could not allocate pci_chipset_tag_t"); + memcpy(npc, pc, sizeof *pc); + npc->cookie = pbm; + npc->rootnode = node; + return (npc); +} + +#define BUS_DMA_FIND_PARENT(t, fn) \ + if (t->_parent == NULL) \ + panic("null bus_dma parent (" #fn ")"); \ + for (t = t->_parent; t->fn == NULL; t = t->_parent) \ + if (t->_parent == NULL) \ + panic("no bus_dma " #fn " located"); + +int +vpci_dmamap_create(bus_dma_tag_t t, bus_dma_tag_t t0, bus_size_t size, + int nsegments, bus_size_t maxsegsz, bus_size_t boundary, int flags, + bus_dmamap_t *dmamap) +{ + struct vpci_pbm *vp = t->_cookie; + + return (viommu_dvmamap_create(t, t0, &vp->vp_is, size, nsegments, + maxsegsz, boundary, flags, dmamap)); +} + +int +vpci_bus_map(bus_space_tag_t t, bus_space_tag_t t0, bus_addr_t offset, + bus_size_t size, int flags, bus_space_handle_t *hp) +{ + struct vpci_pbm *pbm = t->cookie; + int i, ss = t->default_type; + + if (t->parent == 0 || t->parent->sparc_bus_map == 0) + panic("vpci_bus_map: invalid parent"); + + if (flags & BUS_SPACE_MAP_PROMADDRESS) { + return ((*t->parent->sparc_bus_map) + (t, t0, offset, size, flags, hp)); + } + + for (i = 0; i < pbm->vp_nrange; i++) { + bus_addr_t paddr; + + if (((pbm->vp_range[i].cspace >> 24) & 0x03) != ss) + continue; + + paddr = pbm->vp_range[i].phys_lo + offset; + paddr |= ((bus_addr_t)pbm->vp_range[i].phys_hi) << 32; + return ((*t->parent->sparc_bus_map) + (t, t0, paddr, size, flags, hp)); + } + + return (EINVAL); +} + +paddr_t +vpci_bus_mmap(bus_space_tag_t t, bus_space_tag_t t0, bus_addr_t paddr, + off_t off, int prot, int flags) +{ + bus_addr_t offset = paddr; + struct vpci_pbm *pbm = t->cookie; + int i, ss = t->default_type; + + if (t->parent == 0 || t->parent->sparc_bus_mmap == 0) + panic("vpci_bus_mmap: invalid parent"); + + for (i = 0; i < pbm->vp_nrange; i++) { + bus_addr_t paddr; + + if (((pbm->vp_range[i].cspace >> 24) & 0x03) != ss) + continue; + + paddr = pbm->vp_range[i].phys_lo + offset; + paddr |= ((bus_addr_t)pbm->vp_range[i].phys_hi<<32); + return ((*t->parent->sparc_bus_mmap) + (t, t0, paddr, off, prot, flags)); + } + + return (-1); +} + +void * +vpci_intr_establish(bus_space_tag_t t, bus_space_tag_t t0, int ihandle, + int level, int flags, int (*handler)(void *), void *arg, const char *what) +{ + uint64_t sysino = INTVEC(ihandle); + struct intrhand *ih; + int err; + + ih = bus_intr_allocate(t0, handler, arg, ihandle, level, + NULL, NULL, what); + if (ih == NULL) + return (NULL); + + intr_establish(ih->ih_pil, ih); + ih->ih_ack = vpci_intr_ack; + + err = hv_intr_settarget(sysino, cpus->ci_upaid); + if (err != H_EOK) + return (NULL); + + /* Clear pending interrupts. */ + err = hv_intr_setstate(sysino, INTR_IDLE); + if (err != H_EOK) + return (NULL); + + err = hv_intr_setenabled(sysino, INTR_ENABLED); + if (err != H_EOK) + return (NULL); + + return (ih); +} + +void +vpci_intr_ack(struct intrhand *ih) +{ + hv_intr_setstate(ih->ih_number, INTR_IDLE); +} + +const struct cfattach vpci_ca = { + sizeof(struct vpci_softc), vpci_match, vpci_attach +}; + +struct cfdriver vpci_cd = { + NULL, "vpci", DV_DULL +}; |