/* $OpenBSD: mb89352.c,v 1.35 2024/11/04 18:27:14 miod Exp $ */ /* $NetBSD: mb89352.c,v 1.5 2000/03/23 07:01:31 thorpej Exp $ */ /* NecBSD: mb89352.c,v 1.4 1998/03/14 07:31:20 kmatsuda Exp */ #ifdef DDB #define integrate #else #define integrate static __inline #endif /*- * Copyright (c) 1996,97,98,99 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Charles M. Hannum, Masaru Oki and Kouichi Matsuda. * * 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 Charles M. Hannum. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * Copyright (c) 1994 Jarle Greipsland * 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. 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. */ /* * [NetBSD for NEC PC-98 series] * Copyright (c) 1996, 1997, 1998 * NetBSD/pc98 porting staff. All rights reserved. * Copyright (c) 1996, 1997, 1998 * Kouichi Matsuda. All rights reserved. */ /* * Acknowledgements: Many of the algorithms used in this driver are * inspired by the work of Julian Elischer (julian@tfs.com) and * Charles Hannum (mycroft@duality.gnu.ai.mit.edu). Thanks a million! */ /* TODO list: * 1) Get the DMA stuff working. * 2) Get the iov/uio stuff working. Is this a good thing ??? * 3) Get the synch stuff working. * 4) Rewrite it to use malloc for the acb structs instead of static alloc.? */ /* * A few customizable items: */ /* Synchronous data transfers? */ #define SPC_USE_SYNCHRONOUS 0 #define SPC_SYNC_REQ_ACK_OFS 8 /* Wide data transfers? */ #define SPC_USE_WIDE 0 #define SPC_MAX_WIDTH 0 /* Max attempts made to transmit a message */ #define SPC_MSG_MAX_ATTEMPT 3 /* Not used now XXX */ /* * Some spin loop parameters (essentially how long to wait some places) * The problem(?) is that sometimes we expect either to be able to transmit a * byte or to get a new one from the SCSI bus pretty soon. In order to avoid * returning from the interrupt just to get yanked back for the next byte we * may spin in the interrupt routine waiting for this byte to come. How long? * This is really (SCSI) device and processor dependent. Tuneable, I guess. */ #define SPC_MSGIN_SPIN 1 /* Will spinwait upto ?ms for a new msg byte */ #define SPC_MSGOUT_SPIN 1 /* * Include debug functions? At the end of this file there are a bunch of * functions that will print out various information regarding queued SCSI * commands, driver state and chip contents. You can call them from the * kernel debugger. If you set SPC_DEBUG to 0 they are not included (the * kernel uses less memory) but you lose the debugging facilities. */ /* #define SPC_DEBUG */ #define SPC_ABORT_TIMEOUT 2000 /* time to wait for abort */ /* End of customizable parameters */ /* * MB89352 SCSI Protocol Controller (SPC) routines. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef DDB #define db_enter() panic("should call debugger here (mb89352.c)") #endif /* ! DDB */ #ifdef SPC_DEBUG int spc_debug = 0x00; /* SPC_SHOWSTART|SPC_SHOWMISC|SPC_SHOWTRACE; */ #endif void spc_done (struct spc_softc *, struct spc_acb *); void spc_dequeue (struct spc_softc *, struct spc_acb *); void spc_scsi_cmd (struct scsi_xfer *); int spc_poll (struct spc_softc *, struct scsi_xfer *, int); integrate void spc_sched_msgout(struct spc_softc *, u_char); integrate void spc_setsync(struct spc_softc *, struct spc_tinfo *); void spc_select (struct spc_softc *, struct spc_acb *); void spc_timeout (void *); void spc_scsi_reset (struct spc_softc *); void spc_reset (struct spc_softc *); void spc_acb_free (void *, void *); void *spc_acb_alloc (void *); int spc_reselect (struct spc_softc *, int); void spc_sense (struct spc_softc *, struct spc_acb *); void spc_msgin (struct spc_softc *); void spc_abort (struct spc_softc *, struct spc_acb *); void spc_msgout (struct spc_softc *); int spc_dataout_pio (struct spc_softc *, u_char *, int); int spc_datain_pio (struct spc_softc *, u_char *, int); #ifdef SPC_DEBUG void spc_print_acb (struct spc_acb *); void spc_dump_driver (struct spc_softc *); void spc_dump89352 (struct spc_softc *); void spc_show_scsi_cmd(struct spc_acb *); void spc_print_active_acb(void); #endif extern struct cfdriver spc_cd; #define breathe() \ do { \ asm volatile ("or %r0, %r0, %r0"); \ asm volatile ("or %r0, %r0, %r0"); \ asm volatile ("or %r0, %r0, %r0"); \ asm volatile ("or %r0, %r0, %r0"); \ } while (0) /* * INITIALIZATION ROUTINES (probe, attach ++) */ void /* spc_attach(sc) */ spc_attach(struct spc_softc *sc, const struct scsi_adapter *adapter) { struct scsibus_attach_args saa; SPC_TRACE(("spc_attach ")); sc->sc_state = SPC_INIT; sc->sc_freq = 20; /* XXXX Assume 20 MHz. */ #if SPC_USE_SYNCHRONOUS /* * These are the bounds of the sync period, based on the frequency of * the chip's clock input and the size and offset of the sync period * register. * * For a 20MHz clock, this gives us 25, or 100nS, or 10MB/s, as a * maximum transfer rate, and 112.5, or 450nS, or 2.22MB/s, as a * minimum transfer rate. */ sc->sc_minsync = (2 * 250) / sc->sc_freq; sc->sc_maxsync = (9 * 250) / sc->sc_freq; #endif spc_init(sc); /* Init chip and driver */ saa.saa_adapter_softc = sc; saa.saa_adapter_target = sc->sc_initiator; saa.saa_adapter = adapter; saa.saa_luns = saa.saa_adapter_buswidth = 8; saa.saa_openings = 2; saa.saa_pool = &sc->sc_iopool; saa.saa_flags = saa.saa_quirks = 0; saa.saa_wwpn = saa.saa_wwnn = 0; config_found(&sc->sc_dev, &saa, scsiprint); } /* * Initialize MB89352 chip itself * The following conditions should hold: * spc_isa_probe should have succeeded, i.e. the iobase address in spc_softc * must be valid. */ void spc_reset(struct spc_softc *sc) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; SPC_TRACE(("spc_reset ")); /* * Disable interrupts then reset the FUJITSU chip. */ bus_space_write_1(iot, ioh, SCTL, SCTL_DISABLE | SCTL_CTRLRST); bus_space_write_1(iot, ioh, SCMD, 0); bus_space_write_1(iot, ioh, TMOD, 0); bus_space_write_1(iot, ioh, PCTL, 0); bus_space_write_1(iot, ioh, TEMP, 0); bus_space_write_1(iot, ioh, TCH, 0); bus_space_write_1(iot, ioh, TCM, 0); bus_space_write_1(iot, ioh, TCL, 0); bus_space_write_1(iot, ioh, INTS, 0); bus_space_write_1(iot, ioh, SCTL, SCTL_DISABLE | SCTL_ABRT_ENAB | SCTL_PARITY_ENAB | SCTL_RESEL_ENAB); bus_space_write_1(iot, ioh, BDID, sc->sc_initiator); delay(400); bus_space_write_1(iot, ioh, SCTL, bus_space_read_1(iot, ioh, SCTL) & ~SCTL_DISABLE); } /* * Pull the SCSI RST line for 500us. */ void spc_scsi_reset(struct spc_softc *sc) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; SPC_TRACE(("spc_scsi_reset ")); bus_space_write_1(iot, ioh, SCMD, bus_space_read_1(iot, ioh, SCMD) | SCMD_RST); delay(500); bus_space_write_1(iot, ioh, SCMD, bus_space_read_1(iot, ioh, SCMD) & ~SCMD_RST); delay(50); } /* * Initialize spc SCSI driver. */ void spc_init(struct spc_softc *sc) { struct spc_acb *acb; int r; SPC_TRACE(("spc_init ")); spc_reset(sc); spc_scsi_reset(sc); spc_reset(sc); if (sc->sc_state == SPC_INIT) { /* First time through; initialize. */ TAILQ_INIT(&sc->ready_list); TAILQ_INIT(&sc->nexus_list); TAILQ_INIT(&sc->free_list); mtx_init(&sc->sc_acb_mtx, IPL_BIO); scsi_iopool_init(&sc->sc_iopool, sc, spc_acb_alloc, spc_acb_free); sc->sc_nexus = NULL; acb = sc->sc_acb; bzero(acb, sizeof(sc->sc_acb)); for (r = 0; r < sizeof(sc->sc_acb) / sizeof(*acb); r++) { TAILQ_INSERT_TAIL(&sc->free_list, acb, chain); acb++; } bzero(&sc->sc_tinfo, sizeof(sc->sc_tinfo)); } else { /* Cancel any active commands. */ sc->sc_state = SPC_CLEANING; if ((acb = sc->sc_nexus) != NULL) { acb->xs->error = XS_DRIVER_STUFFUP; timeout_del(&acb->xs->stimeout); spc_done(sc, acb); } while ((acb = TAILQ_FIRST(&sc->nexus_list)) != NULL) { acb->xs->error = XS_DRIVER_STUFFUP; timeout_del(&acb->xs->stimeout); spc_done(sc, acb); } } sc->sc_prevphase = PH_INVALID; for (r = 0; r < 8; r++) { struct spc_tinfo *ti = &sc->sc_tinfo[r]; ti->flags = 0; #if SPC_USE_SYNCHRONOUS ti->flags |= DO_SYNC; ti->period = sc->sc_minsync; ti->offset = SPC_SYNC_REQ_ACK_OFS; #else ti->period = ti->offset = 0; #endif #if SPC_USE_WIDE ti->flags |= DO_WIDE; ti->width = SPC_MAX_WIDTH; #else ti->width = 0; #endif } sc->sc_state = SPC_IDLE; bus_space_write_1(sc->sc_iot, sc->sc_ioh, SCTL, bus_space_read_1(sc->sc_iot, sc->sc_ioh, SCTL) | SCTL_INTR_ENAB); } void spc_acb_free(void *xsc, void *xacb) { struct spc_softc *sc = xsc; struct spc_acb *acb = xacb; SPC_TRACE(("spc_acb_free ")); acb->flags = 0; mtx_enter(&sc->sc_acb_mtx); TAILQ_INSERT_HEAD(&sc->free_list, acb, chain); mtx_leave(&sc->sc_acb_mtx); } void * spc_acb_alloc(void *xsc) { struct spc_softc *sc = xsc; struct spc_acb *acb; SPC_TRACE(("spc_acb_alloc ")); mtx_enter(&sc->sc_acb_mtx); acb = TAILQ_FIRST(&sc->free_list); if (acb) TAILQ_REMOVE(&sc->free_list, acb, chain); mtx_leave(&sc->sc_acb_mtx); return acb; } /* * DRIVER FUNCTIONS CALLABLE FROM HIGHER LEVEL DRIVERS */ /* * Expected sequence: * 1) Command inserted into ready list * 2) Command selected for execution * 3) Command won arbitration and has selected target device * 4) Send message out (identify message, eventually also sync.negotiations) * 5) Send command * 5a) Receive disconnect message, disconnect. * 5b) Reselected by target * 5c) Receive identify message from target. * 6) Send or receive data * 7) Receive status * 8) Receive message (command complete etc.) * 9) If status == SCSI_CHECK construct a synthetic request sense SCSI cmd. * Repeat 2-8 (no disconnects please...) */ /* * Start a SCSI-command * This function is called by the higher level SCSI-driver to queue/run * SCSI-commands. */ void spc_scsi_cmd(struct scsi_xfer *xs) { struct scsi_link *sc_link = xs->sc_link; struct spc_softc *sc = sc_link->bus->sb_adapter_softc; struct spc_acb *acb; int s, flags; SPC_TRACE(("spc_scsi_cmd ")); SPC_CMDS(("[0x%x, %d]->%d ", (int)xs->cmd.opcode, xs->cmdlen, sc_link->target)); flags = xs->flags; acb = xs->io; /* Initialize acb */ acb->xs = xs; timeout_set(&xs->stimeout, spc_timeout, acb); if (xs->flags & SCSI_RESET) { acb->flags |= ACB_RESET; acb->scsi_cmd_length = 0; acb->data_length = 0; } else { bcopy(&xs->cmd, &acb->scsi_cmd, xs->cmdlen); acb->scsi_cmd_length = xs->cmdlen; acb->data_addr = xs->data; acb->data_length = xs->datalen; } acb->target_stat = 0; s = splbio(); TAILQ_INSERT_TAIL(&sc->ready_list, acb, chain); /* * Start scheduling unless a queue process is in progress. */ if (sc->sc_state == SPC_IDLE) spc_sched(sc); /* * After successful sending, check if we should return just now. */ splx(s); if ((flags & SCSI_POLL) == 0) return; /* Not allowed to use interrupts, use polling instead */ s = splbio(); if (spc_poll(sc, xs, xs->timeout)) { spc_timeout(acb); if (spc_poll(sc, xs, xs->timeout)) spc_timeout(acb); } splx(s); } /* * Used when interrupt driven I/O isn't allowed, e.g. during boot. */ int spc_poll(struct spc_softc *sc, struct scsi_xfer *xs, int count) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; SPC_TRACE(("spc_poll ")); while (count) { /* * If we had interrupts enabled, would we * have got an interrupt? */ if (bus_space_read_1(iot, ioh, INTS) != 0) spc_intr(sc); if ((xs->flags & ITSDONE) != 0) return 0; delay(1000); count--; } return 1; } /* * LOW LEVEL SCSI UTILITIES */ integrate void spc_sched_msgout(struct spc_softc *sc, u_char m) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; SPC_TRACE(("spc_sched_msgout ")); if (sc->sc_msgpriq == 0) bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ATN); sc->sc_msgpriq |= m; } /* * Set synchronous transfer offset and period. */ integrate void spc_setsync(struct spc_softc *sc, struct spc_tinfo *ti) { #if SPC_USE_SYNCHRONOUS bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; SPC_TRACE(("spc_setsync ")); if (ti->offset != 0) bus_space_write_1(iot, ioh, TMOD, ((ti->period * sc->sc_freq) / 250 - 2) << 4 | ti->offset); else bus_space_write_1(iot, ioh, TMOD, 0); #endif } /* * Start a selection. This is used by spc_sched() to select an idle target, * and by spc_done() to immediately reselect a target to get sense information. */ void spc_select(struct spc_softc *sc, struct spc_acb *acb) { struct scsi_link *sc_link = acb->xs->sc_link; int target = sc_link->target; struct spc_tinfo *ti = &sc->sc_tinfo[target]; bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; SPC_TRACE(("spc_select ")); spc_setsync(sc, ti); #if 0 bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ATN); #endif bus_space_write_1(iot, ioh, PCTL, 0); bus_space_write_1(iot, ioh, TEMP, (1 << sc->sc_initiator) | (1 << target)); /* * Setup BSY timeout (selection timeout). * 250ms according to the SCSI specification. * T = (X * 256 + 15) * Tclf * 2 (Tclf = 200ns on x68k) * To setup 256ms timeout, * 128000ns/200ns = X * 256 + 15 * 640 - 15 = X * 256 * X = 625 / 256 * X = 2 + 113 / 256 * ==> tch = 2, tcm = 113 (correct?) */ /* Time to the information transfer phase start. */ /* XXX These values should be calculated from sc_freq */ bus_space_write_1(iot, ioh, TCH, 2); bus_space_write_1(iot, ioh, TCM, 113); bus_space_write_1(iot, ioh, TCL, 3); bus_space_write_1(iot, ioh, SCMD, SCMD_SELECT); sc->sc_state = SPC_SELECTING; } int spc_reselect(struct spc_softc *sc, int message) { u_char selid, target, lun; struct spc_acb *acb; struct scsi_link *sc_link; struct spc_tinfo *ti; SPC_TRACE(("spc_reselect ")); /* * The SCSI chip made a snapshot of the data bus while the reselection * was being negotiated. This enables us to determine which target did * the reselect. */ selid = sc->sc_selid & ~(1 << sc->sc_initiator); if (selid & (selid - 1)) { printf("%s: reselect with invalid selid %02x; " "sending DEVICE RESET\n", sc->sc_dev.dv_xname, selid); SPC_BREAK(); goto reset; } /* * Search wait queue for disconnected cmd * The list should be short, so I haven't bothered with * any more sophisticated structures than a simple * singly linked list. */ target = ffs(selid) - 1; lun = message & 0x07; TAILQ_FOREACH(acb, &sc->nexus_list, chain) { sc_link = acb->xs->sc_link; if (sc_link->target == target && sc_link->lun == lun) break; } if (acb == NULL) { printf("%s: reselect from target %d lun %d with no nexus; " "sending ABORT\n", sc->sc_dev.dv_xname, target, lun); SPC_BREAK(); goto abort; } /* Make this nexus active again. */ TAILQ_REMOVE(&sc->nexus_list, acb, chain); sc->sc_state = SPC_CONNECTED; sc->sc_nexus = acb; ti = &sc->sc_tinfo[target]; ti->lubusy |= (1 << lun); spc_setsync(sc, ti); if (acb->flags & ACB_RESET) spc_sched_msgout(sc, SEND_DEV_RESET); else if (acb->flags & ACB_ABORT) spc_sched_msgout(sc, SEND_ABORT); /* Do an implicit RESTORE POINTERS. */ sc->sc_dp = acb->data_addr; sc->sc_dleft = acb->data_length; sc->sc_cp = (u_char *)&acb->scsi_cmd; sc->sc_cleft = acb->scsi_cmd_length; return (0); reset: spc_sched_msgout(sc, SEND_DEV_RESET); return (1); abort: spc_sched_msgout(sc, SEND_ABORT); return (1); } /* * Schedule a SCSI operation. This has now been pulled out of the interrupt * handler so that we may call it from spc_scsi_cmd and spc_done. This may * save us an unnecessary interrupt just to get things going. Should only be * called when state == SPC_IDLE and at bio pl. */ void spc_sched(struct spc_softc *sc) { struct spc_acb *acb; struct scsi_link *sc_link; struct spc_tinfo *ti; /* missing the hw, just return and wait for our hw */ if (sc->sc_flags & SPC_INACTIVE) return; SPC_TRACE(("spc_sched ")); /* * Find first acb in ready queue that is for a target/lunit pair that * is not busy. */ TAILQ_FOREACH(acb, &sc->ready_list, chain) { sc_link = acb->xs->sc_link; ti = &sc->sc_tinfo[sc_link->target]; if ((ti->lubusy & (1 << sc_link->lun)) == 0) { SPC_MISC(("selecting %d:%d ", sc_link->target, sc_link->lun)); TAILQ_REMOVE(&sc->ready_list, acb, chain); sc->sc_nexus = acb; spc_select(sc, acb); return; } else SPC_MISC(("%d:%d busy\n", sc_link->target, sc_link->lun)); } SPC_MISC(("idle ")); /* Nothing to start; just enable reselections and wait. */ } void spc_sense(struct spc_softc *sc, struct spc_acb *acb) { struct scsi_xfer *xs = acb->xs; struct scsi_link *sc_link = xs->sc_link; struct spc_tinfo *ti = &sc->sc_tinfo[sc_link->target]; struct scsi_sense *ss = (void *)&acb->scsi_cmd; SPC_MISC(("requesting sense ")); /* Next, setup a request sense command block */ bzero(ss, sizeof(*ss)); ss->opcode = REQUEST_SENSE; ss->byte2 = sc_link->lun << 5; ss->length = sizeof(struct scsi_sense_data); acb->scsi_cmd_length = sizeof(*ss); acb->data_addr = (char *)&xs->sense; acb->data_length = sizeof(struct scsi_sense_data); acb->flags |= ACB_SENSE; ti->senses++; if (acb->flags & ACB_NEXUS) ti->lubusy &= ~(1 << sc_link->lun); if (acb == sc->sc_nexus) { spc_select(sc, acb); } else { spc_dequeue(sc, acb); TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain); if (sc->sc_state == SPC_IDLE) spc_sched(sc); } } /* * POST PROCESSING OF SCSI_CMD (usually current) */ void spc_done(struct spc_softc *sc, struct spc_acb *acb) { struct scsi_xfer *xs = acb->xs; struct scsi_link *sc_link = xs->sc_link; struct spc_tinfo *ti = &sc->sc_tinfo[sc_link->target]; SPC_TRACE(("spc_done ")); /* * Now, if we've come here with no error code, i.e. we've kept the * initial XS_NOERROR, and the status code signals that we should * check sense, we'll need to set up a request sense cmd block and * push the command back into the ready queue *before* any other * commands for this target/lunit, else we lose the sense info. * We don't support chk sense conditions for the request sense cmd. */ if (xs->error == XS_NOERROR) { if (acb->flags & ACB_ABORT) { xs->error = XS_DRIVER_STUFFUP; } else if (acb->flags & ACB_SENSE) { xs->error = XS_SENSE; } else { switch (acb->target_stat) { case SCSI_CHECK: /* First, save the return values */ xs->resid = acb->data_length; xs->status = acb->target_stat; spc_sense(sc, acb); return; case SCSI_BUSY: xs->error = XS_BUSY; break; case SCSI_OK: xs->resid = acb->data_length; break; default: xs->error = XS_DRIVER_STUFFUP; #ifdef SPC_DEBUG printf("%s: spc_done: bad stat 0x%x\n", sc->sc_dev.dv_xname, acb->target_stat); #endif break; } } } #ifdef SPC_DEBUG if ((spc_debug & SPC_SHOWMISC) != 0) { if (xs->resid != 0) printf("resid=%d ", xs->resid); if (xs->error == XS_SENSE) printf("sense=0x%02x\n", xs->sense.error_code); else printf("error=%d\n", xs->error); } #endif /* * Remove the ACB from whatever queue it happens to be on. */ if (acb->flags & ACB_NEXUS) ti->lubusy &= ~(1 << sc_link->lun); if (acb == sc->sc_nexus) { sc->sc_nexus = NULL; sc->sc_state = SPC_IDLE; spc_sched(sc); } else spc_dequeue(sc, acb); ti->cmds++; scsi_done(xs); } void spc_dequeue(struct spc_softc *sc, struct spc_acb *acb) { SPC_TRACE(("spc_dequeue ")); if (acb->flags & ACB_NEXUS) TAILQ_REMOVE(&sc->nexus_list, acb, chain); else TAILQ_REMOVE(&sc->ready_list, acb, chain); } /* * INTERRUPT/PROTOCOL ENGINE */ /* * Precondition: * The SCSI bus is already in the MSGI phase and there is a message byte * on the bus, along with an asserted REQ signal. */ void spc_msgin(struct spc_softc *sc) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; int n; SPC_TRACE(("spc_msgin ")); if (sc->sc_prevphase == PH_MSGIN) { /* This is a continuation of the previous message. */ n = sc->sc_imp - sc->sc_imess; goto nextbyte; } /* This is a new MESSAGE IN phase. Clean up our state. */ sc->sc_flags &= ~SPC_DROP_MSGIN; nextmsg: n = 0; sc->sc_imp = &sc->sc_imess[n]; nextbyte: /* * Read a whole message, but don't ack the last byte. If we reject the * message, we have to assert ATN during the message transfer phase * itself. */ for (;;) { u_int8_t intstat; #if 0 for (;;) { if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) != 0) break; /* Wait for REQINIT. XXX Need timeout. */ } #endif if (bus_space_read_1(iot, ioh, INTS) != 0) { /* * Target left MESSAGE IN, probably because it * a) noticed our ATN signal, or * b) ran out of messages. */ goto out; } /* If parity error, just dump everything on the floor. */ if ((bus_space_read_1(iot, ioh, SERR) & (SERR_SCSI_PAR|SERR_SPC_PAR)) != 0) { sc->sc_flags |= SPC_DROP_MSGIN; spc_sched_msgout(sc, SEND_PARITY_ERROR); } /* send TRANSFER command. */ bus_space_write_1(iot, ioh, TCH, 0); bus_space_write_1(iot, ioh, TCM, 0); bus_space_write_1(iot, ioh, TCL, 1); bus_space_write_1(iot, ioh, PCTL, sc->sc_phase | PCTL_BFINT_ENAB); #ifdef x68k bus_space_write_1(iot, ioh, SCMD, SCMD_XFR); /* | SCMD_PROG_XFR */ #else bus_space_write_1(iot, ioh, SCMD, SCMD_XFR | SCMD_PROG_XFR); /* XXX */ #endif intstat = 0; for (;;) { /*if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0 && (bus_space_read_1(iot, ioh, SSTS) & SSTS_DREG_EMPTY) != 0)*/ if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_DREG_EMPTY) == 0) break; /* * We have to read INTS before checking SSTS to avoid * race between SSTS_DREG_EMPTY and INTS_CMD_DONE. */ if (intstat != 0) goto out; intstat = bus_space_read_1(iot, ioh, INTS); } /* Gather incoming message bytes if needed. */ if ((sc->sc_flags & SPC_DROP_MSGIN) == 0) { if (n >= SPC_MAX_MSG_LEN) { (void) bus_space_read_1(iot, ioh, DREG); sc->sc_flags |= SPC_DROP_MSGIN; spc_sched_msgout(sc, SEND_REJECT); } else { *sc->sc_imp++ = bus_space_read_1(iot, ioh, DREG); n++; /* * This testing is suboptimal, but most * messages will be of the one byte variety, so * it should not affect performance * significantly. */ if (n == 1 && IS1BYTEMSG(sc->sc_imess[0])) break; if (n == 2 && IS2BYTEMSG(sc->sc_imess[0])) break; if (n >= 3 && ISEXTMSG(sc->sc_imess[0]) && n == sc->sc_imess[1] + 2) break; } } else (void) bus_space_read_1(iot, ioh, DREG); /* * If we reach this spot we're either: * a) in the middle of a multi-byte message, or * b) dropping bytes. */ #if 0 /* Ack the last byte read. */ /*(void) bus_space_read_1(iot, ioh, DREG);*/ while ((bus_space_read_1(iot, ioh, PSNS) & ACKI) != 0) ; #endif } SPC_MISC(("n=%d imess=0x%02x ", n, sc->sc_imess[0])); /* We now have a complete message. Parse it. */ switch (sc->sc_state) { struct spc_acb *acb; struct scsi_link *sc_link; struct spc_tinfo *ti; case SPC_CONNECTED: SPC_ASSERT(sc->sc_nexus != NULL); acb = sc->sc_nexus; ti = &sc->sc_tinfo[acb->xs->sc_link->target]; switch (sc->sc_imess[0]) { case MSG_CMDCOMPLETE: if (sc->sc_dleft < 0) { sc_link = acb->xs->sc_link; printf("%s: %ld extra bytes from %d:%d\n", sc->sc_dev.dv_xname, -sc->sc_dleft, sc_link->target, sc_link->lun); acb->data_length = 0; } acb->xs->resid = acb->data_length = sc->sc_dleft; sc->sc_state = SPC_CMDCOMPLETE; break; case MSG_PARITY_ERROR: /* Resend the last message. */ spc_sched_msgout(sc, sc->sc_lastmsg); break; case MSG_MESSAGE_REJECT: SPC_MISC(("message rejected %02x ", sc->sc_lastmsg)); switch (sc->sc_lastmsg) { #if SPC_USE_SYNCHRONOUS + SPC_USE_WIDE case SEND_IDENTIFY: ti->flags &= ~(DO_SYNC | DO_WIDE); ti->period = ti->offset = 0; spc_setsync(sc, ti); ti->width = 0; break; #endif #if SPC_USE_SYNCHRONOUS case SEND_SDTR: ti->flags &= ~DO_SYNC; ti->period = ti->offset = 0; spc_setsync(sc, ti); break; #endif #if SPC_USE_WIDE case SEND_WDTR: ti->flags &= ~DO_WIDE; ti->width = 0; break; #endif case SEND_INIT_DET_ERR: spc_sched_msgout(sc, SEND_ABORT); break; } break; case MSG_NOOP: break; case MSG_DISCONNECT: ti->dconns++; sc->sc_state = SPC_DISCONNECT; break; case MSG_SAVEDATAPOINTER: acb->data_addr = sc->sc_dp; acb->data_length = sc->sc_dleft; break; case MSG_RESTOREPOINTERS: sc->sc_dp = acb->data_addr; sc->sc_dleft = acb->data_length; sc->sc_cp = (u_char *)&acb->scsi_cmd; sc->sc_cleft = acb->scsi_cmd_length; break; case MSG_EXTENDED: switch (sc->sc_imess[2]) { #if SPC_USE_SYNCHRONOUS case MSG_EXT_SDTR: if (sc->sc_imess[1] != 3) goto reject; ti->period = sc->sc_imess[3]; ti->offset = sc->sc_imess[4]; ti->flags &= ~DO_SYNC; if (ti->offset == 0) { } else if (ti->period < sc->sc_minsync || ti->period > sc->sc_maxsync || ti->offset > 8) { ti->period = ti->offset = 0; spc_sched_msgout(sc, SEND_SDTR); } else { sc_print_addr(acb->xs->sc_link); printf("sync, offset %d, " "period %dnsec\n", ti->offset, ti->period * 4); } spc_setsync(sc, ti); break; #endif #if SPC_USE_WIDE case MSG_EXT_WDTR: if (sc->sc_imess[1] != 2) goto reject; ti->width = sc->sc_imess[3]; ti->flags &= ~DO_WIDE; if (ti->width == 0) { } else if (ti->width > SPC_MAX_WIDTH) { ti->width = 0; spc_sched_msgout(sc, SEND_WDTR); } else { sc_print_addr(acb->xs->sc_link); printf("wide, width %d\n", 1 << (3 + ti->width)); } break; #endif default: printf("%s: unrecognized MESSAGE EXTENDED; " "sending REJECT\n", sc->sc_dev.dv_xname); SPC_BREAK(); goto reject; } break; default: printf("%s: unrecognized MESSAGE; sending REJECT\n", sc->sc_dev.dv_xname); SPC_BREAK(); reject: spc_sched_msgout(sc, SEND_REJECT); break; } break; case SPC_RESELECTED: if (!MSG_ISIDENTIFY(sc->sc_imess[0])) { printf("%s: reselect without IDENTIFY; " "sending DEVICE RESET\n", sc->sc_dev.dv_xname); SPC_BREAK(); goto reset; } (void) spc_reselect(sc, sc->sc_imess[0]); break; default: printf("%s: unexpected MESSAGE IN; sending DEVICE RESET\n", sc->sc_dev.dv_xname); SPC_BREAK(); reset: spc_sched_msgout(sc, SEND_DEV_RESET); break; #ifdef notdef abort: spc_sched_msgout(sc, SEND_ABORT); break; #endif } /* Ack the last message byte. */ #if 0 /* XXX? */ (void) bus_space_read_1(iot, ioh, DREG); while ((bus_space_read_1(iot, ioh, PSNS) & ACKI) != 0) ; #endif /* Go get the next message, if any. */ goto nextmsg; out: bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ACK); SPC_MISC(("n=%d imess=0x%02x ", n, sc->sc_imess[0])); } /* * Send the highest priority, scheduled message. */ void spc_msgout(struct spc_softc *sc) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; #if SPC_USE_SYNCHRONOUS struct spc_tinfo *ti; #endif int n; SPC_TRACE(("spc_msgout ")); if (sc->sc_prevphase == PH_MSGOUT) { if (sc->sc_omp == sc->sc_omess) { /* * This is a retransmission. * * We get here if the target stayed in MESSAGE OUT * phase. Section 5.1.9.2 of the SCSI 2 spec indicates * that all of the previously transmitted messages must * be sent again, in the same order. Therefore, we * requeue all the previously transmitted messages, and * start again from the top. Our simple priority * scheme keeps the messages in the right order. */ SPC_MISC(("retransmitting ")); sc->sc_msgpriq |= sc->sc_msgoutq; /* * Set ATN. If we're just sending a trivial 1-byte * message, we'll clear ATN later on anyway. */ bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ATN); /* XXX? */ } else { /* This is a continuation of the previous message. */ n = sc->sc_omp - sc->sc_omess; goto nextbyte; } } /* No messages transmitted so far. */ sc->sc_msgoutq = 0; sc->sc_lastmsg = 0; nextmsg: /* Pick up highest priority message. */ sc->sc_currmsg = sc->sc_msgpriq & -sc->sc_msgpriq; sc->sc_msgpriq &= ~sc->sc_currmsg; sc->sc_msgoutq |= sc->sc_currmsg; /* Build the outgoing message data. */ switch (sc->sc_currmsg) { case SEND_IDENTIFY: SPC_ASSERT(sc->sc_nexus != NULL); sc->sc_omess[0] = MSG_IDENTIFY(sc->sc_nexus->xs->sc_link->lun, 1); n = 1; break; #if SPC_USE_SYNCHRONOUS case SEND_SDTR: SPC_ASSERT(sc->sc_nexus != NULL); ti = &sc->sc_tinfo[sc->sc_nexus->xs->sc_link->target]; sc->sc_omess[4] = MSG_EXTENDED; sc->sc_omess[3] = MSG_EXT_SDTR_LEN; sc->sc_omess[2] = MSG_EXT_SDTR; sc->sc_omess[1] = ti->period >> 2; sc->sc_omess[0] = ti->offset; n = 5; break; #endif #if SPC_USE_WIDE case SEND_WDTR: SPC_ASSERT(sc->sc_nexus != NULL); ti = &sc->sc_tinfo[sc->sc_nexus->xs->sc_link->target]; sc->sc_omess[3] = MSG_EXTENDED; sc->sc_omess[2] = MSG_EXT_WDTR_LEN; sc->sc_omess[1] = MSG_EXT_WDTR; sc->sc_omess[0] = ti->width; n = 4; break; #endif case SEND_DEV_RESET: sc->sc_flags |= SPC_ABORTING; sc->sc_omess[0] = MSG_BUS_DEV_RESET; n = 1; break; case SEND_REJECT: sc->sc_omess[0] = MSG_MESSAGE_REJECT; n = 1; break; case SEND_PARITY_ERROR: sc->sc_omess[0] = MSG_PARITY_ERROR; n = 1; break; case SEND_INIT_DET_ERR: sc->sc_omess[0] = MSG_INITIATOR_DET_ERR; n = 1; break; case SEND_ABORT: sc->sc_flags |= SPC_ABORTING; sc->sc_omess[0] = MSG_ABORT; n = 1; break; default: printf("%s: unexpected MESSAGE OUT; sending NOOP\n", sc->sc_dev.dv_xname); SPC_BREAK(); sc->sc_omess[0] = MSG_NOOP; n = 1; break; } sc->sc_omp = &sc->sc_omess[n]; nextbyte: /* Send message bytes. */ /* send TRANSFER command. */ bus_space_write_1(iot, ioh, TCH, n >> 16); bus_space_write_1(iot, ioh, TCM, n >> 8); bus_space_write_1(iot, ioh, TCL, n); bus_space_write_1(iot, ioh, PCTL, sc->sc_phase | PCTL_BFINT_ENAB); #ifdef x68k bus_space_write_1(iot, ioh, SCMD, SCMD_XFR); /* XXX */ #else bus_space_write_1(iot, ioh, SCMD, SCMD_XFR | SCMD_PROG_XFR | SCMD_ICPT_XFR); #endif for (;;) { if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0) break; if (bus_space_read_1(iot, ioh, INTS) != 0) goto out; } for (;;) { #if 0 for (;;) { if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) != 0) break; /* Wait for REQINIT. XXX Need timeout. */ } #endif if (bus_space_read_1(iot, ioh, INTS) != 0) { /* * Target left MESSAGE OUT, possibly to reject * our message. * * If this is the last message being sent, then we * deassert ATN, since either the target is going to * ignore this message, or it's going to ask for a * retransmission via MESSAGE PARITY ERROR (in which * case we reassert ATN anyway). */ #if 0 if (sc->sc_msgpriq == 0) bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ATN); #endif goto out; } #if 0 /* Clear ATN before last byte if this is the last message. */ if (n == 1 && sc->sc_msgpriq == 0) bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ATN); #endif while ((bus_space_read_1(iot, ioh, SSTS) & SSTS_DREG_FULL) != 0) ; /* Send message byte. */ bus_space_write_1(iot, ioh, DREG, *--sc->sc_omp); --n; /* Keep track of the last message we've sent any bytes of. */ sc->sc_lastmsg = sc->sc_currmsg; #if 0 /* Wait for ACK to be negated. XXX Need timeout. */ while ((bus_space_read_1(iot, ioh, PSNS) & ACKI) != 0) ; #endif if (n == 0) break; } /* We get here only if the entire message has been transmitted. */ if (sc->sc_msgpriq != 0) { /* There are more outgoing messages. */ goto nextmsg; } /* * The last message has been transmitted. We need to remember the last * message transmitted (in case the target switches to MESSAGE IN phase * and sends a MESSAGE REJECT), and the list of messages transmitted * this time around (in case the target stays in MESSAGE OUT phase to * request a retransmit). */ out: /* Disable REQ/ACK protocol. */ return; } /* * spc_dataout_pio: perform a data transfer using the FIFO datapath in the spc * Precondition: The SCSI bus should be in the DOUT phase, with REQ asserted * and ACK deasserted (i.e. waiting for a data byte). * * This new revision has been optimized (I tried) to make the common case fast, * and the rarer cases (as a result) somewhat more complex. */ int spc_dataout_pio(struct spc_softc *sc, u_char *p, int n) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; u_char intstat = 0; int out = 0; #define DOUTAMOUNT 8 /* Full FIFO */ SPC_TRACE(("spc_dataout_pio ")); /* send TRANSFER command. */ bus_space_write_1(iot, ioh, TCH, n >> 16); bus_space_write_1(iot, ioh, TCM, n >> 8); bus_space_write_1(iot, ioh, TCL, n); bus_space_write_1(iot, ioh, PCTL, sc->sc_phase | PCTL_BFINT_ENAB); #ifdef x68k bus_space_write_1(iot, ioh, SCMD, SCMD_XFR); /* XXX */ #else bus_space_write_1(iot, ioh, SCMD, SCMD_XFR | SCMD_PROG_XFR | SCMD_ICPT_XFR); /* XXX */ #endif for (;;) { if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0) break; if (bus_space_read_1(iot, ioh, INTS) != 0) break; } /* * I have tried to make the main loop as tight as possible. This * means that some of the code following the loop is a bit more * complex than otherwise. */ while (n > 0) { int xfer; for (;;) { intstat = bus_space_read_1(iot, ioh, INTS); /* Wait till buffer is empty. */ if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_DREG_EMPTY) != 0) break; /* Break on interrupt. */ if (intstat != 0) goto phasechange; } xfer = min(DOUTAMOUNT, n); SPC_MISC(("%d> ", xfer)); n -= xfer; out += xfer; #if 0 bus_space_write_multi_1(iot, ioh, DREG, p, xfer); p += xfer; #else switch (xfer) { case 8: bus_space_write_1(iot, ioh, DREG, *p++); case 7: bus_space_write_1(iot, ioh, DREG, *p++); case 6: bus_space_write_1(iot, ioh, DREG, *p++); case 5: bus_space_write_1(iot, ioh, DREG, *p++); case 4: bus_space_write_1(iot, ioh, DREG, *p++); case 3: bus_space_write_1(iot, ioh, DREG, *p++); case 2: bus_space_write_1(iot, ioh, DREG, *p++); case 1: bus_space_write_1(iot, ioh, DREG, *p++); } #endif } if (out == 0) { for (;;) { if (bus_space_read_1(iot, ioh, INTS) != 0) break; } SPC_MISC(("extra data ")); } else { /* See the bytes off chip */ for (;;) { /* Wait till buffer is empty. */ if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_DREG_EMPTY) != 0) break; intstat = bus_space_read_1(iot, ioh, INTS); /* Break on interrupt. */ if (intstat != 0) goto phasechange; } } phasechange: /* Stop the FIFO data path. */ if (intstat != 0) { /* Some sort of phase change. */ int amount; amount = ((bus_space_read_1(iot, ioh, TCH) << 16) | (bus_space_read_1(iot, ioh, TCM) << 8) | bus_space_read_1(iot, ioh, TCL)); if (amount > 0) { out -= amount; SPC_MISC(("+%d ", amount)); } } return out; } /* * spc_datain_pio: perform data transfers using the FIFO datapath in the spc * Precondition: The SCSI bus should be in the DIN phase, with REQ asserted * and ACK deasserted (i.e. at least one byte is ready). * * For now, uses a pretty dumb algorithm, hangs around until all data has been * transferred. This, is OK for fast targets, but not so smart for slow * targets which don't disconnect or for huge transfers. */ int spc_datain_pio(struct spc_softc *sc, u_char *p, int n) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; u_int8_t intstat, sstat; int in = 0; #define DINAMOUNT 8 /* Full FIFO */ SPC_TRACE(("spc_datain_pio ")); /* send TRANSFER command. */ bus_space_write_1(iot, ioh, TCH, n >> 16); bus_space_write_1(iot, ioh, TCM, n >> 8); bus_space_write_1(iot, ioh, TCL, n); bus_space_write_1(iot, ioh, PCTL, sc->sc_phase | PCTL_BFINT_ENAB); #ifdef x68k bus_space_write_1(iot, ioh, SCMD, SCMD_XFR); /* XXX */ #else bus_space_write_1(iot, ioh, SCMD, SCMD_XFR | SCMD_PROG_XFR); /* XXX */ #endif for (;;) { if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0) break; if (bus_space_read_1(iot, ioh, INTS) != 0) goto phasechange; } /* * We leave this loop if one or more of the following is true: * a) phase != PH_DATAIN && FIFOs are empty * b) reset has occurred or busfree is detected. */ while (n > 0) { int xfer; /* Wait for fifo half full or phase mismatch */ for (;;) { intstat = bus_space_read_1(iot, ioh, INTS); sstat = bus_space_read_1(iot, ioh, SSTS); if (intstat != 0 || (sstat & SSTS_DREG_FULL) != 0 || (sstat & SSTS_DREG_EMPTY) == 0) break; } #if 1 if (intstat != 0) goto phasechange; #else if (intstat != 0 && (sstat & SSTS_DREG_EMPTY) != 0) goto phasechange; #endif if ((sstat & SSTS_DREG_FULL) != 0) xfer = min(DINAMOUNT, n); else xfer = 1; SPC_MISC((">%d ", xfer)); n -= xfer; in += xfer; #if 0 bus_space_read_multi_1(iot, ioh, DREG, p, xfer); p += xfer; #else switch (xfer) { case 8: *p++ = bus_space_read_1(iot, ioh, DREG); case 7: *p++ = bus_space_read_1(iot, ioh, DREG); case 6: *p++ = bus_space_read_1(iot, ioh, DREG); case 5: *p++ = bus_space_read_1(iot, ioh, DREG); case 4: *p++ = bus_space_read_1(iot, ioh, DREG); case 3: *p++ = bus_space_read_1(iot, ioh, DREG); case 2: *p++ = bus_space_read_1(iot, ioh, DREG); case 1: *p++ = bus_space_read_1(iot, ioh, DREG); } #endif if (intstat != 0) goto phasechange; } /* * Some SCSI-devices are rude enough to transfer more data than what * was requested, e.g. 2048 bytes from a CD-ROM instead of the * requested 512. Test for progress, i.e. real transfers. If no real * transfers have been performed (n is probably already zero) and the * FIFO is not empty, waste some bytes.... */ if (in == 0) { for (;;) { /* XXX needs timeout */ if (bus_space_read_1(iot, ioh, INTS) != 0) break; } SPC_MISC(("extra data ")); } phasechange: /* Stop the FIFO data path. */ return in; } /* * Catch an interrupt from the adaptor */ /* * This is the workhorse routine of the driver. * Deficiencies (for now): * 1) always uses programmed I/O */ int spc_intr(void *arg) { struct spc_softc *sc = arg; bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; u_char ints; struct spc_acb *acb; struct scsi_link *sc_link; struct spc_tinfo *ti; int n; /* * On LUNA-88K2, 2 spc(4)'s share the level 3 interrupt. * So, first, check if this device needs to process this interrupt. */ ints = bus_space_read_1(iot, ioh, INTS); if (ints == 0) /* No interrupt event on this device */ return 0; /* * Disable interrupt. */ bus_space_write_1(iot, ioh, SCTL, bus_space_read_1(iot, ioh, SCTL) & ~SCTL_INTR_ENAB); SPC_TRACE(("spc_intr ")); loop: /* * Loop until transfer completion. */ /* * First check for abnormal conditions, such as reset. */ #ifdef x68k /* XXX? */ while ((ints = bus_space_read_1(iot, ioh, INTS)) == 0) delay(1); SPC_MISC(("ints = 0x%x ", ints)); #else ints = bus_space_read_1(iot, ioh, INTS); SPC_MISC(("ints = 0x%x ", ints)); #endif if ((ints & INTS_RST) != 0) { printf("%s: SCSI bus reset\n", sc->sc_dev.dv_xname); goto reset; } /* * Check for less serious errors. */ if ((bus_space_read_1(iot, ioh, SERR) & (SERR_SCSI_PAR|SERR_SPC_PAR)) != 0) { printf("%s: SCSI bus parity error\n", sc->sc_dev.dv_xname); if (sc->sc_prevphase == PH_MSGIN) { sc->sc_flags |= SPC_DROP_MSGIN; spc_sched_msgout(sc, SEND_PARITY_ERROR); } else spc_sched_msgout(sc, SEND_INIT_DET_ERR); } /* * If we're not already busy doing something test for the following * conditions: * 1) We have been reselected by something * 2) We have selected something successfully * 3) Our selection process has timed out * 4) This is really a bus free interrupt just to get a new command * going? * 5) Spurious interrupt? */ switch (sc->sc_state) { case SPC_IDLE: case SPC_SELECTING: SPC_MISC(("ints:0x%02x ", ints)); if ((ints & INTS_SEL) != 0) { /* * We don't currently support target mode. */ printf("%s: target mode selected; going to BUS FREE\n", sc->sc_dev.dv_xname); goto sched; } else if ((ints & INTS_RESEL) != 0) { SPC_MISC(("reselected ")); /* * If we're trying to select a target ourselves, * push our command back into the ready list. */ if (sc->sc_state == SPC_SELECTING) { SPC_MISC(("backoff selector ")); SPC_ASSERT(sc->sc_nexus != NULL); acb = sc->sc_nexus; sc->sc_nexus = NULL; TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain); } /* Save reselection ID. */ sc->sc_selid = bus_space_read_1(iot, ioh, TEMP); sc->sc_state = SPC_RESELECTED; } else if ((ints & INTS_CMD_DONE) != 0) { SPC_MISC(("selected ")); /* * We have selected a target. Things to do: * a) Determine what message(s) to send. * b) Verify that we're still selecting the target. * c) Mark device as busy. */ if (sc->sc_state != SPC_SELECTING) { printf("%s: selection out while idle; " "resetting\n", sc->sc_dev.dv_xname); SPC_BREAK(); goto reset; } SPC_ASSERT(sc->sc_nexus != NULL); acb = sc->sc_nexus; sc_link = acb->xs->sc_link; ti = &sc->sc_tinfo[sc_link->target]; sc->sc_msgpriq = SEND_IDENTIFY; if (acb->flags & ACB_RESET) sc->sc_msgpriq |= SEND_DEV_RESET; else if (acb->flags & ACB_ABORT) sc->sc_msgpriq |= SEND_ABORT; else { #if SPC_USE_SYNCHRONOUS if ((ti->flags & DO_SYNC) != 0) sc->sc_msgpriq |= SEND_SDTR; #endif #if SPC_USE_WIDE if ((ti->flags & DO_WIDE) != 0) sc->sc_msgpriq |= SEND_WDTR; #endif } acb->flags |= ACB_NEXUS; ti->lubusy |= (1 << sc_link->lun); /* Do an implicit RESTORE POINTERS. */ sc->sc_dp = acb->data_addr; sc->sc_dleft = acb->data_length; sc->sc_cp = (u_char *)&acb->scsi_cmd; sc->sc_cleft = acb->scsi_cmd_length; /* On our first connection, schedule a timeout. */ if ((acb->xs->flags & SCSI_POLL) == 0) timeout_add_msec(&acb->xs->stimeout, acb->xs->timeout); sc->sc_state = SPC_CONNECTED; } else if ((ints & INTS_TIMEOUT) != 0) { SPC_MISC(("selection timeout ")); if (sc->sc_state != SPC_SELECTING) { printf("%s: selection timeout while idle; " "resetting\n", sc->sc_dev.dv_xname); SPC_BREAK(); goto reset; } SPC_ASSERT(sc->sc_nexus != NULL); acb = sc->sc_nexus; delay(250); acb->xs->error = XS_SELTIMEOUT; goto finish; } else { if (sc->sc_state != SPC_IDLE) { printf("%s: BUS FREE while not idle; " "state=%d\n", sc->sc_dev.dv_xname, sc->sc_state); SPC_BREAK(); goto out; } goto sched; } /* * Turn off selection stuff, and prepare to catch bus free * interrupts, parity errors, and phase changes. */ sc->sc_flags = 0; sc->sc_prevphase = PH_INVALID; goto dophase; } if ((ints & INTS_DISCON) != 0) { /* disable disconnect interrupt */ bus_space_write_1(iot, ioh, PCTL, bus_space_read_1(iot, ioh, PCTL) & ~PCTL_BFINT_ENAB); /* XXX reset interrupt */ bus_space_write_1(iot, ioh, INTS, ints); switch (sc->sc_state) { case SPC_RESELECTED: goto sched; case SPC_CONNECTED: SPC_ASSERT(sc->sc_nexus != NULL); acb = sc->sc_nexus; #if SPC_USE_SYNCHRONOUS + SPC_USE_WIDE if (sc->sc_prevphase == PH_MSGOUT) { /* * If the target went to BUS FREE phase during * or immediately after sending a SDTR or WDTR * message, disable negotiation. */ sc_link = acb->xs->sc_link; ti = &sc->sc_tinfo[sc_link->target]; switch (sc->sc_lastmsg) { #if SPC_USE_SYNCHRONOUS case SEND_SDTR: ti->flags &= ~DO_SYNC; ti->period = ti->offset = 0; break; #endif #if SPC_USE_WIDE case SEND_WDTR: ti->flags &= ~DO_WIDE; ti->width = 0; break; #endif } } #endif if ((sc->sc_flags & SPC_ABORTING) == 0) { /* * Section 5.1.1 of the SCSI 2 spec suggests * issuing a REQUEST SENSE following an * unexpected disconnect. Some devices go into * a contingent allegiance condition when * disconnecting, and this is necessary to * clean up their state. */ printf("%s: unexpected disconnect; " "sending REQUEST SENSE\n", sc->sc_dev.dv_xname); SPC_BREAK(); spc_sense(sc, acb); goto out; } acb->xs->error = XS_DRIVER_STUFFUP; goto finish; case SPC_DISCONNECT: SPC_ASSERT(sc->sc_nexus != NULL); acb = sc->sc_nexus; TAILQ_INSERT_HEAD(&sc->nexus_list, acb, chain); sc->sc_nexus = NULL; goto sched; case SPC_CMDCOMPLETE: SPC_ASSERT(sc->sc_nexus != NULL); acb = sc->sc_nexus; goto finish; } } else if ((ints & INTS_CMD_DONE) != 0 && sc->sc_prevphase == PH_MSGIN && sc->sc_state != SPC_CONNECTED) goto out; dophase: #if 0 if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) == 0) { /* Wait for REQINIT. */ goto out; } #else bus_space_write_1(iot, ioh, INTS, ints); ints = 0; while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) == 0) breathe(); /* need timeout XXX */ #endif /* * State transition. */ sc->sc_phase = bus_space_read_1(iot, ioh, PSNS) & PH_MASK; #if 0 bus_space_write_1(iot, ioh, PCTL, sc->sc_phase); #endif SPC_MISC(("phase=%d\n", sc->sc_phase)); switch (sc->sc_phase) { case PH_MSGOUT: if (sc->sc_state != SPC_CONNECTED && sc->sc_state != SPC_RESELECTED) break; spc_msgout(sc); sc->sc_prevphase = PH_MSGOUT; goto loop; case PH_MSGIN: if (sc->sc_state != SPC_CONNECTED && sc->sc_state != SPC_RESELECTED) break; spc_msgin(sc); sc->sc_prevphase = PH_MSGIN; goto loop; case PH_CMD: if (sc->sc_state != SPC_CONNECTED) break; #ifdef SPC_DEBUG if ((spc_debug & SPC_SHOWMISC) != 0) { SPC_ASSERT(sc->sc_nexus != NULL); acb = sc->sc_nexus; printf("cmd=0x%02x+%d ", acb->scsi_cmd.opcode, acb->scsi_cmd_length - 1); } #endif n = spc_dataout_pio(sc, sc->sc_cp, sc->sc_cleft); sc->sc_cp += n; sc->sc_cleft -= n; sc->sc_prevphase = PH_CMD; goto loop; case PH_DATAOUT: if (sc->sc_state != SPC_CONNECTED) break; SPC_MISC(("dataout dleft=%d ", sc->sc_dleft)); n = spc_dataout_pio(sc, sc->sc_dp, sc->sc_dleft); sc->sc_dp += n; sc->sc_dleft -= n; sc->sc_prevphase = PH_DATAOUT; goto loop; case PH_DATAIN: if (sc->sc_state != SPC_CONNECTED) break; SPC_MISC(("datain ")); n = spc_datain_pio(sc, sc->sc_dp, sc->sc_dleft); sc->sc_dp += n; sc->sc_dleft -= n; sc->sc_prevphase = PH_DATAIN; goto loop; case PH_STAT: if (sc->sc_state != SPC_CONNECTED) break; SPC_ASSERT(sc->sc_nexus != NULL); acb = sc->sc_nexus; /*acb->target_stat = bus_space_read_1(iot, ioh, DREG);*/ spc_datain_pio(sc, &acb->target_stat, 1); SPC_MISC(("target_stat=0x%02x ", acb->target_stat)); sc->sc_prevphase = PH_STAT; goto loop; } printf("%s: unexpected bus phase; resetting\n", sc->sc_dev.dv_xname); SPC_BREAK(); reset: spc_init(sc); return 1; finish: timeout_del(&acb->xs->stimeout); bus_space_write_1(iot, ioh, INTS, ints); ints = 0; spc_done(sc, acb); goto out; sched: sc->sc_state = SPC_IDLE; spc_sched(sc); goto out; out: if (ints) bus_space_write_1(iot, ioh, INTS, ints); bus_space_write_1(iot, ioh, SCTL, bus_space_read_1(iot, ioh, SCTL) | SCTL_INTR_ENAB); return 1; } void spc_abort(struct spc_softc *sc, struct spc_acb *acb) { /* 2 secs for the abort */ acb->xs->timeout = SPC_ABORT_TIMEOUT; acb->flags |= ACB_ABORT; if (acb == sc->sc_nexus) { /* * If we're still selecting, the message will be scheduled * after selection is complete. */ if (sc->sc_state == SPC_CONNECTED) spc_sched_msgout(sc, SEND_ABORT); } else { spc_dequeue(sc, acb); TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain); if (sc->sc_state == SPC_IDLE) spc_sched(sc); } } void spc_timeout(void *arg) { struct spc_acb *acb = arg; struct scsi_xfer *xs = acb->xs; struct scsi_link *sc_link = xs->sc_link; struct spc_softc *sc = sc_link->bus->sb_adapter_softc; int s; sc_print_addr(sc_link); printf("timed out"); s = splbio(); if (acb->flags & ACB_ABORT) { /* abort timed out */ printf(" AGAIN\n"); /* XXX Must reset! */ } else { /* abort the operation that has timed out */ printf("\n"); acb->xs->error = XS_TIMEOUT; spc_abort(sc, acb); } splx(s); } #ifdef SPC_DEBUG /* * The following functions are mostly used for debugging purposes, either * directly called from the driver or from the kernel debugger. */ void spc_show_scsi_cmd(spc_acb *acb) { u_char *b = (u_char *)&acb->scsi_cmd; struct scsi_link *sc_link = acb->xs->sc_link; int i; sc_print_addr(sc_link); if ((acb->xs->flags & SCSI_RESET) == 0) { for (i = 0; i < acb->scsi_cmd_length; i++) { if (i) printf(","); printf("%x", b[i]); } printf("\n"); } else printf("RESET\n"); } void spc_print_acb(spc_acb *acb) { printf("acb@%p xs=%p flags=%x", acb, acb->xs, acb->flags); printf(" dp=%p dleft=%d target_stat=%x\n", acb->data_addr, acb->data_length, acb->target_stat); spc_show_scsi_cmd(acb); } void spc_print_active_acb() { struct spc_acb *acb; struct spc_softc *sc = spc_cd.cd_devs[0]; /* XXX */ printf("ready list:\n"); TAILQ_FOREACH(acb, &sc->ready_list, chain) spc_print_acb(acb); printf("nexus:\n"); if (sc->sc_nexus != NULL) spc_print_acb(sc->sc_nexus); printf("nexus list:\n"); TAILQ_FOREACH(acb, &sc->nexus_list, chain) spc_print_acb(acb); } void spc_dump89352(struct spc_softc *sc) { bus_space_tag_t iot = sc->sc_iot; bus_space_handle_t ioh = sc->sc_ioh; printf("mb89352: BDID=%x SCTL=%x SCMD=%x TMOD=%x\n", bus_space_read_1(iot, ioh, BDID), bus_space_read_1(iot, ioh, SCTL), bus_space_read_1(iot, ioh, SCMD), bus_space_read_1(iot, ioh, TMOD)); printf(" INTS=%x PSNS=%x SSTS=%x SERR=%x PCTL=%x\n", bus_space_read_1(iot, ioh, INTS), bus_space_read_1(iot, ioh, PSNS), bus_space_read_1(iot, ioh, SSTS), bus_space_read_1(iot, ioh, SERR), bus_space_read_1(iot, ioh, PCTL)); printf(" MBC=%x DREG=%x TEMP=%x TCH=%x TCM=%x\n", bus_space_read_1(iot, ioh, MBC), #if 0 bus_space_read_1(iot, ioh, DREG), #else 0, #endif bus_space_read_1(iot, ioh, TEMP), bus_space_read_1(iot, ioh, TCH), bus_space_read_1(iot, ioh, TCM)); printf(" TCL=%x EXBF=%x\n", bus_space_read_1(iot, ioh, TCL), bus_space_read_1(iot, ioh, EXBF)); } void spc_dump_driver(struct spc_softc *sc) { struct spc_tinfo *ti; int i; printf("nexus=%p prevphase=%x\n", sc->sc_nexus, sc->sc_prevphase); printf("state=%x msgin=%x msgpriq=%x msgoutq=%x lastmsg=%x " "currmsg=%x\n", sc->sc_state, sc->sc_imess[0], sc->sc_msgpriq, sc->sc_msgoutq, sc->sc_lastmsg, sc->sc_currmsg); for (i = 0; i < 7; i++) { ti = &sc->sc_tinfo[i]; printf("tinfo%d: %d cmds %d disconnects %d timeouts", i, ti->cmds, ti->dconns, ti->touts); printf(" %d senses flags=%x\n", ti->senses, ti->flags); } } #endif