Edit
IABSD.fr/src/sys/dev/isa/wds.c
naddy
- sys/dev/isa/wds.c
-
/* $OpenBSD: wds.c,v 1.59 2022/04/16 19:19:59 naddy Exp $ */ /* $NetBSD: wds.c,v 1.13 1996/11/03 16:20:31 mycroft Exp $ */ #undef WDSDIAG #ifdef DDB #define integrate #else #define integrate static inline #endif /* * XXX * sense data * aborts * resets */ /* * Copyright (c) 1994, 1995 Julian Highfield. All rights reserved. * Portions copyright (c) 1994, 1996 Charles M. Hannum. 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. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Julian Highfield. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * This driver is for the WD7000 family of SCSI controllers: * the WD7000-ASC, a bus-mastering DMA controller, * the WD7000-FASST2, an -ASC with new firmware and scatter-gather, * and the WD7000-ASE, which was custom manufactured for Apollo * workstations and seems to include an -ASC as well as floppy * and ESDI interfaces. * * Loosely based on Theo Deraadt's unfinished attempt says the NetBSD group * so they decided to delete the copyright that file had on it. */ #include <sys/param.h> #include <sys/systm.h> #include <sys/kernel.h> #include <sys/errno.h> #include <sys/ioctl.h> #include <sys/device.h> #include <sys/malloc.h> #include <sys/buf.h> #include <uvm/uvm_extern.h> #include <machine/bus.h> #include <machine/intr.h> #include <scsi/scsi_all.h> #include <scsi/scsiconf.h> #include <dev/isa/isavar.h> #include <dev/isa/isadmavar.h> #include <dev/isa/wdsreg.h> #define WDS_MBX_SIZE 16 #define WDS_SCB_MAX 32 #define SCB_HASH_SIZE 32 /* hash table size for phystokv */ #define SCB_HASH_SHIFT 9 #define SCB_HASH(x) ((((long)(x))>>SCB_HASH_SHIFT) & (SCB_HASH_SIZE - 1)) #define wds_nextmbx(wmb, mbx, mbio) \ if ((wmb) == &(mbx)->mbio[WDS_MBX_SIZE - 1]) \ (wmb) = &(mbx)->mbio[0]; \ else \ (wmb)++; struct wds_mbx { struct wds_mbx_out mbo[WDS_MBX_SIZE]; struct wds_mbx_in mbi[WDS_MBX_SIZE]; struct wds_mbx_out *cmbo; /* Collection Mail Box out */ struct wds_mbx_out *tmbo; /* Target Mail Box out */ struct wds_mbx_in *tmbi; /* Target Mail Box in */ }; #define KVTOPHYS(x) vtophys((vaddr_t)(x)) struct wds_softc { struct device sc_dev; struct isadev sc_id; void *sc_ih; bus_space_tag_t sc_iot; /* bus identifier */ bus_space_handle_t sc_ioh; /* io handle */ int sc_irq, sc_drq; int sc_revision; struct wds_mbx sc_mbx; #define wmbx (&sc->sc_mbx) struct wds_scb *sc_scbhash[SCB_HASH_SIZE]; TAILQ_HEAD(, wds_scb) sc_free_scb, sc_waiting_scb; int sc_numscbs, sc_mbofull; int sc_scsi_dev; struct mutex sc_scb_mtx; struct scsi_iopool sc_iopool; }; /* Define the bounce buffer length... */ #define BUFLEN (64*1024) /* ..and how many there are. One per device! Non-FASST boards need these. */ #define BUFCNT 8 /* The macro for deciding whether the board needs a buffer. */ #define NEEDBUFFER(sc) (sc->sc_revision < 0x800) struct wds_buf { u_char data[BUFLEN]; int busy; TAILQ_ENTRY(wds_buf) chain; } wds_buffer[BUFCNT]; TAILQ_HEAD(, wds_buf) wds_free_buffer; #ifdef WDSDEBUG int wds_debug = WDSDEBUG; #endif integrate void wds_wait(bus_space_tag_t, bus_space_handle_t, int, int, int); int wds_cmd(struct wds_softc *, u_char *, int); integrate void wds_finish_scbs(struct wds_softc *); int wdsintr(void *); integrate void wds_reset_scb(struct wds_softc *, struct wds_scb *); void wds_scb_free(void *, void *); void wds_free_buf(struct wds_softc *, struct wds_buf *); integrate void wds_init_scb(struct wds_softc *, struct wds_scb *); void *wds_scb_alloc(void *); struct wds_buf *wds_get_buf(struct wds_softc *, int); struct wds_scb *wds_scb_phys_kv(struct wds_softc *, u_long); void wds_queue_scb(struct wds_softc *, struct wds_scb *); void wds_collect_mbo(struct wds_softc *); void wds_start_scbs(struct wds_softc *); void wds_done(struct wds_softc *, struct wds_scb *, u_char); int wds_find(struct isa_attach_args *, struct wds_softc *); void wds_init(struct wds_softc *); void wds_inquire_setup_information(struct wds_softc *); void wds_scsi_cmd(struct scsi_xfer *); void wds_sense(struct wds_softc *, struct wds_scb *); int wds_poll(struct wds_softc *, struct scsi_xfer *, int); int wds_ipoll(struct wds_softc *, struct wds_scb *, int); void wds_timeout(void *); int wdsprint(void *, const char *); const struct scsi_adapter wds_switch = { wds_scsi_cmd, NULL, NULL, NULL, NULL }; int wdsprobe(struct device *, void *, void *); void wdsattach(struct device *, struct device *, void *); const struct cfattach wds_ca = { sizeof(struct wds_softc), wdsprobe, wdsattach }; struct cfdriver wds_cd = { NULL, "wds", DV_DULL }; #define WDS_ABORT_TIMEOUT 2000 /* time to wait for abort (mSec) */ integrate void wds_wait(bus_space_tag_t iot, bus_space_handle_t ioh, int port, int mask, int val) { while ((bus_space_read_1(iot, ioh, port) & mask) != val) ; } /* * Write a command to the board's I/O ports. */ int wds_cmd(struct wds_softc *sc, u_int8_t *ibuf, int icnt) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; u_int8_t c; wds_wait(iot, ioh, WDS_STAT, WDSS_RDY, WDSS_RDY); while (icnt--) { bus_space_write_1(iot, ioh, WDS_CMD, *ibuf++); wds_wait(iot, ioh, WDS_STAT, WDSS_RDY, WDSS_RDY); c = bus_space_read_1(iot, ioh, WDS_STAT); if (c & WDSS_REJ) return 1; } return 0; } /* * Check for the presence of a WD7000 SCSI controller. */ int wdsprobe(struct device *parent, void *match, void *aux) { register struct isa_attach_args *ia = aux; bus_space_tag_t iot = ia->ia_iot; bus_space_handle_t ioh; int rv; if (bus_space_map(iot, ia->ia_iobase, WDS_IO_PORTS, 0, &ioh)) return (0); /* See if there is a unit at this location. */ rv = wds_find(ia, NULL); bus_space_unmap(iot, ioh, WDS_IO_PORTS); if (rv) { ia->ia_msize = 0; ia->ia_iosize = WDS_IO_PORTS; } return (rv); } int wdsprint(void *aux, const char *name) { if (name != NULL) printf("%s: scsibus ", name); return UNCONF; } /* * Attach all available units. */ void wdsattach(struct device *parent, struct device *self, void *aux) { struct isa_attach_args *ia = aux; struct wds_softc *sc = (void *)self; struct scsibus_attach_args saa; bus_space_tag_t iot = ia->ia_iot; bus_space_handle_t ioh; if (bus_space_map(iot, ia->ia_iobase, WDS_IO_PORTS, 0, &ioh)) { printf("%s: can't map i/o space\n", sc->sc_dev.dv_xname); return; } if (!wds_find(ia, sc)) panic("wdsattach: wds_find of %s failed", self->dv_xname); wds_init(sc); if (sc->sc_drq != DRQUNK) isadma_cascade(sc->sc_drq); TAILQ_INIT(&sc->sc_free_scb); TAILQ_INIT(&sc->sc_waiting_scb); mtx_init(&sc->sc_scb_mtx, IPL_BIO); scsi_iopool_init(&sc->sc_iopool, sc, wds_scb_alloc, wds_scb_free); wds_inquire_setup_information(sc); sc->sc_ih = isa_intr_establish(ia->ia_ic, sc->sc_irq, IST_EDGE, IPL_BIO, wdsintr, sc, sc->sc_dev.dv_xname); /* XXX */ /* I don't think the -ASE can handle openings > 1. */ /* It gives Vendor Error 26 whenever I try it. */ saa.saa_adapter_softc = sc; saa.saa_adapter_target = sc->sc_scsi_dev; saa.saa_adapter = &wds_switch; saa.saa_luns = saa.saa_adapter_buswidth = 8; saa.saa_openings = 1; saa.saa_pool = &sc->sc_iopool; saa.saa_quirks = saa.saa_flags = 0; saa.saa_wwpn = saa.saa_wwnn = 0; config_found(self, &saa, wdsprint); } integrate void wds_finish_scbs(struct wds_softc *sc) { struct wds_mbx_in *wmbi; struct wds_scb *scb; int i; wmbi = wmbx->tmbi; if (wmbi->stat == WDS_MBI_FREE) { for (i = 0; i < WDS_MBX_SIZE; i++) { if (wmbi->stat != WDS_MBI_FREE) { printf("%s: mbi not in round-robin order\n", sc->sc_dev.dv_xname); goto AGAIN; } wds_nextmbx(wmbi, wmbx, mbi); } #ifdef WDSDIAGnot printf("%s: mbi interrupt with no full mailboxes\n", sc->sc_dev.dv_xname); #endif return; } AGAIN: do { scb = wds_scb_phys_kv(sc, phystol(wmbi->scb_addr)); if (!scb) { printf("%s: bad mbi scb pointer; skipping\n", sc->sc_dev.dv_xname); goto next; } #ifdef WDSDEBUG if (wds_debug) { u_int8_t *cp = (u_int8_t *)&scb->cmd.scb; printf("op=%x %x %x %x %x %x\n", cp[0], cp[1], cp[2], cp[3], cp[4], cp[5]); printf("stat %x for mbi addr = %p, ", wmbi->stat, wmbi); printf("scb addr = %p\n", scb); } #endif /* WDSDEBUG */ timeout_del(&scb->xs->stimeout); wds_done(sc, scb, wmbi->stat); next: wmbi->stat = WDS_MBI_FREE; wds_nextmbx(wmbi, wmbx, mbi); } while (wmbi->stat != WDS_MBI_FREE); wmbx->tmbi = wmbi; } /* * Process an interrupt. */ int wdsintr(void *arg) { struct wds_softc *sc = arg; bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; u_char c; /* Was it really an interrupt from the board? */ if ((bus_space_read_1(iot, ioh, WDS_STAT) & WDSS_IRQ) == 0) return 0; /* Get the interrupt status byte. */ c = bus_space_read_1(iot, ioh, WDS_IRQSTAT) & WDSI_MASK; /* Acknowledge (which resets) the interrupt. */ bus_space_write_1(iot, ioh, WDS_IRQACK, 0x00); switch (c) { case WDSI_MSVC: wds_finish_scbs(sc); break; case WDSI_MFREE: wds_start_scbs(sc); break; default: printf("%s: unrecognized interrupt type %02x", sc->sc_dev.dv_xname, c); break; } return 1; } integrate void wds_reset_scb(struct wds_softc *sc, struct wds_scb *scb) { scb->flags = 0; } /* * Free the command structure, the outgoing mailbox and the data buffer. */ void wds_scb_free(void *xsc, void *xscb) { struct wds_softc *sc = xsc; struct wds_scb *scb = xscb; if (scb->buf) { wds_free_buf(sc, scb->buf); scb->buf = NULL; } wds_reset_scb(sc, scb); mtx_enter(&sc->sc_scb_mtx); TAILQ_INSERT_HEAD(&sc->sc_free_scb, scb, chain); mtx_leave(&sc->sc_scb_mtx); } void wds_free_buf(struct wds_softc *sc, struct wds_buf *buf) { int s; s = splbio(); buf->busy = 0; TAILQ_INSERT_HEAD(&wds_free_buffer, buf, chain); /* * If there were none, wake anybody waiting for one to come free, * starting with queued entries. */ if (TAILQ_NEXT(buf, chain) == NULL) wakeup(&wds_free_buffer); splx(s); } integrate void wds_init_scb(struct wds_softc *sc, struct wds_scb *scb) { int hashnum; bzero(scb, sizeof(struct wds_scb)); /* * put in the phystokv hash table * Never gets taken out. */ scb->hashkey = KVTOPHYS(scb); hashnum = SCB_HASH(scb->hashkey); scb->nexthash = sc->sc_scbhash[hashnum]; sc->sc_scbhash[hashnum] = scb; wds_reset_scb(sc, scb); } /* * Get a free scb */ void * wds_scb_alloc(void *xsc) { struct wds_softc *sc = xsc; struct wds_scb *scb; mtx_enter(&sc->sc_scb_mtx); scb = TAILQ_FIRST(&sc->sc_free_scb); if (scb) { TAILQ_REMOVE(&sc->sc_free_scb, scb, chain); scb->flags |= SCB_ALLOC; } mtx_leave(&sc->sc_scb_mtx); return (scb); } struct wds_buf * wds_get_buf(struct wds_softc *sc, int flags) { struct wds_buf *buf; int s; s = splbio(); for (;;) { buf = TAILQ_FIRST(&wds_free_buffer); if (buf) { TAILQ_REMOVE(&wds_free_buffer, buf, chain); break; } if ((flags & SCSI_NOSLEEP) != 0) goto out; tsleep_nsec(&wds_free_buffer, PRIBIO, "wdsbuf", INFSLP); } buf->busy = 1; out: splx(s); return (buf); } struct wds_scb * wds_scb_phys_kv(struct wds_softc *sc, u_long scb_phys) { int hashnum = SCB_HASH(scb_phys); struct wds_scb *scb = sc->sc_scbhash[hashnum]; while (scb) { if (scb->hashkey == scb_phys) break; /* XXX Check to see if it matches the sense command block. */ if (scb->hashkey == (scb_phys - sizeof(struct wds_cmd))) break; scb = scb->nexthash; } return scb; } /* * Queue a SCB to be sent to the controller, and send it if possible. */ void wds_queue_scb(struct wds_softc *sc, struct wds_scb *scb) { TAILQ_INSERT_TAIL(&sc->sc_waiting_scb, scb, chain); wds_start_scbs(sc); } /* * Garbage collect mailboxes that are no longer in use. */ void wds_collect_mbo(struct wds_softc *sc) { struct wds_mbx_out *wmbo; /* Mail Box Out pointer */ #ifdef WDSDIAG struct wds_scb *scb; #endif wmbo = wmbx->cmbo; while (sc->sc_mbofull > 0) { if (wmbo->cmd != WDS_MBO_FREE) break; #ifdef WDSDIAG scb = wds_scb_phys_kv(sc, phystol(wmbo->scb_addr)); scb->flags &= ~SCB_SENDING; #endif --sc->sc_mbofull; wds_nextmbx(wmbo, wmbx, mbo); } wmbx->cmbo = wmbo; } /* * Send as many SCBs as we have empty mailboxes for. */ void wds_start_scbs(struct wds_softc *sc) { struct wds_mbx_out *wmbo; /* Mail Box Out pointer */ struct wds_scb *scb; u_char c; wmbo = wmbx->tmbo; while ((scb = TAILQ_FIRST(&sc->sc_waiting_scb)) != NULL) { if (sc->sc_mbofull >= WDS_MBX_SIZE) { wds_collect_mbo(sc); if (sc->sc_mbofull >= WDS_MBX_SIZE) { c = WDSC_IRQMFREE; wds_cmd(sc, &c, sizeof c); break; } } TAILQ_REMOVE(&sc->sc_waiting_scb, scb, chain); #ifdef WDSDIAG scb->flags |= SCB_SENDING; #endif timeout_set(&scb->xs->stimeout, wds_timeout, scb); /* Link scb to mbo. */ if (scb->flags & SCB_SENSE) ltophys(KVTOPHYS(&scb->sense), wmbo->scb_addr); else ltophys(KVTOPHYS(&scb->cmd), wmbo->scb_addr); /* XXX What about aborts? */ wmbo->cmd = WDS_MBO_START; /* Tell the card to poll immediately. */ c = WDSC_MSTART(wmbo - wmbx->mbo); wds_cmd(sc, &c, sizeof c); if ((scb->flags & SCB_POLLED) == 0) timeout_add_msec(&scb->xs->stimeout, scb->timeout); ++sc->sc_mbofull; wds_nextmbx(wmbo, wmbx, mbo); } wmbx->tmbo = wmbo; } /* * Process the result of a SCSI command. */ void wds_done(struct wds_softc *sc, struct wds_scb *scb, u_int8_t stat) { struct scsi_xfer *xs = scb->xs; /* XXXXX */ /* Don't release the SCB if it was an internal command. */ if (xs == 0) { scb->flags |= SCB_DONE; return; } /* Sense handling. */ if (xs->error == XS_SENSE) { bcopy(&scb->sense_data, &xs->sense, sizeof (struct scsi_sense_data)); } else { if (xs->error == XS_NOERROR) { /* If all went well, or an error is acceptable. */ if (stat == WDS_MBI_OK) { /* OK, set the result */ xs->resid = 0; } else { /* Check the mailbox status. */ switch (stat) { case WDS_MBI_OKERR: /* SCSI error recorded in scb, counts as WDS_MBI_OK */ switch (scb->cmd.venderr) { case 0x00: printf("%s: Is this an error?\n", sc->sc_dev.dv_xname); xs->error = XS_DRIVER_STUFFUP; /* Experiment */ break; case 0x01: /*printf("%s: OK, see SCSI error field.\n", sc->sc_dev.dv_xname);*/ if (scb->cmd.stat == SCSI_CHECK) { /* Do sense. */ wds_sense (sc, scb); return; } else if (scb->cmd.stat == SCSI_BUSY) { xs->error = XS_BUSY; } break; case 0x40: /*printf("%s: DMA underrun!\n", sc->sc_dev.dv_xname);*/ /* Hits this if the target returns fewer that datalen bytes (eg my CD-ROM, which returns a short version string, or if DMA is turned off etc. */ xs->resid = 0; break; default: printf("%s: VENDOR ERROR %02x, scsi %02x\n", sc->sc_dev.dv_xname, scb->cmd.venderr, scb->cmd.stat); xs->error = XS_DRIVER_STUFFUP; /* Experiment */ break; } break; case WDS_MBI_ETIME: /* * The documentation isn't clear on * what conditions might generate this, * but selection timeouts are the only * one I can think of. */ xs->error = XS_SELTIMEOUT; break; case WDS_MBI_ERESET: case WDS_MBI_ETARCMD: case WDS_MBI_ERESEL: case WDS_MBI_ESEL: case WDS_MBI_EABORT: case WDS_MBI_ESRESET: case WDS_MBI_EHRESET: xs->error = XS_DRIVER_STUFFUP; break; } } } /* else sense */ if (NEEDBUFFER(sc) && xs->datalen) { if (xs->flags & SCSI_DATA_IN) bcopy(scb->buf->data, xs->data, xs->datalen); } } /* XS_NOERROR */ scsi_done(xs); } int wds_find(struct isa_attach_args *ia, struct wds_softc *sc) { bus_space_tag_t iot = ia->ia_iot; bus_space_handle_t ioh = ia->ia_ioh; u_char c; int i; /* * Sending a command causes the CMDRDY bit to clear. */ c = bus_space_read_1(iot, ioh, WDS_STAT); for (i = 0; i < 4; i++) { if ((bus_space_read_1(iot, ioh, WDS_STAT) & WDSS_RDY) != 0) goto ready; delay(10); } return (0); ready: bus_space_write_1(iot, ioh, WDS_CMD, WDSC_NOOP); if (bus_space_read_1(iot, ioh, WDS_STAT) & WDSS_RDY) return (0); bus_space_write_1(iot, ioh, WDS_HCR, WDSH_SCSIRESET|WDSH_ASCRESET); delay(10000); bus_space_write_1(iot, ioh, WDS_HCR, 0x00); delay(500000); wds_wait(iot, ioh, WDS_STAT, WDSS_RDY, WDSS_RDY); if (bus_space_read_1(iot, ioh, WDS_IRQSTAT) != 1) if (bus_space_read_1(iot, ioh, WDS_IRQSTAT) != 7) printf("%s: failed reset!!! %2x\n", sc ? sc->sc_dev.dv_xname : "wds?", bus_space_read_1(iot, ioh, WDS_IRQSTAT)); if ((bus_space_read_1(iot, ioh, WDS_STAT) & (WDSS_RDY)) != WDSS_RDY) { printf("%s: waiting for controller to become ready.", sc ? sc->sc_dev.dv_xname : "wds?"); for (i = 0; i < 20; i++) { if ((bus_space_read_1(iot, ioh, WDS_STAT) & (WDSS_RDY)) == WDSS_RDY) break; printf("."); delay(10000); } if ((bus_space_read_1(iot, ioh, WDS_STAT) & (WDSS_RDY)) != WDSS_RDY) { printf(" failed\n"); return (0); } printf("\n"); } if (sc != NULL) { /* XXX Can we do this better? */ /* who are we on the scsi bus? */ sc->sc_scsi_dev = 7; sc->sc_iot = iot; sc->sc_ioh = ioh; sc->sc_irq = ia->ia_irq; sc->sc_drq = ia->ia_drq; } return (1); } /* * Initialise the board and driver. */ void wds_init(struct wds_softc *sc) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; struct wds_setup init; u_char c; int i; /* * Set up initial mail box for round-robin operation. */ for (i = 0; i < WDS_MBX_SIZE; i++) { wmbx->mbo[i].cmd = WDS_MBO_FREE; wmbx->mbi[i].stat = WDS_MBI_FREE; } wmbx->cmbo = wmbx->tmbo = &wmbx->mbo[0]; wmbx->tmbi = &wmbx->mbi[0]; sc->sc_mbofull = 0; /* Clear the buffers. */ TAILQ_INIT(&wds_free_buffer); for (i = 0; i < BUFCNT; i++) { wds_buffer[i].busy = 0; TAILQ_INSERT_HEAD(&wds_free_buffer, &wds_buffer[i], chain); } init.opcode = WDSC_INIT; init.scsi_id = sc->sc_scsi_dev; /* Record scsi id of controller for use in scsi_attach */ sc->sc_scsi_dev = init.scsi_id; init.buson_t = 48; init.busoff_t = 24; init.xx = 0; ltophys(KVTOPHYS(wmbx), init.mbaddr); init.nomb = init.nimb = WDS_MBX_SIZE; wds_cmd(sc, (u_char *)&init, sizeof init); wds_wait(iot, ioh, WDS_STAT, WDSS_INIT, WDSS_INIT); c = WDSC_DISUNSOL; wds_cmd(sc, &c, sizeof c); bus_space_write_1(iot, ioh, WDS_HCR, WDSH_DRQEN); } /* * Read the board's firmware revision information. */ void wds_inquire_setup_information(struct wds_softc *sc) { struct wds_scb *scb; u_char *j; int s; scb = scsi_io_get(&sc->sc_iopool, SCSI_NOSLEEP); if (scb == NULL) { printf("%s: no request slot available in getvers()!\n", sc->sc_dev.dv_xname); return; } scb->xs = NULL; scb->timeout = 40; bzero(&scb->cmd, sizeof scb->cmd); scb->cmd.write = 0x80; scb->cmd.opcode = WDSX_GETFIRMREV; /* Will poll card, await result. */ bus_space_write_1(sc->sc_iot, sc->sc_ioh, WDS_HCR, WDSH_DRQEN); scb->flags |= SCB_POLLED; s = splbio(); wds_queue_scb(sc, scb); splx(s); if (wds_ipoll(sc, scb, scb->timeout)) goto out; /* Print the version number. */ printf(": version %x.%02x ", scb->cmd.targ, scb->cmd.scb.opcode); sc->sc_revision = (scb->cmd.targ << 8) | scb->cmd.scb.opcode; /* Print out the version string. */ j = 2 + &(scb->cmd.targ); while ((*j >= 32) && (*j < 128)) { printf("%c", *j); j++; } out: printf("\n"); scsi_io_put(&sc->sc_iopool, scb); } /* * Send a SCSI command. */ void wds_scsi_cmd(struct scsi_xfer *xs) { struct scsi_link *sc_link = xs->sc_link; struct wds_softc *sc = sc_link->bus->sb_adapter_softc; bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; struct wds_scb *scb; struct wds_scat_gath *sg; int seg; u_long thiskv, thisphys, nextphys; int bytes_this_seg, bytes_this_page, datalen, flags; int s; if (xs->flags & SCSI_RESET) { /* XXX Fix me! */ printf("%s: reset!\n", sc->sc_dev.dv_xname); wds_init(sc); scsi_done(xs); return; } flags = xs->flags; scb = xs->io; scb->xs = xs; scb->timeout = xs->timeout; /* Zero out the command structure. */ bzero(&scb->cmd, sizeof scb->cmd); bcopy(&xs->cmd, &scb->cmd.scb, xs->cmdlen < 12 ? xs->cmdlen : 12); /* Set up some of the command fields. */ scb->cmd.targ = (xs->sc_link->target << 5) | xs->sc_link->lun; /* NOTE: cmd.write may be OK as 0x40 (disable direction checking) * on boards other than the WD-7000V-ASE. Need this for the ASE: */ scb->cmd.write = (xs->flags & SCSI_DATA_IN) ? 0x80 : 0x00; if (!NEEDBUFFER(sc) && xs->datalen) { sg = scb->scat_gath; seg = 0; /* * Set up the scatter-gather block. */ #ifdef WDSDEBUG printf("%s: %d @%p:- ", sc->sc_dev.dv_xname, xs->datalen, xs->data); #endif datalen = xs->datalen; thiskv = (int)xs->data; thisphys = KVTOPHYS(xs->data); while (datalen && seg < WDS_NSEG) { bytes_this_seg = 0; /* put in the base address */ ltophys(thisphys, sg->seg_addr); #ifdef WDSDEBUG printf("0x%lx", thisphys); #endif /* do it at least once */ nextphys = thisphys; while (datalen && thisphys == nextphys) { /* * This page is contiguous (physically) * with the last, just extend the * length */ /* check it fits on the ISA bus */ if (thisphys > 0xFFFFFF) { printf("%s: DMA beyond" " end of ISA\n", sc->sc_dev.dv_xname); goto bad; } /* how far to the end of the page */ nextphys = (thisphys & ~PGOFSET) + NBPG; bytes_this_page = nextphys - thisphys; /**** or the data ****/ bytes_this_page = min(bytes_this_page, datalen); bytes_this_seg += bytes_this_page; datalen -= bytes_this_page; /* get more ready for the next page */ thiskv = (thiskv & ~PGOFSET) + NBPG; if (datalen) thisphys = KVTOPHYS(thiskv); } /* * next page isn't contiguous, finish the seg */ #ifdef WDSDEBUG printf("(0x%x)", bytes_this_seg); #endif ltophys(bytes_this_seg, sg->seg_len); sg++; seg++; } #ifdef WDSDEBUG printf("\n"); #endif if (datalen) { /* * there's still data, must have run out of segs! */ printf("%s: wds_scsi_cmd, more than %d dma segs\n", sc->sc_dev.dv_xname, WDS_NSEG); goto bad; } scb->cmd.opcode = WDSX_SCSISG; ltophys(KVTOPHYS(scb->scat_gath), scb->cmd.data); ltophys(seg * sizeof(struct wds_scat_gath), scb->cmd.len); } else if (xs->datalen > 0) { /* The board is an ASC or ASE. Do not use scatter/gather. */ if (xs->datalen > BUFLEN) { printf("%s: wds_scsi_cmd, I/O too large for bounce buffer\n", sc->sc_dev.dv_xname); goto bad; } if (xs->flags & SCSI_DATA_OUT) bcopy(xs->data, scb->buf->data, xs->datalen); else bzero(scb->buf->data, xs->datalen); scb->cmd.opcode = WDSX_SCSICMD; ltophys(KVTOPHYS(scb->buf->data), scb->cmd.data); ltophys(xs->datalen, scb->cmd.len); } else { scb->cmd.opcode = WDSX_SCSICMD; ltophys(0, scb->cmd.data); ltophys(0, scb->cmd.len); } scb->cmd.stat = 0x00; scb->cmd.venderr = 0x00; ltophys(0, scb->cmd.link); /* XXX Do we really want to do this? */ if (flags & SCSI_POLL) { /* Will poll card, await result. */ bus_space_write_1(iot, ioh, WDS_HCR, WDSH_DRQEN); scb->flags |= SCB_POLLED; } else { /* Will send command, let interrupt routine handle result. */ bus_space_write_1(iot, ioh, WDS_HCR, WDSH_IRQEN | WDSH_DRQEN); } s = splbio(); wds_queue_scb(sc, scb); splx(s); if ((flags & SCSI_POLL) == 0) return; if (wds_poll(sc, xs, scb->timeout)) { wds_timeout(scb); if (wds_poll(sc, xs, scb->timeout)) wds_timeout(scb); } return; bad: xs->error = XS_DRIVER_STUFFUP; } /* * Send a sense request. */ void wds_sense(struct wds_softc *sc, struct wds_scb *scb) { struct scsi_xfer *xs = scb->xs; struct scsi_sense *ss = (void *)&scb->sense.scb; int s; /* XXXXX */ /* Send sense request SCSI command. */ xs->error = XS_SENSE; scb->flags |= SCB_SENSE; /* First, save the return values */ if (NEEDBUFFER(sc) && xs->datalen) { if (xs->flags & SCSI_DATA_IN) bcopy(scb->buf->data, xs->data, xs->datalen); } /* Next, setup a request sense command block */ bzero(ss, sizeof(*ss)); ss->opcode = REQUEST_SENSE; ss->byte2 = xs->sc_link->lun << 5; ss->length = sizeof(struct scsi_sense_data); /* Set up some of the command fields. */ scb->sense.targ = scb->cmd.targ; scb->sense.write = 0x80; scb->sense.opcode = WDSX_SCSICMD; ltophys(KVTOPHYS(&scb->sense_data), scb->sense.data); ltophys(sizeof(struct scsi_sense_data), scb->sense.len); s = splbio(); wds_queue_scb(sc, scb); splx(s); /* * There's no reason for us to poll here. There are two cases: * 1) If it's a polling operation, then we're called from the interrupt * handler, and we return and continue polling. * 2) If it's an interrupt-driven operation, then it gets completed * later on when the REQUEST SENSE finishes. */ } /* * Poll a particular unit, looking for a particular scb */ int wds_poll(struct wds_softc *sc, struct scsi_xfer *xs, int count) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; int s; /* timeouts are in msec, so we loop in 1000 usec cycles */ while (count) { /* * If we had interrupts enabled, would we * have got an interrupt? */ if (bus_space_read_1(iot, ioh, WDS_STAT) & WDSS_IRQ) { s = splbio(); wdsintr(sc); splx(s); } if (xs->flags & ITSDONE) return 0; delay(1000); /* only happens in boot so ok */ count--; } return 1; } /* * Poll a particular unit, looking for a particular scb */ int wds_ipoll(struct wds_softc *sc, struct wds_scb *scb, int count) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; int s; /* timeouts are in msec, so we loop in 1000 usec cycles */ while (count) { /* * If we had interrupts enabled, would we * have got an interrupt? */ if (bus_space_read_1(iot, ioh, WDS_STAT) & WDSS_IRQ) { s = splbio(); wdsintr(sc); splx(s); } if (scb->flags & SCB_DONE) return 0; delay(1000); /* only happens in boot so ok */ count--; } return 1; } void wds_timeout(void *arg) { struct wds_scb *scb = arg; struct scsi_xfer *xs; struct scsi_link *sc_link; struct wds_softc *sc; int s; s = splbio(); xs = scb->xs; sc_link = xs->sc_link; sc = sc_link->bus->sb_adapter_softc; sc_print_addr(sc_link); printf("timed out"); #ifdef WDSDIAG /* * If The scb's mbx is not free, then the board has gone south? */ wds_collect_mbo(sc); if (scb->flags & SCB_SENDING) panic("%s: not taking commands!", sc->sc_dev.dv_xname); #endif /* * If it has been through before, then * a previous abort has failed, don't * try abort again */ if (scb->flags & SCB_ABORT) { /* abort timed out */ printf(" AGAIN\n"); /* XXX Must reset! */ } else { /* abort the operation that has timed out */ printf("\n"); scb->xs->error = XS_TIMEOUT; scb->timeout = WDS_ABORT_TIMEOUT; scb->flags |= SCB_ABORT; wds_queue_scb(sc, scb); } splx(s); }