summaryrefslogtreecommitdiffstats
path: root/sys/dev/mly/mly_pci.c
diff options
context:
space:
mode:
Diffstat (limited to 'sys/dev/mly/mly_pci.c')
-rw-r--r--sys/dev/mly/mly_pci.c590
1 files changed, 590 insertions, 0 deletions
diff --git a/sys/dev/mly/mly_pci.c b/sys/dev/mly/mly_pci.c
new file mode 100644
index 0000000..c0dbd45
--- /dev/null
+++ b/sys/dev/mly/mly_pci.c
@@ -0,0 +1,590 @@
+/*-
+ * Copyright (c) 2000 Michael Smith
+ * Copyright (c) 2000 BSDi
+ * 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
+ *
+ * $FreeBSD$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/malloc.h>
+#include <sys/kernel.h>
+
+#include <sys/bus.h>
+#include <sys/conf.h>
+#include <sys/devicestat.h>
+#include <sys/disk.h>
+
+#include <machine/bus_memio.h>
+#include <machine/bus.h>
+#include <machine/resource.h>
+#include <sys/rman.h>
+
+#include <pci/pcireg.h>
+#include <pci/pcivar.h>
+
+#include <dev/mly/mlyreg.h>
+#include <dev/mly/mlyvar.h>
+
+static int mly_pci_probe(device_t dev);
+static int mly_pci_attach(device_t dev);
+static int mly_pci_detach(device_t dev);
+static int mly_pci_shutdown(device_t dev);
+static int mly_pci_suspend(device_t dev);
+static int mly_pci_resume(device_t dev);
+static void mly_pci_intr(void *arg);
+
+static int mly_sg_map(struct mly_softc *sc);
+static void mly_sg_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error);
+static int mly_mmbox_map(struct mly_softc *sc);
+static void mly_mmbox_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error);
+static void mly_free_command_cluster(struct mly_command_cluster *mcc);
+
+static device_method_t mly_methods[] = {
+ /* Device interface */
+ DEVMETHOD(device_probe, mly_pci_probe),
+ DEVMETHOD(device_attach, mly_pci_attach),
+ DEVMETHOD(device_detach, mly_pci_detach),
+ DEVMETHOD(device_shutdown, mly_pci_shutdown),
+ DEVMETHOD(device_suspend, mly_pci_suspend),
+ DEVMETHOD(device_resume, mly_pci_resume),
+ { 0, 0 }
+};
+
+static driver_t mly_pci_driver = {
+ "mly",
+ mly_methods,
+ sizeof(struct mly_softc)
+};
+
+static devclass_t mly_devclass;
+DRIVER_MODULE(mly, pci, mly_pci_driver, mly_devclass, 0, 0);
+
+struct mly_ident
+{
+ u_int16_t vendor;
+ u_int16_t device;
+ u_int16_t subvendor;
+ u_int16_t subdevice;
+ int hwif;
+ char *desc;
+} mly_identifiers[] = {
+ {0x1069, 0xba56, 0x1069, 0x0040, MLY_HWIF_STRONGARM, "Mylex eXtremeRAID 2000"},
+ {0x1069, 0xba56, 0x1069, 0x0030, MLY_HWIF_STRONGARM, "Mylex eXtremeRAID 3000"},
+ {0x1069, 0x0050, 0x1069, 0x0050, MLY_HWIF_I960RX, "Mylex AcceleRAID 352"},
+ {0x1069, 0x0050, 0x1069, 0x0052, MLY_HWIF_I960RX, "Mylex AcceleRAID 170"},
+ {0x1069, 0x0050, 0x1069, 0x0054, MLY_HWIF_I960RX, "Mylex AcceleRAID 160"},
+ {0, 0, 0, 0, 0, 0}
+};
+
+/********************************************************************************
+ ********************************************************************************
+ Bus Interface
+ ********************************************************************************
+ ********************************************************************************/
+
+static int
+mly_pci_probe(device_t dev)
+{
+ struct mly_ident *m;
+
+ debug_called(1);
+
+ for (m = mly_identifiers; m->vendor != 0; m++) {
+ if ((m->vendor == pci_get_vendor(dev)) &&
+ (m->device == pci_get_device(dev)) &&
+ ((m->subvendor == 0) || ((m->subvendor == pci_get_subvendor(dev)) &&
+ (m->subdevice == pci_get_subdevice(dev))))) {
+
+ device_set_desc(dev, m->desc);
+ return(-10); /* allow room to be overridden */
+ }
+ }
+ return(ENXIO);
+}
+
+static int
+mly_pci_attach(device_t dev)
+{
+ struct mly_softc *sc;
+ int i, error;
+ u_int32_t command;
+
+ debug_called(1);
+
+ /*
+ * Initialise softc.
+ */
+ sc = device_get_softc(dev);
+ bzero(sc, sizeof(*sc));
+ sc->mly_dev = dev;
+
+#ifdef MLY_DEBUG
+ if (device_get_unit(sc->mly_dev) == 0)
+ mly_softc0 = sc;
+#endif
+
+ /* assume failure is 'not configured' */
+ error = ENXIO;
+
+ /*
+ * Verify that the adapter is correctly set up in PCI space.
+ */
+ command = pci_read_config(sc->mly_dev, PCIR_COMMAND, 2);
+ command |= PCIM_CMD_BUSMASTEREN;
+ pci_write_config(dev, PCIR_COMMAND, command, 2);
+ command = pci_read_config(sc->mly_dev, PCIR_COMMAND, 2);
+ if (!(command & PCIM_CMD_BUSMASTEREN)) {
+ mly_printf(sc, "can't enable busmaster feature\n");
+ goto fail;
+ }
+ if ((command & PCIM_CMD_MEMEN) == 0) {
+ mly_printf(sc, "memory window not available\n");
+ goto fail;
+ }
+
+ /*
+ * Allocate the PCI register window.
+ */
+ sc->mly_regs_rid = PCIR_MAPS; /* first base address register */
+ if ((sc->mly_regs_resource = bus_alloc_resource(sc->mly_dev, SYS_RES_MEMORY, &sc->mly_regs_rid,
+ 0, ~0, 1, RF_ACTIVE)) == NULL) {
+ mly_printf(sc, "can't allocate register window\n");
+ goto fail;
+ }
+ sc->mly_btag = rman_get_bustag(sc->mly_regs_resource);
+ sc->mly_bhandle = rman_get_bushandle(sc->mly_regs_resource);
+
+ /*
+ * Allocate and connect our interrupt.
+ */
+ sc->mly_irq_rid = 0;
+ if ((sc->mly_irq = bus_alloc_resource(sc->mly_dev, SYS_RES_IRQ, &sc->mly_irq_rid,
+ 0, ~0, 1, RF_SHAREABLE | RF_ACTIVE)) == NULL) {
+ mly_printf(sc, "can't allocate interrupt\n");
+ goto fail;
+ }
+ if (bus_setup_intr(sc->mly_dev, sc->mly_irq, INTR_TYPE_CAM, mly_pci_intr, sc, &sc->mly_intr)) {
+ mly_printf(sc, "can't set up interrupt\n");
+ goto fail;
+ }
+
+ /* assume failure is 'out of memory' */
+ error = ENOMEM;
+
+ /*
+ * Allocate the parent bus DMA tag appropriate for our PCI interface.
+ *
+ * Note that all of these controllers are 64-bit capable.
+ */
+ if (bus_dma_tag_create(NULL, /* parent */
+ 1, 0, /* alignment, boundary */
+ BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
+ BUS_SPACE_MAXADDR, /* highaddr */
+ NULL, NULL, /* filter, filterarg */
+ MAXBSIZE, MLY_MAXSGENTRIES, /* maxsize, nsegments */
+ BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
+ BUS_DMA_ALLOCNOW, /* flags */
+ &sc->mly_parent_dmat)) {
+ mly_printf(sc, "can't allocate parent DMA tag\n");
+ goto fail;
+ }
+
+ /*
+ * Create DMA tag for mapping buffers into controller-addressable space.
+ */
+ if (bus_dma_tag_create(sc->mly_parent_dmat, /* parent */
+ 1, 0, /* alignment, boundary */
+ BUS_SPACE_MAXADDR, /* lowaddr */
+ BUS_SPACE_MAXADDR, /* highaddr */
+ NULL, NULL, /* filter, filterarg */
+ MAXBSIZE, MLY_MAXSGENTRIES, /* maxsize, nsegments */
+ BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
+ 0, /* flags */
+ &sc->mly_buffer_dmat)) {
+ mly_printf(sc, "can't allocate buffer DMA tag\n");
+ goto fail;
+ }
+
+ /*
+ * Initialise the DMA tag for command packets.
+ */
+ if (bus_dma_tag_create(sc->mly_parent_dmat, /* parent */
+ 1, 0, /* alignment, boundary */
+ BUS_SPACE_MAXADDR, /* lowaddr */
+ BUS_SPACE_MAXADDR, /* highaddr */
+ NULL, NULL, /* filter, filterarg */
+ sizeof(union mly_command_packet) * MLY_CMD_CLUSTERCOUNT, 1, /* maxsize, nsegments */
+ BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
+ 0, /* flags */
+ &sc->mly_packet_dmat)) {
+ mly_printf(sc, "can't allocate command packet DMA tag\n");
+ goto fail;
+ }
+
+ /*
+ * Detect the hardware interface version
+ */
+ for (i = 0; mly_identifiers[i].vendor != 0; i++) {
+ if ((mly_identifiers[i].vendor == pci_get_vendor(dev)) &&
+ (mly_identifiers[i].device == pci_get_device(dev))) {
+ sc->mly_hwif = mly_identifiers[i].hwif;
+ switch(sc->mly_hwif) {
+ case MLY_HWIF_I960RX:
+ debug(2, "set hardware up for i960RX");
+ sc->mly_doorbell_true = 0x00;
+ sc->mly_command_mailbox = MLY_I960RX_COMMAND_MAILBOX;
+ sc->mly_status_mailbox = MLY_I960RX_STATUS_MAILBOX;
+ sc->mly_idbr = MLY_I960RX_IDBR;
+ sc->mly_odbr = MLY_I960RX_ODBR;
+ sc->mly_error_status = MLY_I960RX_ERROR_STATUS;
+ sc->mly_interrupt_status = MLY_I960RX_INTERRUPT_STATUS;
+ sc->mly_interrupt_mask = MLY_I960RX_INTERRUPT_MASK;
+ break;
+ case MLY_HWIF_STRONGARM:
+ debug(2, "set hardware up for StrongARM");
+ sc->mly_doorbell_true = 0xff; /* doorbell 'true' is 0 */
+ sc->mly_command_mailbox = MLY_STRONGARM_COMMAND_MAILBOX;
+ sc->mly_status_mailbox = MLY_STRONGARM_STATUS_MAILBOX;
+ sc->mly_idbr = MLY_STRONGARM_IDBR;
+ sc->mly_odbr = MLY_STRONGARM_ODBR;
+ sc->mly_error_status = MLY_STRONGARM_ERROR_STATUS;
+ sc->mly_interrupt_status = MLY_STRONGARM_INTERRUPT_STATUS;
+ sc->mly_interrupt_mask = MLY_STRONGARM_INTERRUPT_MASK;
+ break;
+ }
+ break;
+ }
+ }
+
+ /*
+ * Create the scatter/gather mappings.
+ */
+ if ((error = mly_sg_map(sc)))
+ goto fail;
+
+ /*
+ * Allocate and map the memory mailbox
+ */
+ if ((error = mly_mmbox_map(sc)))
+ goto fail;
+
+ /*
+ * Do bus-independent initialisation.
+ */
+ if ((error = mly_attach(sc)))
+ goto fail;
+
+ return(0);
+
+fail:
+ mly_free(sc);
+ return(error);
+}
+
+/********************************************************************************
+ * Disconnect from the controller completely, in preparation for unload.
+ */
+static int
+mly_pci_detach(device_t dev)
+{
+ struct mly_softc *sc = device_get_softc(dev);
+ int error;
+
+ debug_called(1);
+
+ if (sc->mly_state & MLY_STATE_OPEN)
+ return(EBUSY);
+
+ if ((error = mly_pci_shutdown(dev)))
+ return(error);
+
+ mly_free(sc);
+
+ return(0);
+}
+
+/********************************************************************************
+ * Bring the controller down to a dormant state and detach all child devices.
+ *
+ * This function is called before detach or system shutdown.
+ *
+ * Note that we can assume that the camq on the controller is empty, as we won't
+ * allow shutdown if any device is open.
+ */
+static int
+mly_pci_shutdown(device_t dev)
+{
+ struct mly_softc *sc = device_get_softc(dev);
+
+ debug_called(1);
+
+ mly_detach(sc);
+ return(0);
+}
+
+/********************************************************************************
+ * Bring the controller to a quiescent state, ready for system suspend.
+ *
+ * We can't assume that the controller is not active at this point, so we need
+ * to mask interrupts.
+ */
+static int
+mly_pci_suspend(device_t dev)
+{
+ struct mly_softc *sc = device_get_softc(dev);
+ int s;
+
+ debug_called(1);
+ s = splcam();
+ mly_detach(sc);
+ splx(s);
+ return(0);
+}
+
+/********************************************************************************
+ * Bring the controller back to a state ready for operation.
+ */
+static int
+mly_pci_resume(device_t dev)
+{
+ struct mly_softc *sc = device_get_softc(dev);
+
+ debug_called(1);
+ sc->mly_state &= ~MLY_STATE_SUSPEND;
+ MLY_UNMASK_INTERRUPTS(sc);
+ return(0);
+}
+
+/*******************************************************************************
+ * Take an interrupt, or be poked by other code to look for interrupt-worthy
+ * status.
+ */
+static void
+mly_pci_intr(void *arg)
+{
+ struct mly_softc *sc = (struct mly_softc *)arg;
+
+ debug_called(3);
+
+ /* collect finished commands, queue anything waiting */
+ mly_done(sc);
+};
+
+/********************************************************************************
+ ********************************************************************************
+ Bus-dependant Resource Management
+ ********************************************************************************
+ ********************************************************************************/
+
+/********************************************************************************
+ * Allocate memory for the scatter/gather tables
+ */
+static int
+mly_sg_map(struct mly_softc *sc)
+{
+ size_t segsize;
+
+ debug_called(1);
+
+ /*
+ * Create a single tag describing a region large enough to hold all of
+ * the s/g lists we will need.
+ */
+ segsize = sizeof(struct mly_sg_entry) * MLY_MAXCOMMANDS * MLY_MAXSGENTRIES;
+ if (bus_dma_tag_create(sc->mly_parent_dmat, /* parent */
+ 1, 0, /* alignment, boundary */
+ BUS_SPACE_MAXADDR, /* lowaddr */
+ BUS_SPACE_MAXADDR, /* highaddr */
+ NULL, NULL, /* filter, filterarg */
+ segsize, 1, /* maxsize, nsegments */
+ BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
+ 0, /* flags */
+ &sc->mly_sg_dmat)) {
+ mly_printf(sc, "can't allocate scatter/gather DMA tag\n");
+ return(ENOMEM);
+ }
+
+ /*
+ * Allocate enough s/g maps for all commands and permanently map them into
+ * controller-visible space.
+ *
+ * XXX this assumes we can get enough space for all the s/g maps in one
+ * contiguous slab.
+ */
+ if (bus_dmamem_alloc(sc->mly_sg_dmat, (void **)&sc->mly_sg_table, BUS_DMA_NOWAIT, &sc->mly_sg_dmamap)) {
+ mly_printf(sc, "can't allocate s/g table\n");
+ return(ENOMEM);
+ }
+ bus_dmamap_load(sc->mly_sg_dmat, sc->mly_sg_dmamap, sc->mly_sg_table, segsize, mly_sg_map_helper, sc, 0);
+ return(0);
+}
+
+/********************************************************************************
+ * Save the physical address of the base of the s/g table.
+ */
+static void
+mly_sg_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
+{
+ struct mly_softc *sc = (struct mly_softc *)arg;
+
+ debug_called(2);
+
+ /* save base of s/g table's address in bus space */
+ sc->mly_sg_busaddr = segs->ds_addr;
+}
+
+/********************************************************************************
+ * Allocate memory for the memory-mailbox interface
+ */
+static int
+mly_mmbox_map(struct mly_softc *sc)
+{
+
+ /*
+ * Create a DMA tag for a single contiguous region large enough for the
+ * memory mailbox structure.
+ */
+ if (bus_dma_tag_create(sc->mly_parent_dmat, /* parent */
+ 1, 0, /* alignment, boundary */
+ BUS_SPACE_MAXADDR, /* lowaddr */
+ BUS_SPACE_MAXADDR, /* highaddr */
+ NULL, NULL, /* filter, filterarg */
+ sizeof(struct mly_mmbox), 1, /* maxsize, nsegments */
+ BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
+ 0, /* flags */
+ &sc->mly_mmbox_dmat)) {
+ mly_printf(sc, "can't allocate memory mailbox DMA tag\n");
+ return(ENOMEM);
+ }
+
+ /*
+ * Allocate the buffer
+ */
+ if (bus_dmamem_alloc(sc->mly_mmbox_dmat, (void **)&sc->mly_mmbox, BUS_DMA_NOWAIT, &sc->mly_mmbox_dmamap)) {
+ mly_printf(sc, "can't allocate memory mailbox\n");
+ return(ENOMEM);
+ }
+ bus_dmamap_load(sc->mly_mmbox_dmat, sc->mly_mmbox_dmamap, sc->mly_mmbox, sizeof(struct mly_mmbox),
+ mly_mmbox_map_helper, sc, 0);
+ bzero(sc->mly_mmbox, sizeof(*sc->mly_mmbox));
+ return(0);
+
+}
+
+/********************************************************************************
+ * Save the physical address of the memory mailbox
+ */
+static void
+mly_mmbox_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
+{
+ struct mly_softc *sc = (struct mly_softc *)arg;
+
+ debug_called(2);
+
+ sc->mly_mmbox_busaddr = segs->ds_addr;
+}
+
+/********************************************************************************
+ * Free all of the resources associated with (sc)
+ *
+ * Should not be called if the controller is active.
+ */
+void
+mly_free(struct mly_softc *sc)
+{
+ struct mly_command_cluster *mcc;
+
+ debug_called(1);
+
+ /* detach from CAM */
+ mly_cam_detach(sc);
+
+ /* throw away any command buffers */
+ while ((mcc = mly_dequeue_cluster(sc)) != NULL)
+ mly_free_command_cluster(mcc);
+
+ /* throw away the controllerinfo structure */
+ if (sc->mly_controllerinfo != NULL)
+ free(sc->mly_controllerinfo, M_DEVBUF);
+
+ /* throw away the controllerparam structure */
+ if (sc->mly_controllerparam != NULL)
+ free(sc->mly_controllerparam, M_DEVBUF);
+
+ /* destroy data-transfer DMA tag */
+ if (sc->mly_buffer_dmat)
+ bus_dma_tag_destroy(sc->mly_buffer_dmat);
+
+ /* free and destroy DMA memory and tag for s/g lists */
+ if (sc->mly_sg_table) {
+ bus_dmamap_unload(sc->mly_sg_dmat, sc->mly_sg_dmamap);
+ bus_dmamem_free(sc->mly_sg_dmat, sc->mly_sg_table, sc->mly_sg_dmamap);
+ }
+ if (sc->mly_sg_dmat)
+ bus_dma_tag_destroy(sc->mly_sg_dmat);
+
+ /* free and destroy DMA memory and tag for memory mailbox */
+ if (sc->mly_mmbox) {
+ bus_dmamap_unload(sc->mly_mmbox_dmat, sc->mly_mmbox_dmamap);
+ bus_dmamem_free(sc->mly_mmbox_dmat, sc->mly_mmbox, sc->mly_mmbox_dmamap);
+ }
+ if (sc->mly_mmbox_dmat)
+ bus_dma_tag_destroy(sc->mly_mmbox_dmat);
+
+ /* disconnect the interrupt handler */
+ if (sc->mly_intr)
+ bus_teardown_intr(sc->mly_dev, sc->mly_irq, sc->mly_intr);
+ if (sc->mly_irq != NULL)
+ bus_release_resource(sc->mly_dev, SYS_RES_IRQ, sc->mly_irq_rid, sc->mly_irq);
+
+ /* destroy the parent DMA tag */
+ if (sc->mly_parent_dmat)
+ bus_dma_tag_destroy(sc->mly_parent_dmat);
+
+ /* release the register window mapping */
+ if (sc->mly_regs_resource != NULL)
+ bus_release_resource(sc->mly_dev, SYS_RES_MEMORY, sc->mly_regs_rid, sc->mly_regs_resource);
+}
+
+/********************************************************************************
+ * Free a command cluster.
+ */
+static void
+mly_free_command_cluster(struct mly_command_cluster *mcc)
+{
+ struct mly_softc *sc = mcc->mcc_command[0].mc_sc;
+ int i;
+
+ debug_called(1);
+
+ for (i = 0; i < MLY_CMD_CLUSTERCOUNT; i++)
+ bus_dmamap_destroy(sc->mly_buffer_dmat, mcc->mcc_command[i].mc_datamap);
+
+ bus_dmamap_unload(sc->mly_packet_dmat, mcc->mcc_packetmap);
+ bus_dmamem_free(sc->mly_packet_dmat, mcc->mcc_packet, mcc->mcc_packetmap);
+ free(mcc, M_DEVBUF);
+}
+
OpenPOWER on IntegriCloud