diff --git a/sys/dev/ida/ida.c b/sys/dev/ida/ida.c index 2072ab578182..4b2d6f244f2e 100644 --- a/sys/dev/ida/ida.c +++ b/sys/dev/ida/ida.c @@ -1,529 +1,529 @@ /*- * Copyright (c) 1999,2000 Jonathan Lemon * All rights reserved. * # Derived from the original IDA Compaq RAID driver, which is * Copyright (c) 1996, 1997, 1998, 1999 * Mark Dawson and David James. 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$ */ /* * Generic driver for Compaq SMART RAID adapters. * * Specific probe routines are in: * pci/ida_pci.c * i386/eisa/ida_eisa.c */ #include #include #include #include #include #include #include #include #include #if NPCI > 0 #include #endif #include #include #include #include #include #include /* prototypes */ static void ida_alloc_qcb(struct ida_softc *ida); static void ida_construct_qcb(struct ida_softc *ida); static void ida_start(struct ida_softc *ida); static void ida_done(struct ida_softc *ida, struct ida_qcb *qcb); static void ida_wait(struct ida_softc *ida, struct ida_qcb *qcb, int delay); void ida_free(struct ida_softc *ida) { int i; for (i = 0; i < ida->num_qcbs; i++) bus_dmamap_destroy(ida->buffer_dmat, ida->qcbs[i].dmamap); if (ida->hwqcb_busaddr) bus_dmamap_unload(ida->hwqcb_dmat, ida->hwqcb_dmamap); if (ida->hwqcbs) bus_dmamem_free(ida->hwqcb_dmat, ida->hwqcbs, ida->hwqcb_dmamap); if (ida->buffer_dmat) bus_dma_tag_destroy(ida->buffer_dmat); if (ida->hwqcb_dmat) bus_dma_tag_destroy(ida->hwqcb_dmat); if (ida->qcbs != NULL) free(ida->qcbs, M_DEVBUF); if (ida->ih != NULL) bus_teardown_intr(ida->dev, ida->irq, ida->ih); if (ida->irq != NULL) bus_release_resource(ida->dev, ida->irq_res_type, 0, ida->irq); if (ida->parent_dmat != NULL) bus_dma_tag_destroy(ida->parent_dmat); if (ida->regs != NULL) bus_release_resource(ida->dev, ida->regs_res_type, ida->regs_res_id, ida->regs); } /* * record bus address from bus_dmamap_load */ static void ida_dma_map_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error) { bus_addr_t *baddr; baddr = (bus_addr_t *)arg; *baddr = segs->ds_addr; } static __inline struct ida_qcb * ida_get_qcb(struct ida_softc *ida) { struct ida_qcb *qcb; if ((qcb = SLIST_FIRST(&ida->free_qcbs)) != NULL) { SLIST_REMOVE_HEAD(&ida->free_qcbs, link.sle); } else { ida_alloc_qcb(ida); if ((qcb = SLIST_FIRST(&ida->free_qcbs)) != NULL) SLIST_REMOVE_HEAD(&ida->free_qcbs, link.sle); } return (qcb); } static __inline bus_addr_t idahwqcbvtop(struct ida_softc *ida, struct ida_hardware_qcb *hwqcb) { return (ida->hwqcb_busaddr + ((bus_addr_t)hwqcb - (bus_addr_t)ida->hwqcbs)); } static __inline struct ida_qcb * idahwqcbptov(struct ida_softc *ida, bus_addr_t hwqcb_addr) { struct ida_hardware_qcb *hwqcb; hwqcb = (struct ida_hardware_qcb *) ((bus_addr_t)ida->hwqcbs + (hwqcb_addr - ida->hwqcb_busaddr)); return (hwqcb->qcb); } /* * XXX * since we allocate all QCB space up front during initialization, then * why bother with this routine? */ static void ida_alloc_qcb(struct ida_softc *ida) { struct ida_qcb *qcb; int error; if (ida->num_qcbs >= IDA_QCB_MAX) return; qcb = &ida->qcbs[ida->num_qcbs]; error = bus_dmamap_create(ida->buffer_dmat, /*flags*/0, &qcb->dmamap); if (error != 0) return; qcb->flags = QCB_FREE; qcb->hwqcb = &ida->hwqcbs[ida->num_qcbs]; qcb->hwqcb->qcb = qcb; qcb->hwqcb_busaddr = idahwqcbvtop(ida, qcb->hwqcb); SLIST_INSERT_HEAD(&ida->free_qcbs, qcb, link.sle); ida->num_qcbs++; } int ida_init(struct ida_softc *ida) { int error; ida->unit = device_get_unit(ida->dev); ida->tag = rman_get_bustag(ida->regs); ida->bsh = rman_get_bushandle(ida->regs); SLIST_INIT(&ida->free_qcbs); STAILQ_INIT(&ida->qcb_queue); bioq_init(&ida->bio_queue); ida->qcbs = (struct ida_qcb *) malloc(IDA_QCB_MAX * sizeof(struct ida_qcb), M_DEVBUF, M_NOWAIT); if (ida->qcbs == NULL) return (ENOMEM); bzero(ida->qcbs, IDA_QCB_MAX * sizeof(struct ida_qcb)); /* * Create our DMA tags */ /* DMA tag for our hardware QCB structures */ error = bus_dma_tag_create(ida->parent_dmat, /*alignment*/1, /*boundary*/0, /*lowaddr*/BUS_SPACE_MAXADDR, /*highaddr*/BUS_SPACE_MAXADDR, /*filter*/NULL, /*filterarg*/NULL, IDA_QCB_MAX * sizeof(struct ida_hardware_qcb), /*nsegments*/1, /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT, /*flags*/0, &ida->hwqcb_dmat); if (error) return (ENOMEM); /* DMA tag for mapping buffers into device space */ error = bus_dma_tag_create(ida->parent_dmat, /*alignment*/1, /*boundary*/0, /*lowaddr*/BUS_SPACE_MAXADDR, /*highaddr*/BUS_SPACE_MAXADDR, /*filter*/NULL, /*filterarg*/NULL, /*maxsize*/MAXBSIZE, /*nsegments*/IDA_NSEG, /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT, /*flags*/0, &ida->buffer_dmat); if (error) return (ENOMEM); /* Allocation of hardware QCBs */ /* XXX allocation is rounded to hardware page size */ error = bus_dmamem_alloc(ida->hwqcb_dmat, (void **)&ida->hwqcbs, BUS_DMA_NOWAIT, &ida->hwqcb_dmamap); if (error) return (ENOMEM); /* And permanently map them in */ bus_dmamap_load(ida->hwqcb_dmat, ida->hwqcb_dmamap, ida->hwqcbs, IDA_QCB_MAX * sizeof(struct ida_hardware_qcb), ida_dma_map_cb, &ida->hwqcb_busaddr, /*flags*/0); bzero(ida->hwqcbs, IDA_QCB_MAX * sizeof(struct ida_hardware_qcb)); ida_alloc_qcb(ida); /* allocate an initial qcb */ return (0); } void ida_attach(struct ida_softc *ida) { struct ida_controller_info cinfo; int error, i; ida->cmd.int_enable(ida, 0); error = ida_command(ida, CMD_GET_CTRL_INFO, &cinfo, sizeof(cinfo), IDA_CONTROLLER, DMA_DATA_IN); if (error) { device_printf(ida->dev, "CMD_GET_CTRL_INFO failed.\n"); return; } device_printf(ida->dev, "drives=%d firm_rev=%c%c%c%c\n", cinfo.num_drvs, cinfo.firm_rev[0], cinfo.firm_rev[1], cinfo.firm_rev[2], cinfo.firm_rev[3]); ida->num_drives = cinfo.num_drvs; for (i = 0; i < ida->num_drives; i++) device_add_child(ida->dev, /*"idad"*/NULL, -1); bus_generic_attach(ida->dev); ida->cmd.int_enable(ida, 1); } int ida_detach(device_t dev) { struct ida_softc *ida; int error = 0; ida = (struct ida_softc *)device_get_softc(dev); /* * XXX * before detaching, we must make sure that the system is * quiescent; nothing mounted, no pending activity. */ /* * XXX * now, how are we supposed to maintain a list of our drives? * iterate over our "child devices"? */ ida_free(ida); return (error); } static void ida_setup_dmamap(void *arg, bus_dma_segment_t *segs, int nsegments, int error) { struct ida_hardware_qcb *hwqcb = (struct ida_hardware_qcb *)arg; int i; hwqcb->hdr.size = (sizeof(struct ida_req) + sizeof(struct ida_sgb) * IDA_NSEG) >> 2; for (i = 0; i < nsegments; i++) { hwqcb->seg[i].addr = segs[i].ds_addr; hwqcb->seg[i].length = segs[i].ds_len; } hwqcb->req.sgcount = nsegments; } int ida_command(struct ida_softc *ida, int command, void *data, int datasize, int drive, int flags) { struct ida_hardware_qcb *hwqcb; struct ida_qcb *qcb; bus_dmasync_op_t op; int s; s = splbio(); qcb = ida_get_qcb(ida); splx(s); if (qcb == NULL) { printf("ida_command: out of QCBs"); return (1); } hwqcb = qcb->hwqcb; bzero(hwqcb, sizeof(struct ida_hdr) + sizeof(struct ida_req)); bus_dmamap_load(ida->buffer_dmat, qcb->dmamap, (void *)data, datasize, ida_setup_dmamap, hwqcb, 0); op = qcb->flags & DMA_DATA_IN ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE; bus_dmamap_sync(ida->buffer_dmat, qcb->dmamap, op); hwqcb->hdr.drive = drive; /* XXX */ hwqcb->req.bcount = howmany(datasize, DEV_BSIZE); hwqcb->req.command = command; qcb->flags = flags | IDA_COMMAND; s = splbio(); STAILQ_INSERT_TAIL(&ida->qcb_queue, qcb, link.stqe); ida_start(ida); ida_wait(ida, qcb, 500); splx(s); /* XXX should have status returned here? */ /* XXX have "status pointer" area in QCB? */ return (0); } void ida_submit_buf(struct ida_softc *ida, struct bio *bp) { bioq_insert_tail(&ida->bio_queue, bp); ida_construct_qcb(ida); ida_start(ida); } static void ida_construct_qcb(struct ida_softc *ida) { struct ida_hardware_qcb *hwqcb; struct ida_qcb *qcb; bus_dmasync_op_t op; struct bio *bp; bp = bioq_first(&ida->bio_queue); if (bp == NULL) return; /* no more buffers */ qcb = ida_get_qcb(ida); if (qcb == NULL) return; /* out of resources */ bioq_remove(&ida->bio_queue, bp); qcb->buf = bp; qcb->flags = 0; hwqcb = qcb->hwqcb; bzero(hwqcb, sizeof(struct ida_hdr) + sizeof(struct ida_req)); bus_dmamap_load(ida->buffer_dmat, qcb->dmamap, (void *)bp->bio_data, bp->bio_bcount, ida_setup_dmamap, hwqcb, 0); op = qcb->flags & DMA_DATA_IN ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE; bus_dmamap_sync(ida->buffer_dmat, qcb->dmamap, op); /* * XXX */ { - struct id_softc *drv = (struct id_softc *)bp->bio_driver1; + struct idad_softc *drv = (struct idad_softc *)bp->bio_driver1; hwqcb->hdr.drive = drv->unit; } hwqcb->req.blkno = bp->bio_pblkno; hwqcb->req.bcount = howmany(bp->bio_bcount, DEV_BSIZE); hwqcb->req.command = bp->bio_cmd == BIO_READ ? CMD_READ : CMD_WRITE; STAILQ_INSERT_TAIL(&ida->qcb_queue, qcb, link.stqe); } /* * This routine will be called from ida_intr in order to queue up more * I/O, meaning that we may be in an interrupt context. Hence, we should * not muck around with spl() in this routine. */ static void ida_start(struct ida_softc *ida) { struct ida_qcb *qcb; while ((qcb = STAILQ_FIRST(&ida->qcb_queue)) != NULL) { if (ida->cmd.fifo_full(ida)) break; STAILQ_REMOVE_HEAD(&ida->qcb_queue, link.stqe); /* * XXX * place the qcb on an active list and set a timeout? */ qcb->state = QCB_ACTIVE; ida->cmd.submit(ida, qcb); } } static void ida_wait(struct ida_softc *ida, struct ida_qcb *qcb, int delay) { struct ida_qcb *qcb_done = NULL; bus_addr_t completed; if (ida->flags & IDA_ATTACHED) { if (tsleep((caddr_t)qcb, PRIBIO, "idacmd", delay)) panic("ida_command: timeout waiting for interrupt"); return; } while ((completed = ida->cmd.done(ida)) == 0) { if (delay-- == 0) panic("ida_wait: timeout waiting for completion"); DELAY(10); } qcb_done = idahwqcbptov(ida, completed & ~3); if (qcb_done != qcb) panic("ida_wait: incorrect qcb returned"); ida_done(ida, qcb); return; } void ida_intr(void *data) { struct ida_softc *ida; struct ida_qcb *qcb; bus_addr_t completed; ida = (struct ida_softc *)data; if (ida->cmd.int_pending(ida) == 0) return; /* not our interrupt */ while ((completed = ida->cmd.done(ida)) != 0) { qcb = idahwqcbptov(ida, completed & ~3); if (qcb == NULL || qcb->state != QCB_ACTIVE) { device_printf(ida->dev, "ignoring completion %x\n", completed); continue; } ida_done(ida, qcb); } ida_start(ida); } /* * should switch out command type; may be status, not just I/O. */ static void ida_done(struct ida_softc *ida, struct ida_qcb *qcb) { int error = 0; /* * finish up command */ if (qcb->flags & DMA_DATA_TRANSFER) { bus_dmasync_op_t op; op = qcb->flags & DMA_DATA_IN ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE; bus_dmamap_sync(ida->buffer_dmat, qcb->dmamap, op); bus_dmamap_unload(ida->buffer_dmat, qcb->dmamap); } if (qcb->hwqcb->req.error & SOFT_ERROR) device_printf(ida->dev, "soft error\n"); if (qcb->hwqcb->req.error & HARD_ERROR) { error = 1; device_printf(ida->dev, "hard error\n"); } if (qcb->hwqcb->req.error & CMD_REJECTED) { error = 1; device_printf(ida->dev, "invalid request\n"); } if (qcb->flags & IDA_COMMAND) { if (ida->flags & IDA_ATTACHED) wakeup(qcb); } else { if (error) qcb->buf->bio_flags |= BIO_ERROR; - id_intr(qcb->buf); + idad_intr(qcb->buf); } qcb->state = QCB_FREE; SLIST_INSERT_HEAD(&ida->free_qcbs, qcb, link.sle); ida_construct_qcb(ida); } diff --git a/sys/dev/ida/ida_disk.c b/sys/dev/ida/ida_disk.c index 1b70bfbb5c74..72a6f04055a2 100644 --- a/sys/dev/ida/ida_disk.c +++ b/sys/dev/ida/ida_disk.c @@ -1,279 +1,276 @@ /*- * Copyright (c) 1999,2000 Jonathan Lemon * 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$ */ /* * Disk driver for Compaq SMART RAID adapters. */ #include #include #include #include #include #include #include #include #if NPCI > 0 #include #endif #include #include #include #include #include #include /* prototypes */ -static int idprobe(device_t dev); -static int idattach(device_t dev); -static int iddetach(device_t dev); +static int idad_probe(device_t dev); +static int idad_attach(device_t dev); +static int idad_detach(device_t dev); -static d_open_t idopen; -static d_close_t idclose; -static d_strategy_t idstrategy; +static d_open_t idad_open; +static d_close_t idad_close; +static d_strategy_t idad_strategy; -#define ID_BDEV_MAJOR 29 -#define ID_CDEV_MAJOR 109 - -#define WD_BDEV_MAJOR 0 -#define WD_CDEV_MAJOR 3 +#define IDAD_BDEV_MAJOR 29 +#define IDAD_CDEV_MAJOR 109 static struct cdevsw id_cdevsw = { - /* open */ idopen, - /* close */ idclose, + /* open */ idad_open, + /* close */ idad_close, /* read */ physread, /* write */ physwrite, /* ioctl */ noioctl, /* poll */ nopoll, /* mmap */ nommap, - /* strategy */ idstrategy, - /* name */ "id", - /* maj */ ID_CDEV_MAJOR, + /* strategy */ idad_strategy, + /* name */ "idad", + /* maj */ IDAD_CDEV_MAJOR, /* dump */ nodump, /* psize */ nopsize, /* flags */ D_DISK, - /* bmaj */ ID_BDEV_MAJOR + /* bmaj */ IDAD_BDEV_MAJOR }; -static devclass_t id_devclass; -static struct cdevsw iddisk_cdevsw; +static devclass_t idad_devclass; +static struct cdevsw idaddisk_cdevsw; static int disks_registered = 0; -static device_method_t id_methods[] = { - DEVMETHOD(device_probe, idprobe), - DEVMETHOD(device_attach, idattach), - DEVMETHOD(device_detach, iddetach), +static device_method_t idad_methods[] = { + DEVMETHOD(device_probe, idad_probe), + DEVMETHOD(device_attach, idad_attach), + DEVMETHOD(device_detach, idad_detach), { 0, 0 } }; -static driver_t id_driver = { +static driver_t idad_driver = { "idad", - id_methods, - sizeof(struct id_softc) + idad_methods, + sizeof(struct idad_softc) }; -static __inline struct id_softc * -idgetsoftc(dev_t dev) +DRIVER_MODULE(idad, ida, idad_driver, idad_devclass, 0, 0); + +static __inline struct idad_softc * +idad_getsoftc(dev_t dev) { - return ((struct id_softc *)dev->si_drv1); + return ((struct idad_softc *)dev->si_drv1); } static int -idopen(dev_t dev, int flags, int fmt, struct proc *p) +idad_open(dev_t dev, int flags, int fmt, struct proc *p) { - struct id_softc *drv; + struct idad_softc *drv; struct disklabel *label; - drv = idgetsoftc(dev); + drv = idad_getsoftc(dev); if (drv == NULL) return (ENXIO); label = &drv->disk.d_label; bzero(label, sizeof(*label)); label->d_type = DTYPE_SCSI; label->d_secsize = drv->secsize; label->d_nsectors = drv->sectors; label->d_ntracks = drv->heads; label->d_ncylinders = drv->cylinders; label->d_secpercyl = drv->sectors * drv->heads; label->d_secperunit = drv->secperunit; return (0); } static int -idclose(dev_t dev, int flags, int fmt, struct proc *p) +idad_close(dev_t dev, int flags, int fmt, struct proc *p) { - struct id_softc *drv; + struct idad_softc *drv; - drv = idgetsoftc(dev); + drv = idad_getsoftc(dev); if (drv == NULL) return (ENXIO); return (0); } /* * Read/write routine for a buffer. Finds the proper unit, range checks * arguments, and schedules the transfer. Does not wait for the transfer * to complete. Multi-page transfers are supported. All I/O requests must * be a multiple of a sector in length. */ static void -idstrategy(struct bio *bp) +idad_strategy(struct bio *bp) { - struct id_softc *drv; + struct idad_softc *drv; int s; - drv = idgetsoftc(bp->bio_dev); + drv = idad_getsoftc(bp->bio_dev); if (drv == NULL) { bp->bio_error = EINVAL; goto bad; } /* * software write protect check */ if (drv->flags & DRV_WRITEPROT && (bp->bio_cmd == BIO_WRITE)) { bp->bio_error = EROFS; goto bad; } /* * If it's a null transfer, return immediately */ if (bp->bio_bcount == 0) goto done; bp->bio_driver1 = drv; s = splbio(); devstat_start_transaction(&drv->stats); ida_submit_buf(drv->controller, bp); splx(s); return; bad: bp->bio_flags |= BIO_ERROR; done: /* * Correctly set the buf to indicate a completed transfer */ bp->bio_resid = bp->bio_bcount; biodone(bp); return; } void -id_intr(struct bio *bp) +idad_intr(struct bio *bp) { - struct id_softc *drv = (struct id_softc *)bp->bio_driver1; + struct idad_softc *drv = (struct idad_softc *)bp->bio_driver1; if (bp->bio_flags & BIO_ERROR) bp->bio_error = EIO; else bp->bio_resid = 0; devstat_end_transaction_bio(&drv->stats, bp); biodone(bp); } static int -idprobe(device_t dev) +idad_probe(device_t dev) { device_set_desc(dev, "Compaq Logical Drive"); return (0); } static int -idattach(device_t dev) +idad_attach(device_t dev) { struct ida_drive_info dinfo; - struct id_softc *drv; + struct idad_softc *drv; device_t parent; dev_t dsk; int error; - drv = (struct id_softc *)device_get_softc(dev); + drv = (struct idad_softc *)device_get_softc(dev); parent = device_get_parent(dev); drv->controller = (struct ida_softc *)device_get_softc(parent); drv->unit = device_get_unit(dev); error = ida_command(drv->controller, CMD_GET_LOG_DRV_INFO, &dinfo, sizeof(dinfo), drv->unit, DMA_DATA_IN); if (error) { device_printf(dev, "CMD_GET_LOG_DRV_INFO failed\n"); return (ENXIO); } drv->cylinders = dinfo.ncylinders; drv->heads = dinfo.nheads; drv->sectors = dinfo.nsectors; drv->secsize = dinfo.secsize; drv->secperunit = dinfo.secperunit; /* XXX * other initialization */ device_printf(dev, "%uMB (%u sectors), blocksize=%d\n", drv->secperunit / ((1024 * 1024) / drv->secsize), drv->secperunit, drv->secsize); devstat_add_entry(&drv->stats, "idad", drv->unit, drv->secsize, DEVSTAT_NO_ORDERED_TAGS, DEVSTAT_TYPE_STORARRAY| DEVSTAT_TYPE_IF_OTHER, DEVSTAT_PRIORITY_ARRAY); dsk = disk_create(drv->unit, &drv->disk, 0, - &id_cdevsw, &iddisk_cdevsw); + &id_cdevsw, &idaddisk_cdevsw); dsk->si_drv1 = drv; dsk->si_iosize_max = DFLTPHYS; /* XXX guess? */ disks_registered++; return (0); } static int -iddetach(device_t dev) +idad_detach(device_t dev) { - struct id_softc *drv; + struct idad_softc *drv; - drv = (struct id_softc *)device_get_softc(dev); + drv = (struct idad_softc *)device_get_softc(dev); devstat_remove_entry(&drv->stats); if (--disks_registered == 0) - cdevsw_remove(&iddisk_cdevsw); + cdevsw_remove(&idaddisk_cdevsw); return (0); } - -DRIVER_MODULE(idad, ida, id_driver, id_devclass, 0, 0); diff --git a/sys/dev/ida/idavar.h b/sys/dev/ida/idavar.h index 50335ab788b1..0e3db00a23bb 100644 --- a/sys/dev/ida/idavar.h +++ b/sys/dev/ida/idavar.h @@ -1,200 +1,200 @@ /*- * Copyright (c) 1999,2000 Jonathan Lemon * 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$ */ /* * software structures for the Compaq RAID controller */ #ifndef _IDAVAR_H #define _IDAVAR_H #define ida_inb(ida, port) \ bus_space_read_1((ida)->tag, (ida)->bsh, port) #define ida_inw(ida, port) \ bus_space_read_2((ida)->tag, (ida)->bsh, port) #define ida_inl(ida, port) \ bus_space_read_4((ida)->tag, (ida)->bsh, port) #define ida_outb(ida, port, val) \ bus_space_write_1((ida)->tag, (ida)->bsh, port, val) #define ida_outw(ida, port, val) \ bus_space_write_2((ida)->tag, (ida)->bsh, port, val) #define ida_outl(ida, port, val) \ bus_space_write_4((ida)->tag, (ida)->bsh, port, val) struct ida_hdr { u_int8_t drive; /* logical drive */ u_int8_t priority; /* block priority */ u_int16_t size; /* size of request, in words */ }; struct ida_req { u_int16_t next; /* offset of next request */ u_int8_t command; /* command */ u_int8_t error; /* return error code */ u_int32_t blkno; /* block number */ u_int16_t bcount; /* block count */ u_int8_t sgcount; /* number of scatter/gather entries */ u_int8_t spare; /* reserved */ }; struct ida_sgb { u_int32_t length; /* length of S/G segment */ u_int32_t addr; /* physical address of block */ }; #define IDA_NSEG 32 /* maximum number of segments */ /* * right now, this structure totals 276 bytes. */ struct ida_hardware_qcb { struct ida_hdr hdr; /* 4 */ struct ida_req req; /* 12 */ struct ida_sgb seg[IDA_NSEG]; /* 256 */ struct ida_qcb *qcb; /* 4 - qcb backpointer */ }; typedef enum { QCB_FREE = 0x0000, QCB_ACTIVE = 0x0001, /* waiting for completion */ } qcb_state; #define DMA_DATA_IN 0x0001 #define DMA_DATA_OUT 0x0002 #define IDA_COMMAND 0x0004 #define DMA_DATA_TRANSFER (DMA_DATA_IN | DMA_DATA_OUT) #define IDA_QCB_MAX 256 #define IDA_CONTROLLER 0 /* drive "number" for controller */ struct ida_qcb { struct ida_hardware_qcb *hwqcb; qcb_state state; short flags; union { STAILQ_ENTRY(ida_qcb) stqe; SLIST_ENTRY(ida_qcb) sle; } link; bus_dmamap_t dmamap; bus_addr_t hwqcb_busaddr; struct bio *buf; /* bio associated with qcb */ }; struct ida_softc; struct ida_access { int (*fifo_full)(struct ida_softc *); void (*submit)(struct ida_softc *, struct ida_qcb *); bus_addr_t (*done)(struct ida_softc *); int (*int_pending)(struct ida_softc *); void (*int_enable)(struct ida_softc *, int); }; /* * flags for the controller */ #define IDA_ATTACHED 0x01 /* attached, interrupts okay */ struct ida_softc { device_t dev; int unit; int regs_res_type; int regs_res_id; struct resource *regs; int irq_res_type; struct resource *irq; void *ih; bus_space_tag_t tag; bus_space_handle_t bsh; /* various DMA tags */ bus_dma_tag_t parent_dmat; bus_dma_tag_t buffer_dmat; bus_dma_tag_t hwqcb_dmat; bus_dmamap_t hwqcb_dmamap; bus_addr_t hwqcb_busaddr; bus_dma_tag_t sg_dmat; int num_drives; int num_qcbs; int flags; struct ida_hardware_qcb *hwqcbs; /* HW QCB array */ struct ida_qcb *qcbs; /* kernel QCB array */ SLIST_HEAD(, ida_qcb) free_qcbs; STAILQ_HEAD(, ida_qcb) qcb_queue; struct bio_queue_head bio_queue; struct ida_access cmd; }; /* * drive flags */ #define DRV_WRITEPROT 0x0001 -struct id_softc { +struct idad_softc { device_t dev; struct ida_softc *controller; struct disk disk; struct devstat stats; int unit; int cylinders; int heads; int sectors; int secsize; int secperunit; int flags; }; struct ida_board { u_int32_t board; char *desc; struct ida_access *accessor; }; extern int ida_detach(device_t dev); extern struct ida_softc *ida_alloc(device_t dev, struct resource *regs, int regs_type, int regs_id, bus_dma_tag_t parent_dmat); extern void ida_free(struct ida_softc *ida); extern int ida_init(struct ida_softc *ida); extern void ida_attach(struct ida_softc *ida); extern int ida_command(struct ida_softc *ida, int command, void *data, int datasize, int drive, int flags); extern void ida_submit_buf(struct ida_softc *ida, struct bio *bp); extern void ida_intr(void *data); -extern void id_intr(struct bio *bp); +extern void idad_intr(struct bio *bp); #endif /* _IDAVAR_H */