/*- * Copyright (c) 1999 Michael Smith * 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$ */ /* * Driver for the AMI MegaRaid family of controllers */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if 0 #define debug(fmt, args...) printf("%s: " fmt "\n", __FUNCTION__ , ##args) #else #define debug(fmt, args...) #endif #define AMR_CDEV_MAJOR 132 static struct cdevsw amr_cdevsw = { /* open */ amr_open, /* close */ amr_close, /* read */ noread, /* write */ nowrite, /* ioctl */ amr_ioctl, /* poll */ nopoll, /* mmap */ nommap, /* strategy */ nostrategy, /* name */ "amr", /* maj */ AMR_CDEV_MAJOR, /* dump */ nodump, /* psize */ nopsize, /* flags */ 0, /* bmaj */ 254 /* XXX magic no-bdev */ }; static int cdev_registered = 0; devclass_t amr_devclass; /* * Command wrappers */ static int amr_query_controller(struct amr_softc *sc); static void *amr_enquiry(struct amr_softc *sc, size_t bufsize, u_int8_t cmd, u_int8_t cmdsub, u_int8_t cmdqual); static int amr_flush(struct amr_softc *sc); static void amr_startio(struct amr_softc *sc); static void amr_completeio(struct amr_command *ac); /* * Command processing. */ static int amr_wait_command(struct amr_command *ac); static int amr_poll_command(struct amr_command *ac); static int amr_getslot(struct amr_command *ac); static void amr_mapcmd(struct amr_command *ac); static void amr_unmapcmd(struct amr_command *ac); static int amr_start(struct amr_command *ac); static int amr_done(struct amr_softc *sc); static void amr_complete(struct amr_softc *sc); /* * Command buffer allocation. */ static struct amr_command *amr_alloccmd(struct amr_softc *sc); static void amr_releasecmd(struct amr_command *ac); static void amr_freecmd(struct amr_command *ac); /* * Status monitoring */ static void amr_periodic(void *data); /* * Interface-specific shims */ static void amr_quartz_submit_command(struct amr_softc *sc); static int amr_quartz_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave); static void amr_quartz_attach_mailbox(struct amr_softc *sc); static void amr_std_submit_command(struct amr_softc *sc); static int amr_std_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave); static void amr_std_attach_mailbox(struct amr_softc *sc); /* * Debugging */ static void amr_printcommand(struct amr_command *ac); /******************************************************************************** ******************************************************************************** Public Interfaces ******************************************************************************** ********************************************************************************/ /******************************************************************************** * Free all of the resources associated with (sc) * * Should not be called if the controller is active. */ void amr_free(struct amr_softc *sc) { struct amr_command *ac; u_int8_t *p; debug("called"); /* cancel status timeout */ untimeout(amr_periodic, sc, sc->amr_timeout); /* throw away any command buffers */ while ((ac = TAILQ_FIRST(&sc->amr_freecmds)) != NULL) { TAILQ_REMOVE(&sc->amr_freecmds, ac, ac_link); amr_freecmd(ac); } /* destroy data-transfer DMA tag */ if (sc->amr_buffer_dmat) bus_dma_tag_destroy(sc->amr_buffer_dmat); /* free and destroy DMA memory and tag for s/g lists */ if (sc->amr_sgtable) bus_dmamem_free(sc->amr_sg_dmat, sc->amr_sgtable, sc->amr_sg_dmamap); if (sc->amr_sg_dmat) bus_dma_tag_destroy(sc->amr_sg_dmat); /* free and destroy DMA memory and tag for mailbox */ if (sc->amr_mailbox) { p = (u_int8_t *)sc->amr_mailbox; bus_dmamem_free(sc->amr_sg_dmat, p - 16, sc->amr_sg_dmamap); } if (sc->amr_sg_dmat) bus_dma_tag_destroy(sc->amr_sg_dmat); /* disconnect the interrupt handler */ if (sc->amr_intr) bus_teardown_intr(sc->amr_dev, sc->amr_irq, sc->amr_intr); if (sc->amr_irq != NULL) bus_release_resource(sc->amr_dev, SYS_RES_IRQ, 0, sc->amr_irq); /* destroy the parent DMA tag */ if (sc->amr_parent_dmat) bus_dma_tag_destroy(sc->amr_parent_dmat); /* release the register window mapping */ if (sc->amr_reg != NULL) bus_release_resource(sc->amr_dev, (sc->amr_type == AMR_TYPE_QUARTZ) ? SYS_RES_MEMORY : SYS_RES_IOPORT, AMR_CFG_BASE, sc->amr_reg); } /******************************************************************************** * Allocate and map the scatter/gather table in bus space. */ static void amr_dma_map_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error) { struct amr_softc *sc = (struct amr_softc *)arg; debug("called"); /* save base of s/g table's address in bus space */ sc->amr_sgbusaddr = segs->ds_addr; } static int amr_sglist_map(struct amr_softc *sc) { size_t segsize; int error; debug("called"); /* destroy any existing mappings */ if (sc->amr_sgtable) bus_dmamem_free(sc->amr_sg_dmat, sc->amr_sgtable, sc->amr_sg_dmamap); if (sc->amr_sg_dmat) bus_dma_tag_destroy(sc->amr_sg_dmat); /* * Create a single tag describing a region large enough to hold all of * the s/g lists we will need. */ segsize = sizeof(struct amr_sgentry) * AMR_NSEG * sc->amr_maxio; error = bus_dma_tag_create(sc->amr_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->amr_sg_dmat); if (error != 0) { device_printf(sc->amr_dev, "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. We may need to switch to a more complex arrangement where * we allocate in smaller chunks and keep a lookup table from slot to bus address. * * XXX HACK ALERT: at least some controllers don't like the s/g memory being * allocated below 0x2000. We leak some memory if we get some * below this mark and allocate again. */ retry: error = bus_dmamem_alloc(sc->amr_sg_dmat, (void **)&sc->amr_sgtable, BUS_DMA_NOWAIT, &sc->amr_sg_dmamap); if (error) { device_printf(sc->amr_dev, "can't allocate s/g table\n"); return(ENOMEM); } bus_dmamap_load(sc->amr_sg_dmat, sc->amr_sg_dmamap, sc->amr_sgtable, segsize, amr_dma_map_sg, sc, 0); if (sc->amr_sgbusaddr < 0x2000) { device_printf(sc->amr_dev, "s/g table too low (0x%x), reallocating\n", sc->amr_sgbusaddr); goto retry; } return(0); } /******************************************************************************** * Allocate and set up mailbox areas for the controller (sc) * * The basic mailbox structure should be 16-byte aligned. This means that the * mailbox64 structure has 4 bytes hanging off the bottom. */ static void amr_map_mailbox(void *arg, bus_dma_segment_t *segs, int nseg, int error) { struct amr_softc *sc = (struct amr_softc *)arg; debug("called"); /* save phsyical base of the basic mailbox structure */ sc->amr_mailboxphys = segs->ds_addr + 16; } static int amr_setup_mbox(struct amr_softc *sc) { int error; u_int8_t *p; debug("called"); /* * Create a single tag describing a region large enough to hold the entire * mailbox. */ error = bus_dma_tag_create(sc->amr_parent_dmat, /* parent */ 16, 0, /* alignment, boundary */ BUS_SPACE_MAXADDR, /* lowaddr */ BUS_SPACE_MAXADDR, /* highaddr */ NULL, NULL, /* filter, filterarg */ sizeof(struct amr_mailbox) + 16, 1, /* maxsize, nsegments */ BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ 0, /* flags */ &sc->amr_mailbox_dmat); if (error != 0) { device_printf(sc->amr_dev, "can't allocate mailbox tag\n"); return(ENOMEM); } /* * Allocate the mailbox structure and permanently map it into * controller-visible space. */ error = bus_dmamem_alloc(sc->amr_mailbox_dmat, (void **)&p, BUS_DMA_NOWAIT, &sc->amr_mailbox_dmamap); if (error) { device_printf(sc->amr_dev, "can't allocate mailbox memory\n"); return(ENOMEM); } bus_dmamap_load(sc->amr_mailbox_dmat, sc->amr_mailbox_dmamap, p, sizeof(struct amr_mailbox64), amr_map_mailbox, sc, 0); /* * Conventional mailbox is inside the mailbox64 region. */ bzero(p, sizeof(struct amr_mailbox64)); sc->amr_mailbox64 = (struct amr_mailbox64 *)(p + 12); sc->amr_mailbox = (struct amr_mailbox *)(p + 16); if (sc->amr_type == AMR_TYPE_STD) { /* XXX we have to tell the controller where we put it */ } return(0); } /******************************************************************************** * Initialise the controller and softc. */ int amr_attach(struct amr_softc *sc) { int rid, error; /* * Initialise per-controller queues. */ TAILQ_INIT(&sc->amr_work); TAILQ_INIT(&sc->amr_freecmds); bioq_init(&sc->amr_bioq); /* * Configure for this controller type. */ if (sc->amr_type == AMR_TYPE_QUARTZ) { sc->amr_submit_command = amr_quartz_submit_command; sc->amr_get_work = amr_quartz_get_work; sc->amr_attach_mailbox = amr_quartz_attach_mailbox; } else { sc->amr_submit_command = amr_std_submit_command; sc->amr_get_work = amr_std_get_work; sc->amr_attach_mailbox = amr_std_attach_mailbox; } /* * Allocate and connect our interrupt. */ rid = 0; sc->amr_irq = bus_alloc_resource(sc->amr_dev, SYS_RES_IRQ, &rid, 0, ~0, 1, RF_SHAREABLE | RF_ACTIVE); if (sc->amr_irq == NULL) { device_printf(sc->amr_dev, "couldn't allocate interrupt\n"); amr_free(sc); return(ENXIO); } error = bus_setup_intr(sc->amr_dev, sc->amr_irq, INTR_TYPE_BIO, amr_intr, sc, &sc->amr_intr); if (error) { device_printf(sc->amr_dev, "couldn't set up interrupt\n"); amr_free(sc); return(ENXIO); } /* * Create DMA tag for mapping buffers into controller-addressable space. */ error = bus_dma_tag_create(sc->amr_parent_dmat, /* parent */ 1, 0, /* alignment, boundary */ BUS_SPACE_MAXADDR, /* lowaddr */ BUS_SPACE_MAXADDR, /* highaddr */ NULL, NULL, /* filter, filterarg */ MAXBSIZE, AMR_NSEG, /* maxsize, nsegments */ BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ 0, /* flags */ &sc->amr_buffer_dmat); if (error != 0) { device_printf(sc->amr_dev, "can't allocate buffer DMA tag\n"); return(ENOMEM); } /* * Allocate and set up mailbox in a bus-visible fashion, attach to controller. */ if ((error = amr_setup_mbox(sc)) != 0) return(error); sc->amr_attach_mailbox(sc); /* * Build a temporary set of scatter/gather buffers. */ sc->amr_maxio = 2; if (amr_sglist_map(sc)) return(ENXIO); /* * Quiz controller for features and limits. */ if (amr_query_controller(sc)) return(ENXIO); /* * Rebuild the scatter/gather buffers now we know how many we need. */ if (amr_sglist_map(sc)) return(ENXIO); /* * Start the timeout routine. */ sc->amr_timeout = timeout(amr_periodic, sc, hz); return(0); } /******************************************************************************** * Locate disk resources and attach children to them. */ void amr_startup(struct amr_softc *sc) { struct amr_logdrive *dr; int i, error; debug("called"); /* get up-to-date drive information */ if (amr_query_controller(sc)) { device_printf(sc->amr_dev, "couldn't scan controller for drives\n"); return; } /* iterate over available drives */ for (i = 0, dr = &sc->amr_drive[0]; (i < AMR_MAXLD) && (dr->al_size != 0xffffffff); i++, dr++) { /* are we already attached to this drive? */ if (dr->al_disk == 0) { /* generate geometry information */ if (dr->al_size > 0x200000) { /* extended translation? */ dr->al_heads = 255; dr->al_sectors = 63; } else { dr->al_heads = 64; dr->al_sectors = 32; } dr->al_cylinders = dr->al_size / (dr->al_heads * dr->al_sectors); dr->al_disk = device_add_child(sc->amr_dev, NULL, -1); if (dr->al_disk == 0) device_printf(sc->amr_dev, "device_add_child failed\n"); device_set_ivars(dr->al_disk, dr); } } if ((error = bus_generic_attach(sc->amr_dev)) != 0) device_printf(sc->amr_dev, "bus_generic_attach returned %d\n", error); /* mark controller back up */ sc->amr_state &= ~AMR_STATE_SHUTDOWN; /* interrupts will be enabled before we do anything more */ sc->amr_state |= AMR_STATE_INTEN; } /******************************************************************************** * Disconnect from the controller completely, in preparation for unload. */ int amr_detach(device_t dev) { struct amr_softc *sc = device_get_softc(dev); int error; debug("called"); if (sc->amr_state & AMR_STATE_OPEN) return(EBUSY); if ((error = amr_shutdown(dev))) return(error); amr_free(sc); /* * Deregister the control device on last detach. */ if (--cdev_registered == 0) cdevsw_remove(&amr_cdevsw); return(0); } /******************************************************************************** * Bring the controller down to a dormant state and detach all child devices. * * This function is called before detach, system shutdown, or before performing * an operation which may add or delete system disks. (Call amr_startup to * resume normal operation.) * * Note that we can assume that the bioq on the controller is empty, as we won't * allow shutdown if any device is open. */ int amr_shutdown(device_t dev) { struct amr_softc *sc = device_get_softc(dev); struct amrd_softc *ad; int i, s, error; debug("called"); s = splbio(); error = 0; /* assume we're going to shut down */ sc->amr_state |= AMR_STATE_SHUTDOWN; for (i = 0; i < AMR_MAXLD; i++) { if (sc->amr_drive[i].al_disk != 0) { ad = device_get_softc(sc->amr_drive[i].al_disk); if (ad->amrd_flags & AMRD_OPEN) { /* drive is mounted, abort shutdown */ sc->amr_state &= ~AMR_STATE_SHUTDOWN; device_printf(sc->amr_drive[i].al_disk, "still open, can't shutdown\n"); error = EBUSY; goto out; } } } /* flush controller */ device_printf(sc->amr_dev, "flushing cache..."); if (amr_flush(sc)) { printf("failed\n"); } else { printf("done\n"); } /* delete all our child devices */ for (i = 0; i < AMR_MAXLD; i++) { if (sc->amr_drive[i].al_disk != 0) { if ((error = device_delete_child(sc->amr_dev, sc->amr_drive[i].al_disk)) != 0) goto out; sc->amr_drive[i].al_disk = 0; } } out: splx(s); return(error); } /******************************************************************************** * Bring the controller to a quiescent state, ready for system suspend. */ int amr_suspend(device_t dev) { struct amr_softc *sc = device_get_softc(dev); debug("called"); sc->amr_state |= AMR_STATE_SUSPEND; /* flush controller */ device_printf(sc->amr_dev, "flushing cache..."); printf("%s\n", amr_flush(sc) ? "failed" : "done"); return(0); } /******************************************************************************** * Bring the controller back to a state ready for operation. */ int amr_resume(device_t dev) { struct amr_softc *sc = device_get_softc(dev); debug("called"); sc->amr_state &= ~AMR_STATE_SUSPEND; return(0); } /******************************************************************************* * Take an interrupt, or be poked by other code to look for interrupt-worthy * status. */ void amr_intr(void *arg) { struct amr_softc *sc = (struct amr_softc *)arg; debug("called"); /* collect finished commands, queue anything waiting */ amr_done(sc); }; /******************************************************************************* * Receive a buf structure from a child device and queue it on a particular * disk resource, then poke the disk resource to start as much work as it can. */ int amr_submit_buf(struct amr_softc *sc, struct bio *bp) { int s; debug("called"); s = splbio(); bioq_insert_tail(&sc->amr_bioq, bp); splx(s); sc->amr_waitbufs++; amr_startio(sc); return(0); } /******************************************************************************** * Accept an open operation on the control device. */ int amr_open(dev_t dev, int flags, int fmt, struct proc *p) { int unit = minor(dev); struct amr_softc *sc = devclass_get_softc(amr_devclass, unit); sc->amr_state |= AMR_STATE_OPEN; return(0); } /******************************************************************************** * Accept the last close on the control device. */ int amr_close(dev_t dev, int flags, int fmt, struct proc *p) { int unit = minor(dev); struct amr_softc *sc = devclass_get_softc(amr_devclass, unit); sc->amr_state &= ~AMR_STATE_OPEN; return (0); } /******************************************************************************** * Handle controller-specific control operations. */ int amr_ioctl(dev_t dev, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) { switch(cmd) { default: return(ENOTTY); } } /******************************************************************************** * Handle operations requested by a drive connected to this controller. */ int amr_submit_ioctl(struct amr_softc *sc, struct amr_logdrive *drive, u_long cmd, caddr_t addr, int32_t flag, struct proc *p) { return(ENOTTY); } /******************************************************************************** ******************************************************************************** Status Monitoring ******************************************************************************** ********************************************************************************/ /******************************************************************************** * Perform a periodic check of the controller status */ static void amr_periodic(void *data) { struct amr_softc *sc = (struct amr_softc *)data; int s, i; debug("called"); #if 0 /* * XXX this is basically wrong - returning a command that's wedged * leaves us vulnerable to the controller later completing the command * and overwriting memory that may have subsequently been reused. */ /* * Check for commands that are massively late. This will need to be * revisited if/when we deal with eg. device format commands. * The 30 second value is entirely arbitrary. */ s = splbio(); if (sc->amr_busycmdcount > 0) { for (i = 0; i < AMR_MAXCMD; i++) { /* * If the command has been busy for more than 30 seconds, declare it * wedged and retire it with an error. */ if ((sc->amr_busycmd[i] != NULL) && (sc->amr_busycmd[i]->ac_status == AMR_STATUS_BUSY) && ((sc->amr_busycmd[i]->ac_stamp + 30) < time_second)) { device_printf(sc->amr_dev, "command %d wedged after 30 seconds\n", i); sc->amr_busycmd[i]->ac_status = AMR_STATUS_WEDGED; amr_completeio(sc->amr_busycmd[i]); } } } splx(s); #endif /* reschedule */ sc->amr_timeout = timeout(amr_periodic, sc, hz); } /******************************************************************************** ******************************************************************************** Command Wrappers ******************************************************************************** ********************************************************************************/ /******************************************************************************** * Interrogate the controller for the operational parameters we require. */ static int amr_query_controller(struct amr_softc *sc) { void *buf; int i; /* try to issue an ENQUIRY3 command */ if ((buf = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_ENQ3, AMR_CONFIG_ENQ3_SOLICITED_FULL)) == NULL) { struct amr_enquiry *ae; /* failed, try the old ENQUIRY command */ if ((ae = (struct amr_enquiry *)amr_enquiry(sc, 2048, AMR_CMD_ENQUIRY, 0, 0)) == NULL) { device_printf(sc->amr_dev, "could not obtain configuration data from controller\n"); return(1); } /* first-time enquiry? */ if (sc->amr_maxdrives == 0) { device_printf(sc->amr_dev, "firmware %.4s bios %.4s %dMB memory\n", ae->ae_adapter.aa_firmware, ae->ae_adapter.aa_bios, ae->ae_adapter.aa_memorysize); } sc->amr_maxdrives = 8; /* * Cap the maximum number of outstanding I/Os. AMI's Linux driver doesn't trust * the controller's reported value, and lockups have been seen when we do. */ sc->amr_maxio = imin(ae->ae_adapter.aa_maxio, AMR_LIMITCMD); for (i = 0; i < ae->ae_ldrv.al_numdrives; i++) { sc->amr_drive[i].al_size = ae->ae_ldrv.al_size[i]; sc->amr_drive[i].al_state = ae->ae_ldrv.al_state[i]; sc->amr_drive[i].al_properties = ae->ae_ldrv.al_properties[i]; debug(" drive %d: %d state %x properties %x\n", i, sc->amr_drive[i].al_size, sc->amr_drive[i].al_state, sc->amr_drive[i].al_properties); } for (; i < AMR_MAXLD; i++) sc->amr_drive[i].al_size = 0xffffffff; free(ae, M_DEVBUF); } else { /* * The "40LD" (40 logical drive support) firmware is mentioned in the Linux * driver, but no adapters from AMI appear to support it. */ free(buf, M_DEVBUF); sc->amr_maxdrives = 40; /* get static product info */ if ((buf = amr_enquiry(sc, 2048, AMR_CMD_CONFIG, AMR_CONFIG_PRODINFO, 0)) == NULL) { device_printf(sc->amr_dev, "controller supports 40ld but CONFIG_PRODINFO failed\n"); return(1); } free(buf, M_DEVBUF); device_printf(sc->amr_dev, "40LD firmware unsupported; send controller to msmith@freebsd.org\n"); return(1); } return(0); } /******************************************************************************** * Run a generic enquiry-style command. */ static void * amr_enquiry(struct amr_softc *sc, size_t bufsize, u_int8_t cmd, u_int8_t cmdsub, u_int8_t cmdqual) { struct amr_command *ac; void *result; u_int8_t *mbox; int error; debug("called"); error = 1; result = NULL; /* get ourselves a command buffer */ if ((ac = amr_alloccmd(sc)) == NULL) goto out; /* allocate the response structure */ if ((result = malloc(bufsize, M_DEVBUF, M_NOWAIT)) == NULL) goto out; /* get a command slot */ ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT; if (amr_getslot(ac)) goto out; /* map the command so the controller can see it */ ac->ac_data = result; ac->ac_length = bufsize; amr_mapcmd(ac); /* build the command proper */ mbox = (u_int8_t *)&ac->ac_mailbox; /* XXX want a real structure for this? */ mbox[0] = cmd; mbox[2] = cmdsub; mbox[3] = cmdqual; ac->ac_mailbox.mb_physaddr = ac->ac_dataphys; /* can't assume that interrupts are going to work here, so play it safe */ if (amr_poll_command(ac)) goto out; error = ac->ac_status; out: if (ac != NULL) amr_releasecmd(ac); if ((error != 0) && (result != NULL)) { free(result, M_DEVBUF); result = NULL; } return(result); } /******************************************************************************** * Flush the controller's internal cache, return status. */ static int amr_flush(struct amr_softc *sc) { struct amr_command *ac; int error; /* get ourselves a command buffer */ error = 1; if ((ac = amr_alloccmd(sc)) == NULL) goto out; /* get a command slot */ ac->ac_flags |= AMR_CMD_PRIORITY | AMR_CMD_DATAOUT; if (amr_getslot(ac)) goto out; /* build the command proper */ ac->ac_mailbox.mb_command = AMR_CMD_FLUSH; /* we have to poll, as the system may be going down or otherwise damaged */ if (amr_poll_command(ac)) goto out; error = ac->ac_status; out: if (ac != NULL) amr_releasecmd(ac); return(error); } /******************************************************************************** * Pull as much work off the softc's work queue as possible and give it to the * controller. Leave a couple of slots free for emergencies. * * We avoid running at splbio() whenever possible. */ static void amr_startio(struct amr_softc *sc) { struct amr_command *ac; struct amrd_softc *amrd; struct bio *bp; int blkcount; int driveno; int cmd; int s; /* avoid reentrancy */ if (amr_lock_tas(sc, AMR_LOCK_STARTING)) return; /* spin until something prevents us from doing any work */ s = splbio(); for (;;) { /* see if there's work to be done */ if ((bp = bioq_first(&sc->amr_bioq)) == NULL) break; /* get a command */ if ((ac = amr_alloccmd(sc)) == NULL) break; /* get a slot for the command */ if (amr_getslot(ac) != 0) { amr_releasecmd(ac); break; } /* get the buf containing our work */ bioq_remove(&sc->amr_bioq, bp); sc->amr_waitbufs--; splx(s); /* connect the buf to the command */ ac->ac_complete = amr_completeio; ac->ac_private = bp; ac->ac_data = bp->bio_data; ac->ac_length = bp->bio_bcount; if (bp->bio_cmd == BIO_READ) { ac->ac_flags |= AMR_CMD_DATAIN; cmd = AMR_CMD_LREAD; } else { ac->ac_flags |= AMR_CMD_DATAOUT; cmd = AMR_CMD_LWRITE; } /* map the command so the controller can work with it */ amr_mapcmd(ac); /* build a suitable I/O command (assumes 512-byte rounded transfers) */ amrd = (struct amrd_softc *)bp->bio_dev->si_drv1; driveno = amrd->amrd_drive - sc->amr_drive; blkcount = (bp->bio_bcount + AMR_BLKSIZE - 1) / AMR_BLKSIZE; if ((bp->bio_pblkno + blkcount) > sc->amr_drive[driveno].al_size) device_printf(sc->amr_dev, "I/O beyond end of unit (%u,%d > %u)\n", bp->bio_pblkno, blkcount, sc->amr_drive[driveno].al_size); /* * Build the I/O command. */ ac->ac_mailbox.mb_command = cmd; ac->ac_mailbox.mb_blkcount = blkcount; ac->ac_mailbox.mb_lba = bp->bio_pblkno; ac->ac_mailbox.mb_physaddr = ac->ac_sgphys; ac->ac_mailbox.mb_drive = driveno; ac->ac_mailbox.mb_nsgelem = ac->ac_nsgent; /* try to give command to controller */ if (amr_start(ac) != 0) { /* fail the command */ ac->ac_status = AMR_STATUS_WEDGED; amr_completeio(ac); } s = splbio(); } splx(s); amr_lock_clr(sc, AMR_LOCK_STARTING); } /******************************************************************************** * Handle completion of an I/O command. */ static void amr_completeio(struct amr_command *ac) { struct amr_softc *sc = ac->ac_sc; struct bio *bp = (struct bio *)ac->ac_private; int notify, release; notify = 1; release = 1; if (ac->ac_status != AMR_STATUS_SUCCESS) { /* could be more verbose here? */ bp->bio_error = EIO; bp->bio_flags |= BIO_ERROR; switch(ac->ac_status) { /* XXX need more information on I/O error reasons */ case AMR_STATUS_LATE: notify = 0; /* we've already notified the parent */ break; case AMR_STATUS_WEDGED: release = 0; /* the command is still outstanding, we can't release */ break; default: device_printf(sc->amr_dev, "I/O error - %x\n", ac->ac_status); amr_printcommand(ac); break; } } if (release) amr_releasecmd(ac); if (notify) amrd_intr(bp); } /******************************************************************************** ******************************************************************************** Command Processing ******************************************************************************** ********************************************************************************/ /******************************************************************************** * Take a command, submit it to the controller and sleep until it completes * or fails. Interrupts must be enabled, returns nonzero on error. */ static int amr_wait_command(struct amr_command *ac) { struct amr_softc *sc = ac->ac_sc; int error, count; debug("called"); ac->ac_complete = NULL; ac->ac_private = ac; if ((error = amr_start(ac)) != 0) return(error); count = 0; /* XXX better timeout? */ while ((ac->ac_status == AMR_STATUS_BUSY) && (count < 30)) { tsleep(ac->ac_private, PRIBIO | PCATCH, "amrwcmd", hz); } if (ac->ac_status != 0) { device_printf(sc->amr_dev, "I/O error 0x%x\n", ac->ac_status); return(EIO); } return(0); } /******************************************************************************** * Take a command, submit it to the controller and busy-wait for it to return. * Returns nonzero on error. Can be safely called with interrupts enabled. */ static int amr_poll_command(struct amr_command *ac) { struct amr_softc *sc = ac->ac_sc; int error, count, s; debug("called"); ac->ac_complete = NULL; ac->ac_private = NULL; if ((error = amr_start(ac)) != 0) return(error); count = 0; do { /* * Poll for completion, although the interrupt handler may beat us to it. * Note that the timeout here is somewhat arbitrary. */ amr_done(sc); } while ((ac->ac_status == AMR_STATUS_BUSY) && (count++ < 100000)); s = splbio(); if (ac->ac_status != AMR_STATUS_BUSY) { TAILQ_REMOVE(&sc->amr_work, ac, ac_link); sc->amr_workcount--; error = 0; } else { /* take the command out of the busy list, mark slot as bogus */ sc->amr_busycmd[ac->ac_slot] = (struct amr_command *)sc; error = EIO; device_printf(sc->amr_dev, "I/O error 0x%x\n", ac->ac_status); } splx(s); return(error); } /******************************************************************************** * Get a free command slot. */ static int amr_getslot(struct amr_command *ac) { struct amr_softc *sc = ac->ac_sc; int s, slot, limit; debug("called"); /* enforce slot usage limit */ limit = (ac->ac_flags & AMR_CMD_PRIORITY) ? sc->amr_maxio : sc->amr_maxio - 4; if (sc->amr_busycmdcount > limit) return(EBUSY); /* * Allocate a slot */ s = splbio(); for (slot = 0; slot < sc->amr_maxio; slot++) { if (sc->amr_busycmd[slot] == NULL) break; } if (slot < sc->amr_maxio) { sc->amr_busycmdcount++; sc->amr_busycmd[slot] = ac; } splx(s); /* out of slots? */ if (slot >= sc->amr_maxio) return(EBUSY); ac->ac_slot = slot; return(0); } /******************************************************************************** * Map/unmap (ac)'s data in the controller's addressable space. */ static void amr_setup_dmamap(void *arg, bus_dma_segment_t *segs, int nsegments, int error) { struct amr_command *ac = (struct amr_command *)arg; struct amr_softc *sc = ac->ac_sc; struct amr_sgentry *sg; int i; debug("called"); /* get base address of s/g table */ sg = sc->amr_sgtable + (ac->ac_slot * AMR_NSEG); /* save s/g table information in command */ ac->ac_nsgent = nsegments; ac->ac_sgphys = sc->amr_sgbusaddr + (ac->ac_slot * AMR_NSEG * sizeof(struct amr_sgentry)); ac->ac_dataphys = segs[0].ds_addr; /* populate s/g table */ for (i = 0; i < nsegments; i++, sg++) { sg->sg_addr = segs[i].ds_addr; sg->sg_count = segs[i].ds_len; } } static void amr_mapcmd(struct amr_command *ac) { struct amr_softc *sc = ac->ac_sc; debug("called"); /* if the command involves data at all */ if (ac->ac_data != NULL) { /* map the data buffer into bus space and build the s/g list */ bus_dmamap_load(sc->amr_buffer_dmat, ac->ac_dmamap, ac->ac_data, ac->ac_length, amr_setup_dmamap, ac, 0); if (ac->ac_flags & AMR_CMD_DATAIN) bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_PREREAD); if (ac->ac_flags & AMR_CMD_DATAOUT) bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_PREWRITE); } } static void amr_unmapcmd(struct amr_command *ac) { struct amr_softc *sc = ac->ac_sc; debug("called"); /* if the command involved data at all */ if (ac->ac_data != NULL) { if (ac->ac_flags & AMR_CMD_DATAIN) bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_POSTREAD); if (ac->ac_flags & AMR_CMD_DATAOUT) bus_dmamap_sync(sc->amr_buffer_dmat, ac->ac_dmamap, BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(sc->amr_buffer_dmat, ac->ac_dmamap); } } /******************************************************************************** * Take a command and give it to the controller. */ static int amr_start(struct amr_command *ac) { struct amr_softc *sc = ac->ac_sc; int done, s, i; debug("called"); /* * Save the slot number so that we can locate this command when complete. * Note that ident = 0 seems to be special, so we don't use it. */ ac->ac_mailbox.mb_ident = ac->ac_slot + 1; /* set the busy flag when we copy the mailbox in */ ac->ac_mailbox.mb_busy = 1; /* set impossible status so that a woken sleeper can tell the command is busy */ ac->ac_status = AMR_STATUS_BUSY; /* * Spin waiting for the mailbox, give up after ~1 second. */ debug("wait for mailbox"); for (i = 10000, done = 0; (i > 0) && !done; i--) { s = splbio(); /* is the mailbox free? */ if (sc->amr_mailbox->mb_busy == 0) { debug("got mailbox"); sc->amr_mailbox64->mb64_segment = 0; bcopy(&ac->ac_mailbox, sc->amr_mailbox, AMR_MBOX_CMDSIZE); sc->amr_submit_command(sc); done = 1; sc->amr_workcount++; TAILQ_INSERT_TAIL(&sc->amr_work, ac, ac_link); /* not free, try to clean up while we wait */ } else { debug("busy flag %x\n", sc->amr_mailbox->mb_busy); /* this is somewhat ugly */ DELAY(100); } splx(s); /* drop spl to allow completion interrupts */ } /* command is enqueued? */ if (done) { ac->ac_stamp = time_second; debug("posted command"); return(0); } /* * The controller wouldn't take the command. Revoke the slot * that the command was given and return with a bad status. */ sc->amr_busycmd[ac->ac_slot] = NULL; device_printf(sc->amr_dev, "controller wedged (not taking commands)\n"); ac->ac_status = AMR_STATUS_WEDGED; amr_complete(sc); return(EIO); } /******************************************************************************** * Extract one or more completed commands from the controller (sc) * * Returns nonzero if any commands on the work queue were marked as completed. */ static int amr_done(struct amr_softc *sc) { struct amr_command *ac; struct amr_mailbox mbox; int i, idx, s, result; debug("called"); /* See if there's anything for us to do */ result = 0; /* loop collecting completed commands */ s = splbio(); for (;;) { /* poll for a completed command's identifier and status */ if (sc->amr_get_work(sc, &mbox)) { result = 1; /* iterate over completed commands in this result */ for (i = 0; i < mbox.mb_nstatus; i++) { /* get pointer to busy command */ idx = mbox.mb_completed[i] - 1; ac = sc->amr_busycmd[idx]; /* really a busy command? */ if (ac != NULL) { /* pull the command from the busy index */ sc->amr_busycmd[idx] = NULL; sc->amr_busycmdcount--; /* aborted command? */ if (ac == (struct amr_command *)sc) { device_printf(sc->amr_dev, "aborted command completed (%d)\n", idx); sc->amr_busycmd[idx] = NULL; /* free the slot again */ ac = NULL; /* wedged command? */ } else if (ac->ac_status == AMR_STATUS_WEDGED) { device_printf(sc->amr_dev, "wedged command completed (%d)\n", idx); ac->ac_status = AMR_STATUS_LATE; /* completed normally, save status */ } else { ac->ac_status = mbox.mb_status; debug("completed command with status %x", mbox.mb_status); } } } } else { break; } } /* if we've completed any commands, try posting some more */ if (result) amr_startio(sc); /* handle completion and timeouts */ amr_complete(sc); return(result); } /******************************************************************************** * Do completion processing on done commands on (sc) */ static void amr_complete(struct amr_softc *sc) { struct amr_command *ac, *nc; int s, count; debug("called"); if (amr_lock_tas(sc, AMR_LOCK_COMPLETING)) return; s = splbio(); count = 0; /* scan the list of busy/done commands */ ac = TAILQ_FIRST(&sc->amr_work); while (ac != NULL) { nc = TAILQ_NEXT(ac, ac_link); /* Command has been completed in some fashion */ if (ac->ac_status != AMR_STATUS_BUSY) { /* unmap the command's data buffer */ amr_unmapcmd(ac); /* * Is there a completion handler? */ if (ac->ac_complete != NULL) { /* remove and give to completion handler */ TAILQ_REMOVE(&sc->amr_work, ac, ac_link); sc->amr_workcount--; ac->ac_complete(ac); /* * Is someone sleeping on this one? */ } else if (ac->ac_private != NULL) { /* remove and wake up */ TAILQ_REMOVE(&sc->amr_work, ac, ac_link); sc->amr_workcount--; wakeup_one(ac->ac_private); /* * Leave it for a polling caller. */ } else { } } ac = nc; } splx(s); amr_lock_clr(sc, AMR_LOCK_COMPLETING); } /******************************************************************************** ******************************************************************************** Command Buffer Management ******************************************************************************** ********************************************************************************/ /******************************************************************************** * Get a new command buffer. * * This may return NULL in low-memory cases. * * Note that using malloc() is expensive (the command buffer is << 1 page) but * necessary if we are to be a loadable module before the zone allocator is fixed. * * If possible, we recycle a command buffer that's been used before. * * XXX Note that command buffers are not cleaned out - it is the caller's * responsibility to ensure that all required fields are filled in before * using a buffer. */ static struct amr_command * amr_alloccmd(struct amr_softc *sc) { struct amr_command *ac; int error; int s; debug("called"); s = splbio(); if ((ac = TAILQ_FIRST(&sc->amr_freecmds)) != NULL) TAILQ_REMOVE(&sc->amr_freecmds, ac, ac_link); splx(s); /* allocate a new command buffer? */ if (ac == NULL) { ac = (struct amr_command *)malloc(sizeof(*ac), M_DEVBUF, M_NOWAIT); if (ac != NULL) { bzero(ac, sizeof(*ac)); ac->ac_sc = sc; error = bus_dmamap_create(sc->amr_buffer_dmat, 0, &ac->ac_dmamap); if (error) { free(ac, M_DEVBUF); return(NULL); } } } bzero(&ac->ac_mailbox, sizeof(struct amr_mailbox)); return(ac); } /******************************************************************************** * Release a command buffer for recycling. * * XXX It might be a good idea to limit the number of commands we save for reuse * if it's shown that this list bloats out massively. */ static void amr_releasecmd(struct amr_command *ac) { int s; debug("called"); s = splbio(); TAILQ_INSERT_HEAD(&ac->ac_sc->amr_freecmds, ac, ac_link); splx(s); } /******************************************************************************** * Permanently discard a command buffer. */ static void amr_freecmd(struct amr_command *ac) { struct amr_softc *sc = ac->ac_sc; debug("called"); bus_dmamap_destroy(sc->amr_buffer_dmat, ac->ac_dmamap); free(ac, M_DEVBUF); } /******************************************************************************** ******************************************************************************** Interface-specific Shims ******************************************************************************** ********************************************************************************/ /******************************************************************************** * Tell the controller that the mailbox contains a valid command */ static void amr_quartz_submit_command(struct amr_softc *sc) { debug("called"); sc->amr_mailbox->mb_poll = 0; sc->amr_mailbox->mb_ack = 0; while(AMR_QGET_IDB(sc) & AMR_QIDB_SUBMIT) ; /* XXX aiee! what if it dies? */ AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_SUBMIT); } static void amr_std_submit_command(struct amr_softc *sc) { debug("called"); /* XXX write barrier? */ while (AMR_SGET_MBSTAT(sc) & AMR_SMBOX_BUSYFLAG) ; /* XXX aiee! what if it dies? */ AMR_SPOST_COMMAND(sc); } /******************************************************************************** * Claim any work that the controller has completed; acknowledge completion, * save details of the completion in (mbsave) */ static int amr_quartz_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave) { int s, worked; u_int32_t outd; /* debug("called"); */ worked = 0; s = splbio(); /* work waiting for us? */ if ((outd = AMR_QGET_ODB(sc)) == AMR_QODB_READY) { AMR_QPUT_ODB(sc, AMR_QODB_READY); /* save mailbox, which contains a list of completed commands */ /* XXX read barrier? */ bcopy(sc->amr_mailbox, mbsave, sizeof(*mbsave)); /* acknowledge that we have the commands */ AMR_QPUT_IDB(sc, sc->amr_mailboxphys | AMR_QIDB_ACK); while(AMR_QGET_IDB(sc) & AMR_QIDB_ACK) ; /* XXX aiee! what if it dies? */ worked = 1; /* got some work */ } splx(s); return(worked); } static int amr_std_get_work(struct amr_softc *sc, struct amr_mailbox *mbsave) { int s, worked; u_int8_t istat; debug("called"); worked = 0; s = splbio(); /* check for valid interrupt status */ istat = AMR_SGET_ISTAT(sc); if ((istat & AMR_SINTR_VALID) != 0) { AMR_SPUT_ISTAT(sc, istat); /* ack interrupt status */ /* save mailbox, which contains a list of completed commands */ /* XXX read barrier? */ bcopy(sc->amr_mailbox, mbsave, sizeof(*mbsave)); AMR_SACK_INTERRUPT(sc); /* acknowledge we have the mailbox */ worked = 1; } splx(s); return(worked); } /******************************************************************************** * Notify the controller of the mailbox location. */ static void amr_quartz_attach_mailbox(struct amr_softc *sc) { /* Quartz is given the mailbox location when a command is submitted */ } static void amr_std_attach_mailbox(struct amr_softc *sc) { /* program the mailbox physical address */ AMR_SBYTE_SET(sc, AMR_SMBOX_0, sc->amr_mailboxphys & 0xff); AMR_SBYTE_SET(sc, AMR_SMBOX_1, (sc->amr_mailboxphys >> 8) & 0xff); AMR_SBYTE_SET(sc, AMR_SMBOX_2, (sc->amr_mailboxphys >> 16) & 0xff); AMR_SBYTE_SET(sc, AMR_SMBOX_3, (sc->amr_mailboxphys >> 24) & 0xff); AMR_SBYTE_SET(sc, AMR_SMBOX_ENABLE, AMR_SMBOX_ADDR); /* clear any outstanding interrupt and enable interrupts proper */ AMR_SACK_INTERRUPT(sc); AMR_SENABLE_INTR(sc); } /******************************************************************************** ******************************************************************************** Debugging ******************************************************************************** ********************************************************************************/ /******************************************************************************** * Print the command (ac) in human-readable format */ static void amr_printcommand(struct amr_command *ac) { struct amr_softc *sc = ac->ac_sc; struct amr_sgentry *sg; int i; device_printf(sc->amr_dev, "cmd %x ident %d drive %d\n", ac->ac_mailbox.mb_command, ac->ac_mailbox.mb_ident, ac->ac_mailbox.mb_drive); device_printf(sc->amr_dev, "blkcount %d lba %d\n", ac->ac_mailbox.mb_blkcount, ac->ac_mailbox.mb_lba); device_printf(sc->amr_dev, "virtaddr %p length %lu\n", ac->ac_data, (unsigned long)ac->ac_length); device_printf(sc->amr_dev, "sg physaddr %08x nsg %d\n", ac->ac_mailbox.mb_physaddr, ac->ac_mailbox.mb_nsgelem); /* get base address of s/g table */ sg = sc->amr_sgtable + (ac->ac_slot * AMR_NSEG); for (i = 0; i < ac->ac_mailbox.mb_nsgelem; i++, sg++) device_printf(sc->amr_dev, " %x/%d\n", sg->sg_addr, sg->sg_count); } /******************************************************************************** * Print information on all the controllers in the system, useful mostly * for calling from DDB. */ void amr_report(void) { struct amr_softc *sc; int i, s; s = splbio(); for (i = 0; (sc = devclass_get_softc(amr_devclass, i)) != NULL; i++) { device_printf(sc->amr_dev, "amr_waitbufs %d amr_busycmdcount %d amr_workcount %d\n", sc->amr_waitbufs, sc->amr_busycmdcount, sc->amr_workcount); } }