![[BACK]](/icons/back.gif){kind=icon}
Return to ncr53c9x.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to ncr53c9x.c CVS log | Up to [local] / sys / dev / ic |
1.1 ! nbrk 1: /* $OpenBSD: ncr53c9x.c,v 1.34 2007/08/06 08:28:09 tom Exp $ */
! 2: /* $NetBSD: ncr53c9x.c,v 1.56 2000/11/30 14:41:46 thorpej Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1996 Charles M. Hannum. All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: * 3. All advertising materials mentioning features or use of this software
! 16: * must display the following acknowledgement:
! 17: * This product includes software developed by Charles M. Hannum.
! 18: * 4. The name of the author may not be used to endorse or promote products
! 19: * derived from this software without specific prior written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 22: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 23: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 24: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 25: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 26: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 27: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 28: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 29: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 30: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 31: */
! 32:
! 33: /*
! 34: * Copyright (c) 1994 Peter Galbavy
! 35: * Copyright (c) 1995 Paul Kranenburg
! 36: * All rights reserved.
! 37: *
! 38: * Redistribution and use in source and binary forms, with or without
! 39: * modification, are permitted provided that the following conditions
! 40: * are met:
! 41: * 1. Redistributions of source code must retain the above copyright
! 42: * notice, this list of conditions and the following disclaimer.
! 43: * 2. Redistributions in binary form must reproduce the above copyright
! 44: * notice, this list of conditions and the following disclaimer in the
! 45: * documentation and/or other materials provided with the distribution.
! 46: *
! 47: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 48: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
! 49: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 50: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
! 51: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 52: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 53: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 54: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 55: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! 56: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 57: * POSSIBILITY OF SUCH DAMAGE.
! 58: */
! 59:
! 60: /*
! 61: * Based on aic6360 by Jarle Greipsland
! 62: *
! 63: * Acknowledgements: Many of the algorithms used in this driver are
! 64: * inspired by the work of Julian Elischer (julian@tfs.com) and
! 65: * Charles Hannum (mycroft@duality.gnu.ai.mit.edu). Thanks a million!
! 66: */
! 67:
! 68: #include <sys/types.h>
! 69: #include <sys/param.h>
! 70: #include <sys/systm.h>
! 71: #include <sys/kernel.h>
! 72: #include <sys/errno.h>
! 73: #include <sys/ioctl.h>
! 74: #include <sys/device.h>
! 75: #include <sys/buf.h>
! 76: #include <sys/malloc.h>
! 77: #include <sys/proc.h>
! 78: #include <sys/user.h>
! 79: #include <sys/queue.h>
! 80: #include <sys/pool.h>
! 81:
! 82: #include <scsi/scsi_all.h>
! 83: #include <scsi/scsiconf.h>
! 84: #include <scsi/scsi_message.h>
! 85:
! 86: #include <machine/cpu.h>
! 87:
! 88: #include <dev/ic/ncr53c9xreg.h>
! 89: #include <dev/ic/ncr53c9xvar.h>
! 90:
! 91: #ifdef NCR53C9X_DEBUG
! 92: int ncr53c9x_debug = 0; /*NCR_SHOWPHASE|NCR_SHOWMISC|NCR_SHOWTRAC|NCR_SHOWCMDS;*/
! 93: #endif
! 94: #ifdef DEBUG
! 95: int ncr53c9x_notag = 0;
! 96: #endif
! 97:
! 98: /*static*/ void ncr53c9x_readregs(struct ncr53c9x_softc *);
! 99: /*static*/ void ncr53c9x_select(struct ncr53c9x_softc *,
! 100: struct ncr53c9x_ecb *);
! 101: /*static*/ int ncr53c9x_reselect(struct ncr53c9x_softc *, int, int, int);
! 102: /*static*/ void ncr53c9x_scsi_reset(struct ncr53c9x_softc *);
! 103: /*static*/ int ncr53c9x_poll(struct ncr53c9x_softc *,
! 104: struct scsi_xfer *, int);
! 105: /*static*/ void ncr53c9x_sched(struct ncr53c9x_softc *);
! 106: /*static*/ void ncr53c9x_done(struct ncr53c9x_softc *,
! 107: struct ncr53c9x_ecb *);
! 108: /*static*/ void ncr53c9x_msgin(struct ncr53c9x_softc *);
! 109: /*static*/ void ncr53c9x_msgout(struct ncr53c9x_softc *);
! 110: /*static*/ void ncr53c9x_timeout(void *arg);
! 111: /*static*/ void ncr53c9x_watch(void *arg);
! 112: /*static*/ void ncr53c9x_abort(struct ncr53c9x_softc *,
! 113: struct ncr53c9x_ecb *);
! 114: /*static*/ void ncr53c9x_dequeue(struct ncr53c9x_softc *,
! 115: struct ncr53c9x_ecb *);
! 116:
! 117: void ncr53c9x_sense(struct ncr53c9x_softc *,
! 118: struct ncr53c9x_ecb *);
! 119: void ncr53c9x_free_ecb(struct ncr53c9x_softc *,
! 120: struct ncr53c9x_ecb *, int);
! 121: struct ncr53c9x_ecb *ncr53c9x_get_ecb(struct ncr53c9x_softc *, int);
! 122:
! 123: static inline int ncr53c9x_stp2cpb(struct ncr53c9x_softc *, int);
! 124: static inline void ncr53c9x_setsync(struct ncr53c9x_softc *,
! 125: struct ncr53c9x_tinfo *);
! 126: static struct ncr53c9x_linfo *ncr53c9x_lunsearch(struct ncr53c9x_tinfo *,
! 127: int64_t lun);
! 128:
! 129: static void ncr53c9x_wrfifo(struct ncr53c9x_softc *, u_char *, int);
! 130: static int ncr53c9x_rdfifo(struct ncr53c9x_softc *, int);
! 131: #define NCR_RDFIFO_START 0
! 132: #define NCR_RDFIFO_CONTINUE 1
! 133:
! 134: #define NCR_SET_COUNT(sc, size) do { \
! 135: NCR_WRITE_REG((sc), NCR_TCL, (size)); \
! 136: NCR_WRITE_REG((sc), NCR_TCM, (size) >> 8); \
! 137: if ((sc->sc_cfg2 & NCRCFG2_FE) || \
! 138: (sc->sc_rev == NCR_VARIANT_FAS366)) { \
! 139: NCR_WRITE_REG((sc), NCR_TCH, (size) >> 16); \
! 140: } \
! 141: if (sc->sc_rev == NCR_VARIANT_FAS366) { \
! 142: NCR_WRITE_REG(sc, NCR_RCH, 0); \
! 143: } \
! 144: } while (0)
! 145:
! 146: static int ecb_pool_initialized = 0;
! 147: static struct pool ecb_pool;
! 148:
! 149: struct cfdriver esp_cd = {
! 150: NULL, "esp", DV_DULL
! 151: };
! 152:
! 153: /*
! 154: * Names for the NCR53c9x variants, corresponding to the variant tags
! 155: * in ncr53c9xvar.h.
! 156: */
! 157: const char *ncr53c9x_variant_names[] = {
! 158: "ESP100",
! 159: "ESP100A",
! 160: "ESP200",
! 161: "NCR53C94",
! 162: "NCR53C96",
! 163: "ESP406",
! 164: "FAS408",
! 165: "FAS216",
! 166: "AM53C974",
! 167: "FAS366/HME",
! 168: };
! 169:
! 170: /*
! 171: * Search linked list for LUN info by LUN id.
! 172: */
! 173: static struct ncr53c9x_linfo *
! 174: ncr53c9x_lunsearch(ti, lun)
! 175: struct ncr53c9x_tinfo *ti;
! 176: int64_t lun;
! 177: {
! 178: struct ncr53c9x_linfo *li;
! 179: LIST_FOREACH(li, &ti->luns, link)
! 180: if (li->lun == lun)
! 181: return (li);
! 182: return (NULL);
! 183: }
! 184:
! 185: /*
! 186: * Attach this instance, and then all the sub-devices
! 187: */
! 188: void
! 189: ncr53c9x_attach(sc, adapter, dev)
! 190: struct ncr53c9x_softc *sc;
! 191: struct scsi_adapter *adapter;
! 192: struct scsi_device *dev;
! 193: {
! 194: struct scsibus_attach_args saa;
! 195:
! 196: timeout_set(&sc->sc_watchdog, ncr53c9x_watch, sc);
! 197: /*
! 198: * Allocate SCSI message buffers.
! 199: * Front-ends can override allocation to avoid alignment
! 200: * handling in the DMA engines. Note that ncr53c9x_msgout()
! 201: * can request a 1 byte DMA transfer.
! 202: */
! 203: if (sc->sc_omess == NULL)
! 204: sc->sc_omess = malloc(NCR_MAX_MSG_LEN, M_DEVBUF, M_NOWAIT);
! 205:
! 206: if (sc->sc_imess == NULL)
! 207: sc->sc_imess = malloc(NCR_MAX_MSG_LEN+1, M_DEVBUF, M_NOWAIT);
! 208:
! 209: if (sc->sc_omess == NULL || sc->sc_imess == NULL) {
! 210: printf("out of memory\n");
! 211: return;
! 212: }
! 213:
! 214: /*
! 215: * Note, the front-end has set us up to print the chip variation.
! 216: */
! 217: if (sc->sc_rev >= NCR_VARIANT_MAX) {
! 218: printf("\n%s: unknown variant %d, devices not attached\n",
! 219: sc->sc_dev.dv_xname, sc->sc_rev);
! 220: return;
! 221: }
! 222:
! 223: printf(": %s, %dMHz, SCSI ID %d\n",
! 224: ncr53c9x_variant_names[sc->sc_rev], sc->sc_freq, sc->sc_id);
! 225:
! 226: sc->sc_ccf = FREQTOCCF(sc->sc_freq);
! 227:
! 228: /* The value *must not* be == 1. Make it 2 */
! 229: if (sc->sc_ccf == 1)
! 230: sc->sc_ccf = 2;
! 231:
! 232: /*
! 233: * The recommended timeout is 250ms. This register is loaded
! 234: * with a value calculated as follows, from the docs:
! 235: *
! 236: * (timout period) x (CLK frequency)
! 237: * reg = -------------------------------------
! 238: * 8192 x (Clock Conversion Factor)
! 239: *
! 240: * Since CCF has a linear relation to CLK, this generally computes
! 241: * to the constant of 153.
! 242: */
! 243: sc->sc_timeout = ((250 * 1000) * sc->sc_freq) / (8192 * sc->sc_ccf);
! 244:
! 245: /* CCF register only has 3 bits; 0 is actually 8 */
! 246: sc->sc_ccf &= 7;
! 247:
! 248: /* Find how many targets we need to support */
! 249: switch (sc->sc_rev) {
! 250: case NCR_VARIANT_FAS366:
! 251: sc->sc_ntarg = 16;
! 252: break;
! 253: default:
! 254: sc->sc_ntarg = 8;
! 255: break;
! 256: }
! 257:
! 258: /* Reset state & bus */
! 259: sc->sc_cfflags = sc->sc_dev.dv_cfdata->cf_flags;
! 260: sc->sc_state = 0;
! 261: ncr53c9x_init(sc, 1);
! 262:
! 263: /*
! 264: * fill in the prototype scsi_link.
! 265: */
! 266: sc->sc_link.adapter_softc = sc;
! 267: sc->sc_link.adapter_target = sc->sc_id;
! 268: sc->sc_link.adapter = adapter;
! 269: sc->sc_link.device = dev;
! 270: sc->sc_link.openings = 2;
! 271: sc->sc_link.adapter_buswidth = sc->sc_ntarg;
! 272:
! 273: bzero(&saa, sizeof(saa));
! 274: saa.saa_sc_link = &sc->sc_link;
! 275:
! 276: /*
! 277: * Now try to attach all the sub-devices
! 278: */
! 279: config_found(&sc->sc_dev, &saa, scsiprint);
! 280: timeout_add(&sc->sc_watchdog, 60*hz);
! 281: }
! 282:
! 283: /*
! 284: * This is the generic ncr53c9x reset function. It does not reset the SCSI bus,
! 285: * only this controller, but kills any on-going commands, and also stops
! 286: * and resets the DMA.
! 287: *
! 288: * After reset, registers are loaded with the defaults from the attach
! 289: * routine above.
! 290: */
! 291: void
! 292: ncr53c9x_reset(sc)
! 293: struct ncr53c9x_softc *sc;
! 294: {
! 295:
! 296: /* reset DMA first */
! 297: NCRDMA_RESET(sc);
! 298:
! 299: /* reset SCSI chip */
! 300: NCRCMD(sc, NCRCMD_RSTCHIP);
! 301: NCRCMD(sc, NCRCMD_NOP);
! 302: DELAY(500);
! 303:
! 304: /* do these backwards, and fall through */
! 305: switch (sc->sc_rev) {
! 306: case NCR_VARIANT_ESP406:
! 307: case NCR_VARIANT_FAS408:
! 308: NCR_WRITE_REG(sc, NCR_CFG5, sc->sc_cfg5 | NCRCFG5_SINT);
! 309: NCR_WRITE_REG(sc, NCR_CFG4, sc->sc_cfg4);
! 310: case NCR_VARIANT_AM53C974:
! 311: case NCR_VARIANT_FAS216:
! 312: case NCR_VARIANT_NCR53C94:
! 313: case NCR_VARIANT_NCR53C96:
! 314: case NCR_VARIANT_ESP200:
! 315: sc->sc_features |= NCR_F_HASCFG3;
! 316: NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
! 317: case NCR_VARIANT_ESP100A:
! 318: sc->sc_features |= NCR_F_SELATN3;
! 319: NCR_WRITE_REG(sc, NCR_CFG2, sc->sc_cfg2);
! 320: case NCR_VARIANT_ESP100:
! 321: NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
! 322: NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
! 323: NCR_WRITE_REG(sc, NCR_SYNCOFF, 0);
! 324: NCR_WRITE_REG(sc, NCR_TIMEOUT, sc->sc_timeout);
! 325: break;
! 326: case NCR_VARIANT_FAS366:
! 327: sc->sc_features |=
! 328: NCR_F_SELATN3 | NCR_F_HASCFG3 | NCR_F_FASTSCSI;
! 329: sc->sc_cfg3 = NCRFASCFG3_FASTCLK | NCRFASCFG3_OBAUTO;
! 330: sc->sc_cfg3_fscsi = NCRFASCFG3_FASTSCSI;
! 331: NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
! 332: sc->sc_cfg2 = 0; /* NCRCFG2_HMEFE | NCRCFG2_HME32 */
! 333: NCR_WRITE_REG(sc, NCR_CFG2, sc->sc_cfg2);
! 334: NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
! 335: NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
! 336: NCR_WRITE_REG(sc, NCR_SYNCOFF, 0);
! 337: NCR_WRITE_REG(sc, NCR_TIMEOUT, sc->sc_timeout);
! 338: break;
! 339: default:
! 340: printf("%s: unknown revision code, assuming ESP100\n",
! 341: sc->sc_dev.dv_xname);
! 342: NCR_WRITE_REG(sc, NCR_CFG1, sc->sc_cfg1);
! 343: NCR_WRITE_REG(sc, NCR_CCF, sc->sc_ccf);
! 344: NCR_WRITE_REG(sc, NCR_SYNCOFF, 0);
! 345: NCR_WRITE_REG(sc, NCR_TIMEOUT, sc->sc_timeout);
! 346: }
! 347:
! 348: if (sc->sc_rev == NCR_VARIANT_AM53C974)
! 349: NCR_WRITE_REG(sc, NCR_AMDCFG4, sc->sc_cfg4);
! 350:
! 351: #if 0
! 352: printf("%s: ncr53c9x_reset: revision %d\n",
! 353: sc->sc_dev.dv_xname, sc->sc_rev);
! 354: printf("%s: ncr53c9x_reset: cfg1 0x%x, cfg2 0x%x, cfg3 0x%x, ccf 0x%x, timeout 0x%x\n",
! 355: sc->sc_dev.dv_xname,
! 356: sc->sc_cfg1, sc->sc_cfg2, sc->sc_cfg3,
! 357: sc->sc_ccf, sc->sc_timeout);
! 358: #endif
! 359: }
! 360:
! 361: /*
! 362: * Reset the SCSI bus, but not the chip
! 363: */
! 364: void
! 365: ncr53c9x_scsi_reset(sc)
! 366: struct ncr53c9x_softc *sc;
! 367: {
! 368:
! 369: (*sc->sc_glue->gl_dma_stop)(sc);
! 370:
! 371: printf("%s: resetting SCSI bus\n", sc->sc_dev.dv_xname);
! 372: NCRCMD(sc, NCRCMD_RSTSCSI);
! 373: }
! 374:
! 375: /*
! 376: * Initialize ncr53c9x state machine
! 377: */
! 378: void
! 379: ncr53c9x_init(sc, doreset)
! 380: struct ncr53c9x_softc *sc;
! 381: int doreset;
! 382: {
! 383: struct ncr53c9x_ecb *ecb;
! 384: struct ncr53c9x_linfo *li;
! 385: int r, i;
! 386:
! 387: NCR_TRACE(("[NCR_INIT(%d) %d] ", doreset, sc->sc_state));
! 388:
! 389: if (!ecb_pool_initialized) {
! 390: /* All instances share this pool */
! 391: pool_init(&ecb_pool, sizeof(struct ncr53c9x_ecb), 0, 0, 0,
! 392: "ncr53c9x_ecb", NULL);
! 393: ecb_pool_initialized = 1;
! 394: }
! 395:
! 396: if (sc->sc_state == 0) {
! 397: /* First time through; initialize. */
! 398:
! 399: TAILQ_INIT(&sc->ready_list);
! 400: sc->sc_nexus = NULL;
! 401: bzero(sc->sc_tinfo, sizeof(sc->sc_tinfo));
! 402: for (r = 0; r < sc->sc_ntarg; r++) {
! 403: LIST_INIT(&sc->sc_tinfo[r].luns);
! 404: }
! 405: } else {
! 406: /* Cancel any active commands. */
! 407: sc->sc_state = NCR_CLEANING;
! 408: sc->sc_msgify = 0;
! 409: if ((ecb = sc->sc_nexus) != NULL) {
! 410: ecb->xs->error = XS_TIMEOUT;
! 411: ncr53c9x_done(sc, ecb);
! 412: }
! 413: for (r = 0; r < sc->sc_ntarg; r++) {
! 414: LIST_FOREACH(li, &sc->sc_tinfo[r].luns, link) {
! 415: if ((ecb = li->untagged)) {
! 416: li->untagged = NULL;
! 417: /*
! 418: * XXXXXXX
! 419: * Should we terminate a command
! 420: * that never reached the disk?
! 421: */
! 422: li->busy = 0;
! 423: ecb->xs->error = XS_TIMEOUT;
! 424: ncr53c9x_done(sc, ecb);
! 425: }
! 426: for (i = 0; i < 256; i++)
! 427: if ((ecb = li->queued[i])) {
! 428: li->queued[i] = NULL;
! 429: ecb->xs->error = XS_TIMEOUT;
! 430: ncr53c9x_done(sc, ecb);
! 431: }
! 432: li->used = 0;
! 433: }
! 434: }
! 435: }
! 436:
! 437: /*
! 438: * reset the chip to a known state
! 439: */
! 440: ncr53c9x_reset(sc);
! 441:
! 442: sc->sc_phase = sc->sc_prevphase = INVALID_PHASE;
! 443: for (r = 0; r < sc->sc_ntarg; r++) {
! 444: struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[r];
! 445: /* XXX - config flags per target: low bits: no reselect; high bits: no synch */
! 446:
! 447: ti->flags = ((!(sc->sc_cfflags & (1 << (r + 16))) &&
! 448: sc->sc_minsync) ? 0 : T_SYNCHOFF) |
! 449: ((sc->sc_cfflags & (1 << r)) ? T_RSELECTOFF : 0) |
! 450: T_NEED_TO_RESET;
! 451: #ifdef DEBUG
! 452: if (ncr53c9x_notag)
! 453: ti->flags &= ~T_TAG;
! 454: #endif
! 455: ti->period = sc->sc_minsync;
! 456: ti->offset = 0;
! 457: ti->cfg3 = 0;
! 458: }
! 459:
! 460: if (doreset) {
! 461: sc->sc_state = NCR_SBR;
! 462: NCRCMD(sc, NCRCMD_RSTSCSI);
! 463: /*
! 464: * XXX gross...
! 465: * On some systems, commands issued too close to a reset
! 466: * do not work correctly. We'll force a short delay on
! 467: * known-to-be-sensitive chips.
! 468: */
! 469: switch (sc->sc_rev) {
! 470: case NCR_VARIANT_NCR53C94:
! 471: DELAY(600000); /* 600ms */
! 472: break;
! 473: case NCR_VARIANT_NCR53C96:
! 474: DELAY(100000); /* 100ms */
! 475: break;
! 476: }
! 477: } else {
! 478: sc->sc_state = NCR_IDLE;
! 479: ncr53c9x_sched(sc);
! 480: }
! 481: }
! 482:
! 483: /*
! 484: * Read the NCR registers, and save their contents for later use.
! 485: * NCR_STAT, NCR_STEP & NCR_INTR are mostly zeroed out when reading
! 486: * NCR_INTR - so make sure it is the last read.
! 487: *
! 488: * I think that (from reading the docs) most bits in these registers
! 489: * only make sense when he DMA CSR has an interrupt showing. Call only
! 490: * if an interrupt is pending.
! 491: */
! 492: __inline__ void
! 493: ncr53c9x_readregs(sc)
! 494: struct ncr53c9x_softc *sc;
! 495: {
! 496:
! 497: sc->sc_espstat = NCR_READ_REG(sc, NCR_STAT);
! 498: /* Only the stepo bits are of interest */
! 499: sc->sc_espstep = NCR_READ_REG(sc, NCR_STEP) & NCRSTEP_MASK;
! 500:
! 501: if (sc->sc_rev == NCR_VARIANT_FAS366)
! 502: sc->sc_espstat2 = NCR_READ_REG(sc, NCR_STAT2);
! 503:
! 504: sc->sc_espintr = NCR_READ_REG(sc, NCR_INTR);
! 505:
! 506: if (sc->sc_glue->gl_clear_latched_intr != NULL)
! 507: (*sc->sc_glue->gl_clear_latched_intr)(sc);
! 508:
! 509: /*
! 510: * Determine the SCSI bus phase, return either a real SCSI bus phase
! 511: * or some pseudo phase we use to detect certain exceptions.
! 512: */
! 513:
! 514: sc->sc_phase = (sc->sc_espintr & NCRINTR_DIS)
! 515: ? /* Disconnected */ BUSFREE_PHASE
! 516: : sc->sc_espstat & NCRSTAT_PHASE;
! 517:
! 518: NCR_MISC(("regs[intr=%02x,stat=%02x,step=%02x,stat2=%02x] ",
! 519: sc->sc_espintr, sc->sc_espstat, sc->sc_espstep, sc->sc_espstat2));
! 520: }
! 521:
! 522: /*
! 523: * Convert Synchronous Transfer Period to chip register Clock Per Byte value.
! 524: */
! 525: static inline int
! 526: ncr53c9x_stp2cpb(sc, period)
! 527: struct ncr53c9x_softc *sc;
! 528: int period;
! 529: {
! 530: int v;
! 531: v = (sc->sc_freq * period) / 250;
! 532: if (ncr53c9x_cpb2stp(sc, v) < period)
! 533: /* Correct round-down error */
! 534: v++;
! 535: return (v);
! 536: }
! 537:
! 538: static inline void
! 539: ncr53c9x_setsync(sc, ti)
! 540: struct ncr53c9x_softc *sc;
! 541: struct ncr53c9x_tinfo *ti;
! 542: {
! 543: u_char syncoff, synctp;
! 544: u_char cfg3 = sc->sc_cfg3 | ti->cfg3;
! 545:
! 546: if (ti->flags & T_SYNCMODE) {
! 547: syncoff = ti->offset;
! 548: synctp = ncr53c9x_stp2cpb(sc, ti->period);
! 549: if (sc->sc_features & NCR_F_FASTSCSI) {
! 550: /*
! 551: * If the period is 200ns or less (ti->period <= 50),
! 552: * put the chip in Fast SCSI mode.
! 553: */
! 554: if (ti->period <= 50)
! 555: /*
! 556: * There are (at least) 4 variations of the
! 557: * configuration 3 register. The drive attach
! 558: * routine sets the appropriate bit to put the
! 559: * chip into Fast SCSI mode so that it doesn't
! 560: * have to be figured out here each time.
! 561: */
! 562: cfg3 |= (sc->sc_rev == NCR_VARIANT_AM53C974) ?
! 563: NCRAMDCFG3_FSCSI : NCRCFG3_FSCSI;
! 564: }
! 565:
! 566: /*
! 567: * Am53c974 requires different SYNCTP values when the
! 568: * FSCSI bit is off.
! 569: */
! 570: if (sc->sc_rev == NCR_VARIANT_AM53C974 &&
! 571: (cfg3 & NCRAMDCFG3_FSCSI) == 0)
! 572: synctp--;
! 573: } else {
! 574: syncoff = 0;
! 575: synctp = 0;
! 576: }
! 577:
! 578: if (sc->sc_features & NCR_F_HASCFG3)
! 579: NCR_WRITE_REG(sc, NCR_CFG3, cfg3);
! 580:
! 581: NCR_WRITE_REG(sc, NCR_SYNCOFF, syncoff);
! 582: NCR_WRITE_REG(sc, NCR_SYNCTP, synctp);
! 583: }
! 584:
! 585: /*
! 586: * Send a command to a target, set the driver state to NCR_SELECTING
! 587: * and let the caller take care of the rest.
! 588: *
! 589: * Keeping this as a function allows me to say that this may be done
! 590: * by DMA instead of programmed I/O soon.
! 591: */
! 592: void
! 593: ncr53c9x_select(sc, ecb)
! 594: struct ncr53c9x_softc *sc;
! 595: struct ncr53c9x_ecb *ecb;
! 596: {
! 597: struct scsi_link *sc_link = ecb->xs->sc_link;
! 598: int target = sc_link->target;
! 599: int lun = sc_link->lun;
! 600: struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[target];
! 601: int tiflags = ti->flags;
! 602: u_char *cmd;
! 603: int clen;
! 604: int selatn3, selatns;
! 605: size_t dmasize;
! 606:
! 607: NCR_TRACE(("[ncr53c9x_select(t%d,l%d,cmd:%x,tag%x,%x)] ",
! 608: target, lun, ecb->cmd.cmd.opcode, ecb->tag[0], ecb->tag[1]));
! 609:
! 610: sc->sc_state = NCR_SELECTING;
! 611: /*
! 612: * Schedule the timeout now, the first time we will go away
! 613: * expecting to come back due to an interrupt, because it is
! 614: * always possible that the interrupt may never happen.
! 615: */
! 616: if ((ecb->xs->flags & SCSI_POLL) == 0) {
! 617: int timeout = ecb->timeout;
! 618:
! 619: if (timeout > 1000000)
! 620: timeout = (timeout / 1000) * hz;
! 621: else
! 622: timeout = (timeout * hz) / 1000;
! 623: timeout_add(&ecb->to, timeout);
! 624: }
! 625:
! 626: /*
! 627: * The docs say the target register is never reset, and I
! 628: * can't think of a better place to set it
! 629: */
! 630: if (sc->sc_rev == NCR_VARIANT_FAS366) {
! 631: NCRCMD(sc, NCRCMD_FLUSH);
! 632: NCR_WRITE_REG(sc, NCR_SELID, target | NCR_BUSID_HME);
! 633: } else {
! 634: NCR_WRITE_REG(sc, NCR_SELID, target);
! 635: }
! 636: ncr53c9x_setsync(sc, ti);
! 637:
! 638: if ((ecb->flags & ECB_SENSE) != 0) {
! 639: /*
! 640: * For REQUEST SENSE, we should not send an IDENTIFY or
! 641: * otherwise mangle the target. There should be no MESSAGE IN
! 642: * phase.
! 643: */
! 644: if (sc->sc_features & NCR_F_DMASELECT) {
! 645: /* setup DMA transfer for command */
! 646: dmasize = clen = ecb->clen;
! 647: sc->sc_cmdlen = clen;
! 648: sc->sc_cmdp = (caddr_t)&ecb->cmd.cmd;
! 649:
! 650: NCRDMA_SETUP(sc, &sc->sc_cmdp, &sc->sc_cmdlen, 0,
! 651: &dmasize);
! 652: /* Program the SCSI counter */
! 653: NCR_SET_COUNT(sc, dmasize);
! 654:
! 655: if (sc->sc_rev != NCR_VARIANT_FAS366)
! 656: NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
! 657:
! 658: /* And get the targets attention */
! 659: NCRCMD(sc, NCRCMD_SELNATN | NCRCMD_DMA);
! 660: NCRDMA_GO(sc);
! 661: } else {
! 662: ncr53c9x_wrfifo(sc, (u_char *)&ecb->cmd.cmd, ecb->clen);
! 663: NCRCMD(sc, NCRCMD_SELNATN);
! 664: }
! 665: return;
! 666: }
! 667:
! 668: selatn3 = selatns = 0;
! 669: if (ecb->tag[0] != 0) {
! 670: if (sc->sc_features & NCR_F_SELATN3)
! 671: /* use SELATN3 to send tag messages */
! 672: selatn3 = 1;
! 673: else
! 674: /* We don't have SELATN3; use SELATNS to send tags */
! 675: selatns = 1;
! 676: }
! 677:
! 678: if (ti->flags & T_NEGOTIATE) {
! 679: /* We have to use SELATNS to send sync/wide messages */
! 680: selatn3 = 0;
! 681: selatns = 1;
! 682: }
! 683:
! 684: cmd = (u_char *)&ecb->cmd.cmd;
! 685:
! 686: if (selatn3) {
! 687: /* We'll use tags with SELATN3 */
! 688: clen = ecb->clen + 3;
! 689: cmd -= 3;
! 690: cmd[0] = MSG_IDENTIFY(lun, 1); /* msg[0] */
! 691: cmd[1] = ecb->tag[0]; /* msg[1] */
! 692: cmd[2] = ecb->tag[1]; /* msg[2] */
! 693: } else {
! 694: /* We don't have tags, or will send messages with SELATNS */
! 695: clen = ecb->clen + 1;
! 696: cmd -= 1;
! 697: cmd[0] = MSG_IDENTIFY(lun, (tiflags & T_RSELECTOFF) == 0);
! 698: }
! 699:
! 700: if ((sc->sc_features & NCR_F_DMASELECT) && !selatns) {
! 701:
! 702: /* setup DMA transfer for command */
! 703: dmasize = clen;
! 704: sc->sc_cmdlen = clen;
! 705: sc->sc_cmdp = cmd;
! 706:
! 707: NCRDMA_SETUP(sc, &sc->sc_cmdp, &sc->sc_cmdlen, 0, &dmasize);
! 708: /* Program the SCSI counter */
! 709: NCR_SET_COUNT(sc, dmasize);
! 710:
! 711: /* load the count in */
! 712: /* if (sc->sc_rev != NCR_VARIANT_FAS366) */
! 713: NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
! 714:
! 715: /* And get the targets attention */
! 716: if (selatn3) {
! 717: sc->sc_msgout = SEND_TAG;
! 718: sc->sc_flags |= NCR_ATN;
! 719: NCRCMD(sc, NCRCMD_SELATN3 | NCRCMD_DMA);
! 720: } else
! 721: NCRCMD(sc, NCRCMD_SELATN | NCRCMD_DMA);
! 722: NCRDMA_GO(sc);
! 723: return;
! 724: }
! 725:
! 726: /*
! 727: * Who am I. This is where we tell the target that we are
! 728: * happy for it to disconnect etc.
! 729: */
! 730:
! 731: /* Now get the command into the FIFO */
! 732: ncr53c9x_wrfifo(sc, cmd, clen);
! 733:
! 734: /* And get the targets attention */
! 735: if (selatns) {
! 736: NCR_MISC(("SELATNS \n"));
! 737: /* Arbitrate, select and stop after IDENTIFY message */
! 738: NCRCMD(sc, NCRCMD_SELATNS);
! 739: } else if (selatn3) {
! 740: sc->sc_msgout = SEND_TAG;
! 741: sc->sc_flags |= NCR_ATN;
! 742: NCRCMD(sc, NCRCMD_SELATN3);
! 743: } else
! 744: NCRCMD(sc, NCRCMD_SELATN);
! 745: }
! 746:
! 747: void
! 748: ncr53c9x_free_ecb(sc, ecb, flags)
! 749: struct ncr53c9x_softc *sc;
! 750: struct ncr53c9x_ecb *ecb;
! 751: int flags;
! 752: {
! 753: int s;
! 754:
! 755: s = splbio();
! 756: ecb->flags = 0;
! 757: pool_put(&ecb_pool, (void *)ecb);
! 758: splx(s);
! 759: }
! 760:
! 761: struct ncr53c9x_ecb *
! 762: ncr53c9x_get_ecb(sc, flags)
! 763: struct ncr53c9x_softc *sc;
! 764: int flags;
! 765: {
! 766: struct ncr53c9x_ecb *ecb;
! 767: int s, wait = 0;
! 768:
! 769: if ((curproc != NULL) && ((flags & SCSI_NOSLEEP) == 0))
! 770: wait = PR_WAITOK;
! 771:
! 772: s = splbio();
! 773: ecb = (struct ncr53c9x_ecb *)pool_get(&ecb_pool, wait);
! 774: splx(s);
! 775: if (ecb == NULL)
! 776: return (NULL);
! 777: bzero(ecb, sizeof(*ecb));
! 778: timeout_set(&ecb->to, ncr53c9x_timeout, ecb);
! 779: ecb->flags |= ECB_ALLOC;
! 780: return (ecb);
! 781: }
! 782:
! 783: /*
! 784: * DRIVER FUNCTIONS CALLABLE FROM HIGHER LEVEL DRIVERS
! 785: */
! 786:
! 787: /*
! 788: * Start a SCSI-command
! 789: * This function is called by the higher level SCSI-driver to queue/run
! 790: * SCSI-commands.
! 791: */
! 792: int
! 793: ncr53c9x_scsi_cmd(xs)
! 794: struct scsi_xfer *xs;
! 795: {
! 796: struct scsi_link *sc_link = xs->sc_link;
! 797: struct ncr53c9x_softc *sc = sc_link->adapter_softc;
! 798: struct ncr53c9x_ecb *ecb;
! 799: struct ncr53c9x_tinfo *ti;
! 800: struct ncr53c9x_linfo *li;
! 801: int64_t lun = sc_link->lun;
! 802: int s, flags;
! 803:
! 804: NCR_TRACE(("[ncr53c9x_scsi_cmd] "));
! 805: NCR_CMDS(("[0x%x, %d]->%d ", (int)xs->cmd->opcode, xs->cmdlen,
! 806: sc_link->target));
! 807:
! 808: flags = xs->flags;
! 809: ti = &sc->sc_tinfo[sc_link->target];
! 810: li = TINFO_LUN(ti, lun);
! 811: if (li == NULL) {
! 812: /* Initialize LUN info and add to list. */
! 813: if ((li = malloc(sizeof(*li), M_DEVBUF, M_NOWAIT)) == NULL) {
! 814: return (TRY_AGAIN_LATER);
! 815: }
! 816: bzero(li, sizeof(*li));
! 817: li->last_used = time_second;
! 818: li->lun = lun;
! 819: s = splbio();
! 820: LIST_INSERT_HEAD(&ti->luns, li, link);
! 821: if (lun < NCR_NLUN)
! 822: ti->lun[lun] = li;
! 823: splx(s);
! 824: }
! 825:
! 826: if ((ecb = ncr53c9x_get_ecb(sc, flags)) == NULL)
! 827: return (TRY_AGAIN_LATER);
! 828:
! 829: /* Initialize ecb */
! 830: ecb->xs = xs;
! 831: ecb->timeout = xs->timeout;
! 832:
! 833: if (flags & SCSI_RESET) {
! 834: ecb->flags |= ECB_RESET;
! 835: ecb->clen = 0;
! 836: ecb->dleft = 0;
! 837: } else {
! 838: bcopy(xs->cmd, &ecb->cmd.cmd, xs->cmdlen);
! 839: ecb->clen = xs->cmdlen;
! 840: ecb->daddr = xs->data;
! 841: ecb->dleft = xs->datalen;
! 842: }
! 843: ecb->stat = 0;
! 844:
! 845: s = splbio();
! 846:
! 847: TAILQ_INSERT_TAIL(&sc->ready_list, ecb, chain);
! 848: ecb->flags |= ECB_READY;
! 849: if (sc->sc_state == NCR_IDLE)
! 850: ncr53c9x_sched(sc);
! 851:
! 852: splx(s);
! 853:
! 854: if ((flags & SCSI_POLL) == 0)
! 855: return (SUCCESSFULLY_QUEUED);
! 856:
! 857: /* Not allowed to use interrupts, use polling instead */
! 858: if (ncr53c9x_poll(sc, xs, ecb->timeout)) {
! 859: ncr53c9x_timeout(ecb);
! 860: if (ncr53c9x_poll(sc, xs, ecb->timeout))
! 861: ncr53c9x_timeout(ecb);
! 862: }
! 863: return (COMPLETE);
! 864: }
! 865:
! 866: /*
! 867: * Used when interrupt driven I/O isn't allowed, e.g. during boot.
! 868: */
! 869: int
! 870: ncr53c9x_poll(sc, xs, count)
! 871: struct ncr53c9x_softc *sc;
! 872: struct scsi_xfer *xs;
! 873: int count;
! 874: {
! 875:
! 876: NCR_TRACE(("[ncr53c9x_poll] "));
! 877: while (count) {
! 878: if (NCRDMA_ISINTR(sc)) {
! 879: ncr53c9x_intr(sc);
! 880: }
! 881: #if alternatively
! 882: if (NCR_READ_REG(sc, NCR_STAT) & NCRSTAT_INT)
! 883: ncr53c9x_intr(sc);
! 884: #endif
! 885: if ((xs->flags & ITSDONE) != 0)
! 886: return (0);
! 887: if (sc->sc_state == NCR_IDLE) {
! 888: NCR_TRACE(("[ncr53c9x_poll: rescheduling] "));
! 889: ncr53c9x_sched(sc);
! 890: }
! 891: DELAY(1000);
! 892: count--;
! 893: }
! 894: return (1);
! 895: }
! 896:
! 897:
! 898: /*
! 899: * LOW LEVEL SCSI UTILITIES
! 900: */
! 901:
! 902: /*
! 903: * Schedule a scsi operation. This has now been pulled out of the interrupt
! 904: * handler so that we may call it from ncr53c9x_scsi_cmd and ncr53c9x_done.
! 905: * This may save us an unnecessary interrupt just to get things going.
! 906: * Should only be called when state == NCR_IDLE and at bio pl.
! 907: */
! 908: void
! 909: ncr53c9x_sched(sc)
! 910: struct ncr53c9x_softc *sc;
! 911: {
! 912: struct ncr53c9x_ecb *ecb;
! 913: struct scsi_link *sc_link;
! 914: struct ncr53c9x_tinfo *ti;
! 915: int lun;
! 916: struct ncr53c9x_linfo *li;
! 917: int s, tag;
! 918:
! 919: NCR_TRACE(("[ncr53c9x_sched] "));
! 920: if (sc->sc_state != NCR_IDLE)
! 921: panic("ncr53c9x_sched: not IDLE (state=%d)", sc->sc_state);
! 922:
! 923: /*
! 924: * Find first ecb in ready queue that is for a target/lunit
! 925: * combinations that is not busy.
! 926: */
! 927: TAILQ_FOREACH(ecb, &sc->ready_list, chain) {
! 928: sc_link = ecb->xs->sc_link;
! 929: ti = &sc->sc_tinfo[sc_link->target];
! 930: lun = sc_link->lun;
! 931:
! 932: /* Select type of tag for this command */
! 933: if ((ti->flags & (T_RSELECTOFF)) != 0)
! 934: tag = 0;
! 935: else if ((ti->flags & T_TAG) == 0)
! 936: tag = 0;
! 937: else if ((ecb->flags & ECB_SENSE) != 0)
! 938: tag = 0;
! 939: else if (ecb->xs->flags & SCSI_URGENT)
! 940: tag = MSG_HEAD_OF_Q_TAG;
! 941: else
! 942: tag = MSG_SIMPLE_Q_TAG;
! 943: #if 0
! 944: /* XXXX Use tags for polled commands? */
! 945: if (ecb->xs->flags & SCSI_POLL)
! 946: tag = 0;
! 947: #endif
! 948: s = splbio();
! 949: li = TINFO_LUN(ti, lun);
! 950: if (!li) {
! 951: /* Initialize LUN info and add to list. */
! 952: if ((li = malloc(sizeof(*li), M_DEVBUF, M_NOWAIT)) == NULL) {
! 953: splx(s);
! 954: continue;
! 955: }
! 956: bzero(li, sizeof(*li));
! 957: li->lun = lun;
! 958:
! 959: LIST_INSERT_HEAD(&ti->luns, li, link);
! 960: if (lun < NCR_NLUN)
! 961: ti->lun[lun] = li;
! 962: }
! 963: li->last_used = time_second;
! 964: if (!tag) {
! 965: /* Try to issue this as an un-tagged command */
! 966: if (!li->untagged)
! 967: li->untagged = ecb;
! 968: }
! 969: if (li->untagged) {
! 970: tag = 0;
! 971: if ((li->busy != 1) && !li->used) {
! 972: /* We need to issue this untagged command now */
! 973: ecb = li->untagged;
! 974: sc_link = ecb->xs->sc_link;
! 975: }
! 976: else {
! 977: /* Not ready yet */
! 978: splx(s);
! 979: continue;
! 980: }
! 981: }
! 982: ecb->tag[0] = tag;
! 983: if (tag) {
! 984: int i;
! 985:
! 986: /* Allocate a tag */
! 987: if (li->used == 255) {
! 988: /* no free tags */
! 989: splx(s);
! 990: continue;
! 991: }
! 992: /* Start from the last used location */
! 993: for (i=li->avail; i<256; i++) {
! 994: if (li->queued[i] == NULL)
! 995: break;
! 996: }
! 997: /* Couldn't find one, start again from the beginning */
! 998: if (i == 256) {
! 999: for (i = 0; i<256; i++) {
! 1000: if (li->queued[i] == NULL)
! 1001: break;
! 1002: }
! 1003: }
! 1004: #ifdef DIAGNOSTIC
! 1005: if (i == 256)
! 1006: panic("ncr53c9x_sched: tag alloc failure");
! 1007: #endif
! 1008:
! 1009: /* Save where to start next time. */
! 1010: li->avail = i+1;
! 1011: li->used++;
! 1012:
! 1013: li->queued[i] = ecb;
! 1014: ecb->tag[1] = i;
! 1015: }
! 1016: splx(s);
! 1017: if (li->untagged && (li->busy != 1)) {
! 1018: li->busy = 1;
! 1019: TAILQ_REMOVE(&sc->ready_list, ecb, chain);
! 1020: ecb->flags &= ~ECB_READY;
! 1021: sc->sc_nexus = ecb;
! 1022: ncr53c9x_select(sc, ecb);
! 1023: break;
! 1024: }
! 1025: if (!li->untagged && tag) {
! 1026: TAILQ_REMOVE(&sc->ready_list, ecb, chain);
! 1027: ecb->flags &= ~ECB_READY;
! 1028: sc->sc_nexus = ecb;
! 1029: ncr53c9x_select(sc, ecb);
! 1030: break;
! 1031: } else
! 1032: NCR_MISC(("%d:%d busy\n",
! 1033: sc_link->target,
! 1034: sc_link->lun));
! 1035: }
! 1036: }
! 1037:
! 1038: void
! 1039: ncr53c9x_sense(sc, ecb)
! 1040: struct ncr53c9x_softc *sc;
! 1041: struct ncr53c9x_ecb *ecb;
! 1042: {
! 1043: struct scsi_xfer *xs = ecb->xs;
! 1044: struct scsi_link *sc_link = xs->sc_link;
! 1045: struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[sc_link->target];
! 1046: struct scsi_sense *ss = (void *)&ecb->cmd.cmd;
! 1047: struct ncr53c9x_linfo *li;
! 1048: int lun = sc_link->lun;
! 1049:
! 1050: NCR_MISC(("requesting sense "));
! 1051: /* Next, setup a request sense command block */
! 1052: bzero(ss, sizeof(*ss));
! 1053: ss->opcode = REQUEST_SENSE;
! 1054: ss->byte2 = sc_link->lun << 5;
! 1055: ss->length = sizeof(struct scsi_sense_data);
! 1056: ecb->clen = sizeof(*ss);
! 1057: ecb->daddr = (char *)&xs->sense;
! 1058: ecb->dleft = sizeof(struct scsi_sense_data);
! 1059: ecb->flags |= ECB_SENSE;
! 1060: ecb->timeout = NCR_SENSE_TIMEOUT;
! 1061: ti->senses++;
! 1062: li = TINFO_LUN(ti, lun);
! 1063: if (li->busy) li->busy = 0;
! 1064: ncr53c9x_dequeue(sc, ecb);
! 1065: li->untagged = ecb;
! 1066: li->busy = 2;
! 1067: if (ecb == sc->sc_nexus) {
! 1068: ncr53c9x_select(sc, ecb);
! 1069: } else {
! 1070: TAILQ_INSERT_HEAD(&sc->ready_list, ecb, chain);
! 1071: ecb->flags |= ECB_READY;
! 1072: if (sc->sc_state == NCR_IDLE)
! 1073: ncr53c9x_sched(sc);
! 1074: }
! 1075: }
! 1076:
! 1077: /*
! 1078: * POST PROCESSING OF SCSI_CMD (usually current)
! 1079: */
! 1080: void
! 1081: ncr53c9x_done(sc, ecb)
! 1082: struct ncr53c9x_softc *sc;
! 1083: struct ncr53c9x_ecb *ecb;
! 1084: {
! 1085: struct scsi_xfer *xs = ecb->xs;
! 1086: struct scsi_link *sc_link = xs->sc_link;
! 1087: struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[sc_link->target];
! 1088: int lun = sc_link->lun;
! 1089: struct ncr53c9x_linfo *li = TINFO_LUN(ti, lun);
! 1090:
! 1091: NCR_TRACE(("[ncr53c9x_done(error:%x)] ", xs->error));
! 1092:
! 1093: timeout_del(&ecb->to);
! 1094:
! 1095: if (ecb->stat == SCSI_QUEUE_FULL) {
! 1096: /*
! 1097: * Set current throttle -- we should reset
! 1098: * this periodically
! 1099: */
! 1100: sc_link->openings = li->used - 1;
! 1101: printf("\n%s: QFULL -- throttling to %d commands\n",
! 1102: sc->sc_dev.dv_xname, sc_link->openings);
! 1103: }
! 1104:
! 1105: /*
! 1106: * Now, if we've come here with no error code, i.e. we've kept the
! 1107: * initial XS_NOERROR, and the status code signals that we should
! 1108: * check sense, we'll need to set up a request sense cmd block and
! 1109: * push the command back into the ready queue *before* any other
! 1110: * commands for this target/lunit, else we lose the sense info.
! 1111: * We don't support chk sense conditions for the request sense cmd.
! 1112: */
! 1113: if (xs->error == XS_NOERROR) {
! 1114: xs->status = ecb->stat;
! 1115: if ((ecb->flags & ECB_ABORT) != 0) {
! 1116: xs->error = XS_TIMEOUT;
! 1117: } else if ((ecb->flags & ECB_SENSE) != 0) {
! 1118: xs->error = XS_SENSE;
! 1119: } else if ((ecb->stat & ST_MASK) == SCSI_CHECK) {
! 1120: /* First, save the return values */
! 1121: xs->resid = ecb->dleft;
! 1122: ncr53c9x_sense(sc, ecb);
! 1123: return;
! 1124: } else {
! 1125: xs->resid = ecb->dleft;
! 1126: }
! 1127: }
! 1128:
! 1129: xs->flags |= ITSDONE;
! 1130:
! 1131: #ifdef NCR53C9X_DEBUG
! 1132: if (ncr53c9x_debug & NCR_SHOWMISC) {
! 1133: if (xs->resid != 0)
! 1134: printf("resid=%lu ", (unsigned long)xs->resid);
! 1135: if (xs->error == XS_SENSE)
! 1136: printf("sense=0x%02x\n", xs->sense.error_code);
! 1137: else
! 1138: printf("error=%d\n", xs->error);
! 1139: }
! 1140: #endif
! 1141:
! 1142: /*
! 1143: * Remove the ECB from whatever queue it's on.
! 1144: */
! 1145: ncr53c9x_dequeue(sc, ecb);
! 1146: if (ecb == sc->sc_nexus) {
! 1147: sc->sc_nexus = NULL;
! 1148: if (sc->sc_state != NCR_CLEANING) {
! 1149: sc->sc_state = NCR_IDLE;
! 1150: ncr53c9x_sched(sc);
! 1151: }
! 1152: }
! 1153:
! 1154: if (xs->error == XS_SELTIMEOUT) {
! 1155: /* Selection timeout -- discard this LUN if empty */
! 1156: if (!li->untagged && !li->used) {
! 1157: if (lun < NCR_NLUN)
! 1158: ti->lun[lun] = NULL;
! 1159: LIST_REMOVE(li, link);
! 1160: free(li, M_DEVBUF);
! 1161: }
! 1162: }
! 1163:
! 1164: ncr53c9x_free_ecb(sc, ecb, xs->flags);
! 1165: ti->cmds++;
! 1166: scsi_done(xs);
! 1167: }
! 1168:
! 1169: void
! 1170: ncr53c9x_dequeue(sc, ecb)
! 1171: struct ncr53c9x_softc *sc;
! 1172: struct ncr53c9x_ecb *ecb;
! 1173: {
! 1174: struct ncr53c9x_tinfo *ti =
! 1175: &sc->sc_tinfo[ecb->xs->sc_link->target];
! 1176: struct ncr53c9x_linfo *li;
! 1177: int64_t lun = ecb->xs->sc_link->lun;
! 1178:
! 1179: li = TINFO_LUN(ti, lun);
! 1180: #ifdef DIAGNOSTIC
! 1181: if ((!li) || (li->lun != lun))
! 1182: panic("ncr53c9x_dequeue: lun %qx for ecb %p does not exist",
! 1183: (long long)lun, ecb);
! 1184: #endif
! 1185: if (li->untagged == ecb) {
! 1186: li->busy = 0;
! 1187: li->untagged = NULL;
! 1188: }
! 1189: if (ecb->tag[0] && li->queued[ecb->tag[1]]) {
! 1190: #ifdef DIAGNOSTIC
! 1191: if (li->queued[ecb->tag[1]] && (li->queued[ecb->tag[1]] != ecb))
! 1192: panic("ncr53c9x_dequeue: slot %d for lun %qx has %p "
! 1193: "instead of ecb %p", ecb->tag[1],
! 1194: (long long)lun,
! 1195: li->queued[ecb->tag[1]], ecb);
! 1196: #endif
! 1197: li->queued[ecb->tag[1]] = NULL;
! 1198: li->used --;
! 1199:
! 1200: }
! 1201: if (ecb->flags & ECB_READY) {
! 1202: ecb->flags &= ~ECB_READY;
! 1203: TAILQ_REMOVE(&sc->ready_list, ecb, chain);
! 1204: }
! 1205: }
! 1206:
! 1207: /*
! 1208: * INTERRUPT/PROTOCOL ENGINE
! 1209: */
! 1210:
! 1211: /*
! 1212: * Schedule an outgoing message by prioritizing it, and asserting
! 1213: * attention on the bus. We can only do this when we are the initiator
! 1214: * else there will be an illegal command interrupt.
! 1215: */
! 1216: #define ncr53c9x_sched_msgout(m) \
! 1217: do { \
! 1218: NCR_MISC(("ncr53c9x_sched_msgout %x %d ", m, __LINE__)); \
! 1219: NCRCMD(sc, NCRCMD_SETATN); \
! 1220: sc->sc_flags |= NCR_ATN; \
! 1221: sc->sc_msgpriq |= (m); \
! 1222: } while (0)
! 1223:
! 1224: static void
! 1225: ncr53c9x_flushfifo(struct ncr53c9x_softc *sc)
! 1226: {
! 1227: NCR_MISC(("[flushfifo] "));
! 1228:
! 1229: NCRCMD(sc, NCRCMD_FLUSH);
! 1230:
! 1231: if (sc->sc_phase == COMMAND_PHASE ||
! 1232: sc->sc_phase == MESSAGE_OUT_PHASE)
! 1233: DELAY(2);
! 1234: }
! 1235:
! 1236: static int
! 1237: ncr53c9x_rdfifo(struct ncr53c9x_softc *sc, int how)
! 1238: {
! 1239: int i, n;
! 1240: u_char *buf;
! 1241:
! 1242: switch(how) {
! 1243: case NCR_RDFIFO_START:
! 1244: buf = sc->sc_imess;
! 1245: sc->sc_imlen = 0;
! 1246: break;
! 1247: case NCR_RDFIFO_CONTINUE:
! 1248: buf = sc->sc_imess + sc->sc_imlen;
! 1249: break;
! 1250: default:
! 1251: panic("ncr53c9x_rdfifo: bad flag");
! 1252: break;
! 1253: }
! 1254:
! 1255: /*
! 1256: * XXX buffer (sc_imess) size for message
! 1257: */
! 1258:
! 1259: n = NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF;
! 1260:
! 1261: if (sc->sc_rev == NCR_VARIANT_FAS366) {
! 1262: n *= 2;
! 1263:
! 1264: for (i = 0; i < n; i++)
! 1265: buf[i] = NCR_READ_REG(sc, NCR_FIFO);
! 1266:
! 1267: if (sc->sc_espstat2 & FAS_STAT2_ISHUTTLE) {
! 1268:
! 1269: NCR_WRITE_REG(sc, NCR_FIFO, 0);
! 1270: buf[i++] = NCR_READ_REG(sc, NCR_FIFO);
! 1271:
! 1272: NCR_READ_REG(sc, NCR_FIFO);
! 1273:
! 1274: ncr53c9x_flushfifo(sc);
! 1275: }
! 1276: } else {
! 1277: for (i = 0; i < n; i++)
! 1278: buf[i] = NCR_READ_REG(sc, NCR_FIFO);
! 1279: }
! 1280:
! 1281: sc->sc_imlen += i;
! 1282:
! 1283: #ifdef NCR53C9X_DEBUG
! 1284: {
! 1285: int j;
! 1286:
! 1287: NCR_TRACE(("\n[rdfifo %s (%d):",
! 1288: (how == NCR_RDFIFO_START) ? "start" : "cont",
! 1289: (int)sc->sc_imlen));
! 1290: if (ncr53c9x_debug & NCR_SHOWTRAC) {
! 1291: for (j = 0; j < sc->sc_imlen; j++)
! 1292: printf(" %02x", sc->sc_imess[j]);
! 1293: printf("]\n");
! 1294: }
! 1295: }
! 1296: #endif
! 1297: return sc->sc_imlen;
! 1298: }
! 1299:
! 1300: static void
! 1301: ncr53c9x_wrfifo(struct ncr53c9x_softc *sc, u_char *p, int len)
! 1302: {
! 1303: int i;
! 1304:
! 1305: #ifdef NCR53C9X_DEBUG
! 1306: NCR_MISC(("[wrfifo(%d):", len));
! 1307: if (ncr53c9x_debug & NCR_SHOWTRAC) {
! 1308: for (i = 0; i < len; i++)
! 1309: printf(" %02x", p[i]);
! 1310: printf("]\n");
! 1311: }
! 1312: #endif
! 1313:
! 1314: for (i = 0; i < len; i++) {
! 1315: NCR_WRITE_REG(sc, NCR_FIFO, p[i]);
! 1316:
! 1317: if (sc->sc_rev == NCR_VARIANT_FAS366)
! 1318: NCR_WRITE_REG(sc, NCR_FIFO, 0);
! 1319: }
! 1320: }
! 1321:
! 1322: int
! 1323: ncr53c9x_reselect(sc, message, tagtype, tagid)
! 1324: struct ncr53c9x_softc *sc;
! 1325: int message;
! 1326: int tagtype;
! 1327: int tagid;
! 1328: {
! 1329: u_char selid, target, lun;
! 1330: struct ncr53c9x_ecb *ecb = NULL;
! 1331: struct ncr53c9x_tinfo *ti;
! 1332: struct ncr53c9x_linfo *li;
! 1333:
! 1334: if (sc->sc_rev == NCR_VARIANT_FAS366) {
! 1335: target = sc->sc_selid;
! 1336: } else {
! 1337: /*
! 1338: * The SCSI chip made a snapshot of the data bus while the reselection
! 1339: * was being negotiated. This enables us to determine which target did
! 1340: * the reselect.
! 1341: */
! 1342: selid = sc->sc_selid & ~(1 << sc->sc_id);
! 1343: if (selid & (selid - 1)) {
! 1344: printf("%s: reselect with invalid selid %02x;"
! 1345: " sending DEVICE RESET\n", sc->sc_dev.dv_xname, selid);
! 1346: goto reset;
! 1347:
! 1348: }
! 1349: target = ffs(selid) - 1;
! 1350: }
! 1351: lun = message & 0x07;
! 1352:
! 1353: /*
! 1354: * Search wait queue for disconnected cmd
! 1355: * The list should be short, so I haven't bothered with
! 1356: * any more sophisticated structures than a simple
! 1357: * singly linked list.
! 1358: */
! 1359: ti = &sc->sc_tinfo[target];
! 1360: li = TINFO_LUN(ti, lun);
! 1361:
! 1362: /*
! 1363: * We can get as far as the LUN with the IDENTIFY
! 1364: * message. Check to see if we're running an
! 1365: * un-tagged command. Otherwise ack the IDENTIFY
! 1366: * and wait for a tag message.
! 1367: */
! 1368: if (li != NULL) {
! 1369: if (li->untagged != NULL && li->busy)
! 1370: ecb = li->untagged;
! 1371: else if (tagtype != MSG_SIMPLE_Q_TAG) {
! 1372: /* Wait for tag to come by */
! 1373: sc->sc_state = NCR_IDENTIFIED;
! 1374: return (0);
! 1375: } else if (tagtype) ecb = li->queued[tagid];
! 1376: }
! 1377: if (ecb == NULL) {
! 1378: printf("%s: reselect from target %d lun %d tag %x:%x with no nexus;"
! 1379: " sending ABORT\n", sc->sc_dev.dv_xname, target, lun, tagtype, tagid);
! 1380: goto abort;
! 1381: }
! 1382:
! 1383: /* Make this nexus active again. */
! 1384: sc->sc_state = NCR_CONNECTED;
! 1385: sc->sc_nexus = ecb;
! 1386: ncr53c9x_setsync(sc, ti);
! 1387:
! 1388: if (ecb->flags & ECB_RESET)
! 1389: ncr53c9x_sched_msgout(SEND_DEV_RESET);
! 1390: else if (ecb->flags & ECB_ABORT)
! 1391: ncr53c9x_sched_msgout(SEND_ABORT);
! 1392:
! 1393: /* Do an implicit RESTORE POINTERS. */
! 1394: sc->sc_dp = ecb->daddr;
! 1395: sc->sc_dleft = ecb->dleft;
! 1396:
! 1397: return (0);
! 1398:
! 1399: reset:
! 1400: ncr53c9x_sched_msgout(SEND_DEV_RESET);
! 1401: return (1);
! 1402:
! 1403: abort:
! 1404: ncr53c9x_sched_msgout(SEND_ABORT);
! 1405: return (1);
! 1406: }
! 1407:
! 1408: #define IS1BYTEMSG(m) (((m) != 1 && (m) < 0x20) || (m) & 0x80)
! 1409: #define IS2BYTEMSG(m) (((m) & 0xf0) == 0x20)
! 1410: #define ISEXTMSG(m) ((m) == 1)
! 1411:
! 1412: static inline int
! 1413: __verify_msg_format(u_char *p, int len)
! 1414: {
! 1415:
! 1416: if (len == 1 && IS1BYTEMSG(p[0]))
! 1417: return 1;
! 1418: if (len == 2 && IS2BYTEMSG(p[0]))
! 1419: return 1;
! 1420: if (len >= 3 && ISEXTMSG(p[0]) &&
! 1421: len == p[1] + 2)
! 1422: return 1;
! 1423:
! 1424: return 0;
! 1425: }
! 1426:
! 1427: /*
! 1428: * Get an incoming message as initiator.
! 1429: *
! 1430: * The SCSI bus must already be in MESSAGE_IN_PHASE and there is a
! 1431: * byte in the FIFO
! 1432: */
! 1433: void
! 1434: ncr53c9x_msgin(sc)
! 1435: struct ncr53c9x_softc *sc;
! 1436: {
! 1437:
! 1438: NCR_TRACE(("[ncr53c9x_msgin(curmsglen:%ld)] ", (long)sc->sc_imlen));
! 1439:
! 1440: if (sc->sc_imlen == 0) {
! 1441: printf("%s: msgin: no msg byte available\n", sc->sc_dev.dv_xname);
! 1442: return;
! 1443: }
! 1444:
! 1445: /*
! 1446: * Prepare for a new message. A message should (according
! 1447: * to the SCSI standard) be transmitted in one single
! 1448: * MESSAGE_IN_PHASE. If we have been in some other phase,
! 1449: * then this is a new message.
! 1450: */
! 1451: if (sc->sc_prevphase != MESSAGE_IN_PHASE && sc->sc_state != NCR_RESELECTED) {
! 1452: printf("%s: phase change, dropping message, prev %d, state %d\n",
! 1453: sc->sc_dev.dv_xname, sc->sc_prevphase, sc->sc_state);
! 1454: sc->sc_flags &= ~NCR_DROP_MSGI;
! 1455: sc->sc_imlen = 0;
! 1456: }
! 1457:
! 1458: NCR_TRACE(("<msgbyte:0x%02x>", sc->sc_imess[0]));
! 1459:
! 1460: /*
! 1461: * If we're going to reject the message, don't bother storing
! 1462: * the incoming bytes. But still, we need to ACK them.
! 1463: */
! 1464: if ((sc->sc_flags & NCR_DROP_MSGI)) {
! 1465: NCRCMD(sc, NCRCMD_MSGOK);
! 1466: printf("<dropping msg byte %x>",
! 1467: sc->sc_imess[sc->sc_imlen]);
! 1468: return;
! 1469: }
! 1470:
! 1471: if (sc->sc_imlen >= NCR_MAX_MSG_LEN) {
! 1472: ncr53c9x_sched_msgout(SEND_REJECT);
! 1473: sc->sc_flags |= NCR_DROP_MSGI;
! 1474: } else {
! 1475: u_char *pb;
! 1476: int plen;
! 1477:
! 1478: switch (sc->sc_state) {
! 1479: /*
! 1480: * if received message is the first of reselection
! 1481: * then first byte is selid, and then message
! 1482: */
! 1483: case NCR_RESELECTED:
! 1484: pb = sc->sc_imess + 1;
! 1485: plen = sc->sc_imlen - 1;
! 1486: break;
! 1487: default:
! 1488: pb = sc->sc_imess;
! 1489: plen = sc->sc_imlen;
! 1490: break;
! 1491: }
! 1492:
! 1493: if (__verify_msg_format(pb, plen))
! 1494: goto gotit;
! 1495: }
! 1496:
! 1497: /* Ack what we have so far */
! 1498: NCRCMD(sc, NCRCMD_MSGOK);
! 1499: return;
! 1500:
! 1501: gotit:
! 1502: NCR_MSGS(("gotmsg(%x) state %d", sc->sc_imess[0], sc->sc_state));
! 1503: /* we got complete message, flush the imess, XXX nobody uses imlen below */
! 1504: sc->sc_imlen = 0;
! 1505:
! 1506: /*
! 1507: * Now we should have a complete message (1 byte, 2 byte
! 1508: * and moderately long extended messages). We only handle
! 1509: * extended messages which total length is shorter than
! 1510: * NCR_MAX_MSG_LEN. Longer messages will be amputated.
! 1511: */
! 1512: switch (sc->sc_state) {
! 1513: struct ncr53c9x_ecb *ecb;
! 1514: struct ncr53c9x_tinfo *ti;
! 1515: struct ncr53c9x_linfo *li;
! 1516: int lun;
! 1517:
! 1518: case NCR_CONNECTED:
! 1519: ecb = sc->sc_nexus;
! 1520: ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
! 1521:
! 1522: switch (sc->sc_imess[0]) {
! 1523: case MSG_CMDCOMPLETE:
! 1524: NCR_MSGS(("cmdcomplete "));
! 1525: if (sc->sc_dleft < 0) {
! 1526: sc_print_addr(ecb->xs->sc_link);
! 1527: printf("got %ld extra bytes\n",
! 1528: -(long)sc->sc_dleft);
! 1529: sc->sc_dleft = 0;
! 1530: }
! 1531: ecb->dleft = (ecb->flags & ECB_TENTATIVE_DONE)
! 1532: ? 0
! 1533: : sc->sc_dleft;
! 1534: if ((ecb->flags & ECB_SENSE) == 0)
! 1535: ecb->xs->resid = ecb->dleft;
! 1536: sc->sc_state = NCR_CMDCOMPLETE;
! 1537: break;
! 1538:
! 1539: case MSG_MESSAGE_REJECT:
! 1540: NCR_MSGS(("msg reject (msgout=%x) ", sc->sc_msgout));
! 1541: switch (sc->sc_msgout) {
! 1542: case SEND_TAG:
! 1543: /* Target does not like tagged queuing.
! 1544: * - Flush the command queue
! 1545: * - Disable tagged queuing for the target
! 1546: * - Dequeue ecb from the queued array.
! 1547: */
! 1548: printf("%s: tagged queuing rejected: target %d\n",
! 1549: sc->sc_dev.dv_xname, ecb->xs->sc_link->target);
! 1550:
! 1551: NCR_MSGS(("(rejected sent tag)"));
! 1552: NCRCMD(sc, NCRCMD_FLUSH);
! 1553: DELAY(1);
! 1554: ti->flags &= ~T_TAG;
! 1555: lun = ecb->xs->sc_link->lun;
! 1556: li = TINFO_LUN(ti, lun);
! 1557: if (ecb->tag[0] &&
! 1558: li->queued[ecb->tag[1]] != NULL) {
! 1559: li->queued[ecb->tag[1]] = NULL;
! 1560: li->used--;
! 1561: }
! 1562: ecb->tag[0] = ecb->tag[1] = 0;
! 1563: li->untagged = ecb;
! 1564: li->busy = 1;
! 1565: break;
! 1566:
! 1567: case SEND_SDTR:
! 1568: printf("%s: sync transfer rejected: target %d\n",
! 1569: sc->sc_dev.dv_xname, ecb->xs->sc_link->target);
! 1570: sc->sc_flags &= ~NCR_SYNCHNEGO;
! 1571: ti->flags &= ~(T_NEGOTIATE | T_SYNCMODE);
! 1572: ncr53c9x_setsync(sc, ti);
! 1573: break;
! 1574:
! 1575: case SEND_WDTR:
! 1576: printf("%s: wide transfer rejected: target %d\n",
! 1577: sc->sc_dev.dv_xname, ecb->xs->sc_link->target);
! 1578: ti->flags &= ~T_WIDE;
! 1579: ti->width = 0;
! 1580: break;
! 1581:
! 1582: case SEND_INIT_DET_ERR:
! 1583: goto abort;
! 1584: }
! 1585: break;
! 1586:
! 1587: case MSG_NOOP:
! 1588: NCR_MSGS(("noop "));
! 1589: break;
! 1590:
! 1591: case MSG_HEAD_OF_Q_TAG:
! 1592: case MSG_SIMPLE_Q_TAG:
! 1593: case MSG_ORDERED_Q_TAG:
! 1594: NCR_MSGS(("TAG %x:%x", sc->sc_imess[0], sc->sc_imess[1]));
! 1595: break;
! 1596:
! 1597: case MSG_DISCONNECT:
! 1598: NCR_MSGS(("disconnect "));
! 1599: ti->dconns++;
! 1600: sc->sc_state = NCR_DISCONNECT;
! 1601:
! 1602: /*
! 1603: * Mark the fact that all bytes have moved. The
! 1604: * target may not bother to do a SAVE POINTERS
! 1605: * at this stage. This flag will set the residual
! 1606: * count to zero on MSG COMPLETE.
! 1607: */
! 1608: if (sc->sc_dleft == 0)
! 1609: ecb->flags |= ECB_TENTATIVE_DONE;
! 1610:
! 1611: break;
! 1612:
! 1613: case MSG_SAVEDATAPOINTER:
! 1614: NCR_MSGS(("save datapointer "));
! 1615: ecb->daddr = sc->sc_dp;
! 1616: ecb->dleft = sc->sc_dleft;
! 1617: break;
! 1618:
! 1619: case MSG_RESTOREPOINTERS:
! 1620: NCR_MSGS(("restore datapointer "));
! 1621: sc->sc_dp = ecb->daddr;
! 1622: sc->sc_dleft = ecb->dleft;
! 1623: break;
! 1624:
! 1625: case MSG_EXTENDED:
! 1626: NCR_MSGS(("extended(%x) ", sc->sc_imess[2]));
! 1627: switch (sc->sc_imess[2]) {
! 1628: case MSG_EXT_SDTR:
! 1629: NCR_MSGS(("SDTR period %d, offset %d ",
! 1630: sc->sc_imess[3], sc->sc_imess[4]));
! 1631: if (sc->sc_imess[1] != 3)
! 1632: goto reject;
! 1633: ti->period = sc->sc_imess[3];
! 1634: ti->offset = sc->sc_imess[4];
! 1635: ti->flags &= ~T_NEGOTIATE;
! 1636: if (sc->sc_minsync == 0 ||
! 1637: ti->offset == 0 ||
! 1638: ti->period > 124) {
! 1639: #ifdef NCR53C9X_DEBUG
! 1640: sc_print_addr(ecb->xs->sc_link);
! 1641: printf("async mode\n");
! 1642: #endif
! 1643: if ((sc->sc_flags&NCR_SYNCHNEGO)
! 1644: == 0) {
! 1645: /*
! 1646: * target initiated negotiation
! 1647: */
! 1648: ti->offset = 0;
! 1649: ti->flags &= ~T_SYNCMODE;
! 1650: ncr53c9x_sched_msgout(
! 1651: SEND_SDTR);
! 1652: } else {
! 1653: /* we are async */
! 1654: ti->flags &= ~T_SYNCMODE;
! 1655: }
! 1656: } else {
! 1657: #ifdef NCR53C9X_DEBUG
! 1658: int r, s;
! 1659: #endif
! 1660: int p;
! 1661:
! 1662: p = ncr53c9x_stp2cpb(sc, ti->period);
! 1663: ti->period = ncr53c9x_cpb2stp(sc, p);
! 1664: #ifdef NCR53C9X_DEBUG
! 1665: sc_print_addr(ecb->xs->sc_link);
! 1666: r = 250/ti->period;
! 1667: s = (100*250)/ti->period - 100*r;
! 1668: printf("max sync rate %d.%02dMB/s\n",
! 1669: r, s);
! 1670: #endif
! 1671: if ((sc->sc_flags&NCR_SYNCHNEGO) == 0) {
! 1672: /*
! 1673: * target initiated negotiation
! 1674: */
! 1675: if (ti->period <
! 1676: sc->sc_minsync)
! 1677: ti->period =
! 1678: sc->sc_minsync;
! 1679: if (ti->offset > 15)
! 1680: ti->offset = 15;
! 1681: ti->flags &= ~T_SYNCMODE;
! 1682: ncr53c9x_sched_msgout(
! 1683: SEND_SDTR);
! 1684: } else {
! 1685: /* we are sync */
! 1686: ti->flags |= T_SYNCMODE;
! 1687: }
! 1688: }
! 1689: sc->sc_flags &= ~NCR_SYNCHNEGO;
! 1690: ncr53c9x_setsync(sc, ti);
! 1691: break;
! 1692:
! 1693: case MSG_EXT_WDTR:
! 1694: printf("%s: wide mode %d\n",
! 1695: sc->sc_dev.dv_xname, sc->sc_imess[3]);
! 1696: if (sc->sc_imess[3] == 1) {
! 1697: ti->cfg3 |= NCRFASCFG3_EWIDE;
! 1698: ncr53c9x_setsync(sc, ti);
! 1699: } else
! 1700: ti->width = 0;
! 1701: ti->flags &= ~T_WIDE;
! 1702: break;
! 1703: default:
! 1704: sc_print_addr(ecb->xs->sc_link);
! 1705: printf("unrecognized MESSAGE EXTENDED;"
! 1706: " sending REJECT\n");
! 1707: goto reject;
! 1708: }
! 1709: break;
! 1710:
! 1711: default:
! 1712: NCR_MSGS(("ident "));
! 1713: sc_print_addr(ecb->xs->sc_link);
! 1714: printf("unrecognized MESSAGE; sending REJECT\n");
! 1715: reject:
! 1716: ncr53c9x_sched_msgout(SEND_REJECT);
! 1717: break;
! 1718: }
! 1719: break;
! 1720:
! 1721: case NCR_IDENTIFIED:
! 1722: /*
! 1723: * IDENTIFY message was received and queue tag is expected now
! 1724: */
! 1725: if ((sc->sc_imess[0] != MSG_SIMPLE_Q_TAG) ||
! 1726: (sc->sc_msgify == 0)) {
! 1727: printf("%s: TAG reselect without IDENTIFY;"
! 1728: " MSG %x;"
! 1729: " sending DEVICE RESET\n",
! 1730: sc->sc_dev.dv_xname,
! 1731: sc->sc_imess[0]);
! 1732: goto reset;
! 1733: }
! 1734: (void) ncr53c9x_reselect(sc, sc->sc_msgify,
! 1735: sc->sc_imess[0], sc->sc_imess[1]);
! 1736: break;
! 1737:
! 1738: case NCR_RESELECTED:
! 1739: if (MSG_ISIDENTIFY(sc->sc_imess[1])) {
! 1740: sc->sc_msgify = sc->sc_imess[1];
! 1741: } else {
! 1742: printf("%s: reselect without IDENTIFY;"
! 1743: " MSG %x;"
! 1744: " sending DEVICE RESET\n",
! 1745: sc->sc_dev.dv_xname,
! 1746: sc->sc_imess[1]);
! 1747: goto reset;
! 1748: }
! 1749: (void) ncr53c9x_reselect(sc, sc->sc_msgify, 0, 0);
! 1750: break;
! 1751:
! 1752: default:
! 1753: printf("%s: unexpected MESSAGE IN; sending DEVICE RESET\n",
! 1754: sc->sc_dev.dv_xname);
! 1755: reset:
! 1756: ncr53c9x_sched_msgout(SEND_DEV_RESET);
! 1757: break;
! 1758:
! 1759: abort:
! 1760: ncr53c9x_sched_msgout(SEND_ABORT);
! 1761: break;
! 1762: }
! 1763:
! 1764: /* if we have more messages to send set ATN */
! 1765: if (sc->sc_msgpriq)
! 1766: NCRCMD(sc, NCRCMD_SETATN);
! 1767:
! 1768: /* Ack last message byte */
! 1769: NCRCMD(sc, NCRCMD_MSGOK);
! 1770:
! 1771: /* Done, reset message pointer. */
! 1772: sc->sc_flags &= ~NCR_DROP_MSGI;
! 1773: sc->sc_imlen = 0;
! 1774: }
! 1775:
! 1776:
! 1777: /*
! 1778: * Send the highest priority, scheduled message
! 1779: */
! 1780: void
! 1781: ncr53c9x_msgout(sc)
! 1782: struct ncr53c9x_softc *sc;
! 1783: {
! 1784: struct ncr53c9x_tinfo *ti;
! 1785: struct ncr53c9x_ecb *ecb;
! 1786: size_t size;
! 1787:
! 1788: NCR_TRACE(("[ncr53c9x_msgout(priq:%x, prevphase:%x)]",
! 1789: sc->sc_msgpriq, sc->sc_prevphase));
! 1790:
! 1791: /*
! 1792: * XXX - the NCR_ATN flag is not in sync with the actual ATN
! 1793: * condition on the SCSI bus. The 53c9x chip
! 1794: * automatically turns off ATN before sending the
! 1795: * message byte. (see also the comment below in the
! 1796: * default case when picking out a message to send)
! 1797: */
! 1798: if (sc->sc_flags & NCR_ATN) {
! 1799: if (sc->sc_prevphase != MESSAGE_OUT_PHASE) {
! 1800: new:
! 1801: NCRCMD(sc, NCRCMD_FLUSH);
! 1802: /* DELAY(1); */
! 1803: sc->sc_msgoutq = 0;
! 1804: sc->sc_omlen = 0;
! 1805: }
! 1806: } else {
! 1807: if (sc->sc_prevphase == MESSAGE_OUT_PHASE) {
! 1808: ncr53c9x_sched_msgout(sc->sc_msgoutq);
! 1809: goto new;
! 1810: } else {
! 1811: printf("%s at line %d: unexpected MESSAGE OUT phase\n",
! 1812: sc->sc_dev.dv_xname, __LINE__);
! 1813: }
! 1814: }
! 1815:
! 1816: if (sc->sc_omlen == 0) {
! 1817: /* Pick up highest priority message */
! 1818: sc->sc_msgout = sc->sc_msgpriq & -sc->sc_msgpriq;
! 1819: sc->sc_msgoutq |= sc->sc_msgout;
! 1820: sc->sc_msgpriq &= ~sc->sc_msgout;
! 1821: sc->sc_omlen = 1; /* "Default" message len */
! 1822: switch (sc->sc_msgout) {
! 1823: case SEND_SDTR:
! 1824: ecb = sc->sc_nexus;
! 1825: ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
! 1826: sc->sc_omess[0] = MSG_EXTENDED;
! 1827: sc->sc_omess[1] = 3;
! 1828: sc->sc_omess[2] = MSG_EXT_SDTR;
! 1829: sc->sc_omess[3] = ti->period;
! 1830: sc->sc_omess[4] = ti->offset;
! 1831: sc->sc_omlen = 5;
! 1832: if ((sc->sc_flags & NCR_SYNCHNEGO) == 0) {
! 1833: ti->flags |= T_SYNCMODE;
! 1834: ncr53c9x_setsync(sc, ti);
! 1835: }
! 1836: break;
! 1837: case SEND_WDTR:
! 1838: ecb = sc->sc_nexus;
! 1839: ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
! 1840: sc->sc_omess[0] = MSG_EXTENDED;
! 1841: sc->sc_omess[1] = 2;
! 1842: sc->sc_omess[2] = MSG_EXT_WDTR;
! 1843: sc->sc_omess[3] = ti->width;
! 1844: sc->sc_omlen = 4;
! 1845: break;
! 1846: case SEND_IDENTIFY:
! 1847: if (sc->sc_state != NCR_CONNECTED) {
! 1848: printf("%s at line %d: no nexus\n",
! 1849: sc->sc_dev.dv_xname, __LINE__);
! 1850: }
! 1851: ecb = sc->sc_nexus;
! 1852: sc->sc_omess[0] =
! 1853: MSG_IDENTIFY(ecb->xs->sc_link->lun, 0);
! 1854: break;
! 1855: case SEND_TAG:
! 1856: if (sc->sc_state != NCR_CONNECTED) {
! 1857: printf("%s at line %d: no nexus\n",
! 1858: sc->sc_dev.dv_xname, __LINE__);
! 1859: }
! 1860: ecb = sc->sc_nexus;
! 1861: sc->sc_omess[0] = ecb->tag[0];
! 1862: sc->sc_omess[1] = ecb->tag[1];
! 1863: sc->sc_omlen = 2;
! 1864: break;
! 1865: case SEND_DEV_RESET:
! 1866: sc->sc_flags |= NCR_ABORTING;
! 1867: sc->sc_omess[0] = MSG_BUS_DEV_RESET;
! 1868: ecb = sc->sc_nexus;
! 1869: ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
! 1870: ti->flags &= ~T_SYNCMODE;
! 1871: if ((ti->flags & T_SYNCHOFF) == 0)
! 1872: /* We can re-start sync negotiation */
! 1873: ti->flags |= T_NEGOTIATE;
! 1874: break;
! 1875: case SEND_PARITY_ERROR:
! 1876: sc->sc_omess[0] = MSG_PARITY_ERROR;
! 1877: break;
! 1878: case SEND_ABORT:
! 1879: sc->sc_flags |= NCR_ABORTING;
! 1880: sc->sc_omess[0] = MSG_ABORT;
! 1881: break;
! 1882: case SEND_INIT_DET_ERR:
! 1883: sc->sc_omess[0] = MSG_INITIATOR_DET_ERR;
! 1884: break;
! 1885: case SEND_REJECT:
! 1886: sc->sc_omess[0] = MSG_MESSAGE_REJECT;
! 1887: break;
! 1888: default:
! 1889: /*
! 1890: * We normally do not get here, since the chip
! 1891: * automatically turns off ATN before the last
! 1892: * byte of a message is sent to the target.
! 1893: * However, if the target rejects our (multi-byte)
! 1894: * message early by switching to MSG IN phase
! 1895: * ATN remains on, so the target may return to
! 1896: * MSG OUT phase. If there are no scheduled messages
! 1897: * left we send a NO-OP.
! 1898: *
! 1899: * XXX - Note that this leaves no useful purpose for
! 1900: * the NCR_ATN flag.
! 1901: */
! 1902: sc->sc_flags &= ~NCR_ATN;
! 1903: sc->sc_omess[0] = MSG_NOOP;
! 1904: break;
! 1905: }
! 1906: sc->sc_omp = sc->sc_omess;
! 1907: }
! 1908:
! 1909: #ifdef DEBUG
! 1910: {
! 1911: int i;
! 1912:
! 1913: for (i = 0; i<sc->sc_omlen; i++)
! 1914: NCR_MISC(("<msgbyte:0x%02x>", sc->sc_omess[i]));
! 1915: }
! 1916: #endif
! 1917: if (sc->sc_rev == NCR_VARIANT_FAS366) {
! 1918: /*
! 1919: * XXX fifo size
! 1920: */
! 1921: ncr53c9x_flushfifo(sc);
! 1922: ncr53c9x_wrfifo(sc, sc->sc_omp, sc->sc_omlen);
! 1923: NCRCMD(sc, NCRCMD_TRANS);
! 1924: } else {
! 1925: /* (re)send the message */
! 1926: size = min(sc->sc_omlen, sc->sc_maxxfer);
! 1927: NCRDMA_SETUP(sc, &sc->sc_omp, &sc->sc_omlen, 0, &size);
! 1928: /* Program the SCSI counter */
! 1929: NCR_SET_COUNT(sc, size);
! 1930:
! 1931: /* Load the count in and start the message-out transfer */
! 1932: NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
! 1933: NCRCMD(sc, NCRCMD_TRANS|NCRCMD_DMA);
! 1934: NCRDMA_GO(sc);
! 1935: }
! 1936: }
! 1937:
! 1938: /*
! 1939: * This is the most critical part of the driver, and has to know
! 1940: * how to deal with *all* error conditions and phases from the SCSI
! 1941: * bus. If there are no errors and the DMA was active, then call the
! 1942: * DMA pseudo-interrupt handler. If this returns 1, then that was it
! 1943: * and we can return from here without further processing.
! 1944: *
! 1945: * Most of this needs verifying.
! 1946: */
! 1947: int sdebug = 0;
! 1948: int
! 1949: ncr53c9x_intr(arg)
! 1950: void *arg;
! 1951: {
! 1952: struct ncr53c9x_softc *sc = arg;
! 1953: struct ncr53c9x_ecb *ecb;
! 1954: struct scsi_link *sc_link;
! 1955: struct ncr53c9x_tinfo *ti;
! 1956: size_t size;
! 1957: int nfifo;
! 1958:
! 1959: NCR_TRACE(("[ncr53c9x_intr: state %d] ", sc->sc_state));
! 1960:
! 1961: if (!NCRDMA_ISINTR(sc))
! 1962: return (0);
! 1963:
! 1964: again:
! 1965: /* and what do the registers say... */
! 1966: ncr53c9x_readregs(sc);
! 1967:
! 1968: /*
! 1969: * At the moment, only a SCSI Bus Reset or Illegal
! 1970: * Command are classed as errors. A disconnect is a
! 1971: * valid condition, and we let the code check is the
! 1972: * "NCR_BUSFREE_OK" flag was set before declaring it
! 1973: * and error.
! 1974: *
! 1975: * Also, the status register tells us about "Gross
! 1976: * Errors" and "Parity errors". Only the Gross Error
! 1977: * is really bad, and the parity errors are dealt
! 1978: * with later
! 1979: *
! 1980: * TODO
! 1981: * If there are too many parity error, go to slow
! 1982: * cable mode ?
! 1983: */
! 1984:
! 1985: /* SCSI Reset */
! 1986: if (sc->sc_espintr & NCRINTR_SBR) {
! 1987: if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
! 1988: NCRCMD(sc, NCRCMD_FLUSH);
! 1989: DELAY(1);
! 1990: }
! 1991: if (sc->sc_state != NCR_SBR) {
! 1992: printf("%s: SCSI bus reset\n",
! 1993: sc->sc_dev.dv_xname);
! 1994: ncr53c9x_init(sc, 0); /* Restart everything */
! 1995: return (1);
! 1996: }
! 1997: #if 0
! 1998: /*XXX*/ printf("<expected bus reset: "
! 1999: "[intr %x, stat %x, step %d]>\n",
! 2000: sc->sc_espintr, sc->sc_espstat,
! 2001: sc->sc_espstep);
! 2002: #endif
! 2003: if (sc->sc_nexus)
! 2004: panic("%s: nexus in reset state",
! 2005: sc->sc_dev.dv_xname);
! 2006: goto sched;
! 2007: }
! 2008:
! 2009: ecb = sc->sc_nexus;
! 2010:
! 2011: #define NCRINTR_ERR (NCRINTR_SBR|NCRINTR_ILL)
! 2012: if (sc->sc_espintr & NCRINTR_ERR ||
! 2013: sc->sc_espstat & NCRSTAT_GE) {
! 2014:
! 2015: if (sc->sc_espstat & NCRSTAT_GE) {
! 2016: /* Gross Error; no target ? */
! 2017: if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
! 2018: NCRCMD(sc, NCRCMD_FLUSH);
! 2019: DELAY(1);
! 2020: }
! 2021: if (sc->sc_state == NCR_CONNECTED ||
! 2022: sc->sc_state == NCR_SELECTING) {
! 2023: ecb->xs->error = XS_TIMEOUT;
! 2024: ncr53c9x_done(sc, ecb);
! 2025: }
! 2026: return (1);
! 2027: }
! 2028:
! 2029: if (sc->sc_espintr & NCRINTR_ILL) {
! 2030: if (sc->sc_flags & NCR_EXPECT_ILLCMD) {
! 2031: /*
! 2032: * Eat away "Illegal command" interrupt
! 2033: * on a ESP100 caused by a re-selection
! 2034: * while we were trying to select
! 2035: * another target.
! 2036: */
! 2037: #ifdef DEBUG
! 2038: printf("%s: ESP100 work-around activated\n",
! 2039: sc->sc_dev.dv_xname);
! 2040: #endif
! 2041: sc->sc_flags &= ~NCR_EXPECT_ILLCMD;
! 2042: return (1);
! 2043: }
! 2044: /* illegal command, out of sync ? */
! 2045: printf("%s: illegal command: 0x%x "
! 2046: "(state %d, phase %x, prevphase %x)\n",
! 2047: sc->sc_dev.dv_xname, sc->sc_lastcmd,
! 2048: sc->sc_state, sc->sc_phase,
! 2049: sc->sc_prevphase);
! 2050: if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
! 2051: NCRCMD(sc, NCRCMD_FLUSH);
! 2052: DELAY(1);
! 2053: }
! 2054: ncr53c9x_init(sc, 1); /* Restart everything */
! 2055: return (1);
! 2056: }
! 2057: }
! 2058: sc->sc_flags &= ~NCR_EXPECT_ILLCMD;
! 2059:
! 2060: /*
! 2061: * Call if DMA is active.
! 2062: *
! 2063: * If DMA_INTR returns true, then maybe go 'round the loop
! 2064: * again in case there is no more DMA queued, but a phase
! 2065: * change is expected.
! 2066: */
! 2067: if (NCRDMA_ISACTIVE(sc)) {
! 2068: int r = NCRDMA_INTR(sc);
! 2069: if (r == -1) {
! 2070: printf("%s: DMA error; resetting\n",
! 2071: sc->sc_dev.dv_xname);
! 2072: ncr53c9x_init(sc, 1);
! 2073: return (1);
! 2074: }
! 2075: /* If DMA active here, then go back to work... */
! 2076: if (NCRDMA_ISACTIVE(sc))
! 2077: return (1);
! 2078:
! 2079: if ((sc->sc_espstat & NCRSTAT_TC) == 0) {
! 2080: /*
! 2081: * DMA not completed. If we can not find a
! 2082: * acceptable explanation, print a diagnostic.
! 2083: */
! 2084: if (sc->sc_state == NCR_SELECTING)
! 2085: /*
! 2086: * This can happen if we are reselected
! 2087: * while using DMA to select a target.
! 2088: */
! 2089: /*void*/;
! 2090: else if (sc->sc_prevphase == MESSAGE_OUT_PHASE){
! 2091: /*
! 2092: * Our (multi-byte) message (eg SDTR)
! 2093: * was interrupted by the target to
! 2094: * send a MSG REJECT.
! 2095: * Print diagnostic if current phase
! 2096: * is not MESSAGE IN.
! 2097: */
! 2098: if (sc->sc_phase != MESSAGE_IN_PHASE)
! 2099: printf("%s: !TC on MSG OUT"
! 2100: " [intr %x, stat %x, step %d]"
! 2101: " prevphase %x, resid %lx\n",
! 2102: sc->sc_dev.dv_xname,
! 2103: sc->sc_espintr,
! 2104: sc->sc_espstat,
! 2105: sc->sc_espstep,
! 2106: sc->sc_prevphase,
! 2107: (u_long)sc->sc_omlen);
! 2108: } else if (sc->sc_dleft == 0) {
! 2109: /*
! 2110: * The DMA operation was started for
! 2111: * a DATA transfer. Print a diagnostic
! 2112: * if the DMA counter and TC bit
! 2113: * appear to be out of sync.
! 2114: */
! 2115: printf("%s: !TC on DATA XFER"
! 2116: " [intr %x, stat %x, step %d]"
! 2117: " prevphase %x, resid %x\n",
! 2118: sc->sc_dev.dv_xname,
! 2119: sc->sc_espintr,
! 2120: sc->sc_espstat,
! 2121: sc->sc_espstep,
! 2122: sc->sc_prevphase,
! 2123: ecb?ecb->dleft:-1);
! 2124: }
! 2125: }
! 2126: }
! 2127:
! 2128: /*
! 2129: * check for less serious errors
! 2130: */
! 2131: if (sc->sc_espstat & NCRSTAT_PE) {
! 2132: printf("%s: SCSI bus parity error\n", sc->sc_dev.dv_xname);
! 2133: if (sc->sc_prevphase == MESSAGE_IN_PHASE)
! 2134: ncr53c9x_sched_msgout(SEND_PARITY_ERROR);
! 2135: else
! 2136: ncr53c9x_sched_msgout(SEND_INIT_DET_ERR);
! 2137: }
! 2138:
! 2139: if (sc->sc_espintr & NCRINTR_DIS) {
! 2140: sc->sc_msgify = 0;
! 2141: NCR_MISC(("<DISC [intr %x, stat %x, step %d]>",
! 2142: sc->sc_espintr,sc->sc_espstat,sc->sc_espstep));
! 2143: if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
! 2144: NCRCMD(sc, NCRCMD_FLUSH);
! 2145: /* DELAY(1); */
! 2146: }
! 2147: /*
! 2148: * This command must (apparently) be issued within
! 2149: * 250mS of a disconnect. So here you are...
! 2150: */
! 2151: NCRCMD(sc, NCRCMD_ENSEL);
! 2152:
! 2153: switch (sc->sc_state) {
! 2154: case NCR_RESELECTED:
! 2155: goto sched;
! 2156:
! 2157: case NCR_SELECTING:
! 2158: {
! 2159: struct ncr53c9x_linfo *li;
! 2160:
! 2161: ecb->xs->error = XS_SELTIMEOUT;
! 2162:
! 2163: /* Selection timeout -- discard all LUNs if empty */
! 2164: sc_link = ecb->xs->sc_link;
! 2165: ti = &sc->sc_tinfo[sc_link->target];
! 2166: for (li = LIST_FIRST(&ti->luns);
! 2167: li != LIST_END(&ti->luns); ) {
! 2168: if (!li->untagged && !li->used) {
! 2169: if (li->lun < NCR_NLUN)
! 2170: ti->lun[li->lun] = NULL;
! 2171: LIST_REMOVE(li, link);
! 2172: free(li, M_DEVBUF);
! 2173: /* Restart the search at the beginning */
! 2174: li = LIST_FIRST(&ti->luns);
! 2175: continue;
! 2176: }
! 2177: li = LIST_NEXT(li, link);
! 2178: }
! 2179: goto finish;
! 2180: }
! 2181: case NCR_CONNECTED:
! 2182: if ((sc->sc_flags & NCR_SYNCHNEGO)) {
! 2183: #ifdef NCR53C9X_DEBUG
! 2184: if (ecb)
! 2185: sc_print_addr(ecb->xs->sc_link);
! 2186: printf("sync nego not completed!\n");
! 2187: #endif
! 2188: ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
! 2189: sc->sc_flags &= ~NCR_SYNCHNEGO;
! 2190: ti->flags &= ~(T_NEGOTIATE | T_SYNCMODE);
! 2191: }
! 2192:
! 2193: /* it may be OK to disconnect */
! 2194: if ((sc->sc_flags & NCR_ABORTING) == 0) {
! 2195: /*
! 2196: * Section 5.1.1 of the SCSI 2 spec
! 2197: * suggests issuing a REQUEST SENSE
! 2198: * following an unexpected disconnect.
! 2199: * Some devices go into a contingent
! 2200: * allegiance condition when
! 2201: * disconnecting, and this is necessary
! 2202: * to clean up their state.
! 2203: */
! 2204: printf("%s: unexpected disconnect; ",
! 2205: sc->sc_dev.dv_xname);
! 2206: if (ecb->flags & ECB_SENSE) {
! 2207: printf("resetting\n");
! 2208: goto reset;
! 2209: }
! 2210: printf("sending REQUEST SENSE\n");
! 2211: timeout_del(&ecb->to);
! 2212: ncr53c9x_sense(sc, ecb);
! 2213: goto out;
! 2214: }
! 2215:
! 2216: ecb->xs->error = XS_TIMEOUT;
! 2217: goto finish;
! 2218:
! 2219: case NCR_DISCONNECT:
! 2220: sc->sc_nexus = NULL;
! 2221: goto sched;
! 2222:
! 2223: case NCR_CMDCOMPLETE:
! 2224: goto finish;
! 2225: }
! 2226: }
! 2227:
! 2228: switch (sc->sc_state) {
! 2229:
! 2230: case NCR_SBR:
! 2231: printf("%s: waiting for SCSI Bus Reset to happen\n",
! 2232: sc->sc_dev.dv_xname);
! 2233: return (1);
! 2234:
! 2235: case NCR_RESELECTED:
! 2236: /*
! 2237: * we must be continuing a message ?
! 2238: */
! 2239: if (sc->sc_phase != MESSAGE_IN_PHASE) {
! 2240: printf("%s: target didn't identify\n",
! 2241: sc->sc_dev.dv_xname);
! 2242: ncr53c9x_init(sc, 1);
! 2243: return (1);
! 2244: }
! 2245: printf("<<RESELECT CONT'd>>");
! 2246: #if XXXX
! 2247: ncr53c9x_msgin(sc);
! 2248: if (sc->sc_state != NCR_CONNECTED) {
! 2249: /* IDENTIFY fail?! */
! 2250: printf("%s: identify failed\n",
! 2251: sc->sc_dev.dv_xname);
! 2252: ncr53c9x_init(sc, 1);
! 2253: return (1);
! 2254: }
! 2255: #endif
! 2256: break;
! 2257:
! 2258: case NCR_IDENTIFIED:
! 2259: ecb = sc->sc_nexus;
! 2260: if (sc->sc_phase != MESSAGE_IN_PHASE) {
! 2261: int i = (NCR_READ_REG(sc, NCR_FFLAG)
! 2262: & NCRFIFO_FF);
! 2263: /*
! 2264: * Things are seriously fucked up.
! 2265: * Pull the brakes, i.e. reset
! 2266: */
! 2267: printf("%s: target didn't send tag: %d bytes in fifo\n",
! 2268: sc->sc_dev.dv_xname, i);
! 2269: /* Drain and display fifo */
! 2270: while (i-- > 0)
! 2271: printf("[%d] ", NCR_READ_REG(sc, NCR_FIFO));
! 2272: ncr53c9x_init(sc, 1);
! 2273: return (1);
! 2274: } else
! 2275: goto msgin;
! 2276:
! 2277: break;
! 2278: case NCR_IDLE:
! 2279: case NCR_SELECTING:
! 2280: ecb = sc->sc_nexus;
! 2281: if (sc->sc_espintr & NCRINTR_RESEL) {
! 2282: sc->sc_msgpriq = sc->sc_msgout = sc->sc_msgoutq = 0;
! 2283: sc->sc_flags = 0;
! 2284: /*
! 2285: * If we're trying to select a
! 2286: * target ourselves, push our command
! 2287: * back into the ready list.
! 2288: */
! 2289: if (sc->sc_state == NCR_SELECTING) {
! 2290: NCR_MISC(("backoff selector "));
! 2291: timeout_del(&ecb->to);
! 2292: ncr53c9x_dequeue(sc, ecb);
! 2293: TAILQ_INSERT_HEAD(&sc->ready_list, ecb, chain);
! 2294: ecb->flags |= ECB_READY;
! 2295: ecb = sc->sc_nexus = NULL;
! 2296: }
! 2297: sc->sc_state = NCR_RESELECTED;
! 2298: if (sc->sc_phase != MESSAGE_IN_PHASE) {
! 2299: /*
! 2300: * Things are seriously fucked up.
! 2301: * Pull the brakes, i.e. reset
! 2302: */
! 2303: printf("%s: target didn't identify\n",
! 2304: sc->sc_dev.dv_xname);
! 2305: ncr53c9x_init(sc, 1);
! 2306: return (1);
! 2307: }
! 2308: /*
! 2309: * The C90 only inhibits FIFO writes until
! 2310: * reselection is complete, instead of
! 2311: * waiting until the interrupt status register
! 2312: * has been read. So, if the reselect happens
! 2313: * while we were entering a command bytes (for
! 2314: * another target) some of those bytes can
! 2315: * appear in the FIFO here, after the
! 2316: * interrupt is taken.
! 2317: */
! 2318: nfifo = ncr53c9x_rdfifo(sc, NCR_RDFIFO_START);
! 2319:
! 2320: if (nfifo < 2 ||
! 2321: (nfifo > 2 &&
! 2322: sc->sc_rev != NCR_VARIANT_ESP100)) {
! 2323: printf("%s: RESELECT: "
! 2324: "%d bytes in FIFO! "
! 2325: "[intr %x, stat %x, step %d, prevphase %x]\n",
! 2326: sc->sc_dev.dv_xname,
! 2327: nfifo,
! 2328: sc->sc_espintr,
! 2329: sc->sc_espstat,
! 2330: sc->sc_espstep,
! 2331: sc->sc_prevphase);
! 2332: ncr53c9x_init(sc, 1);
! 2333: return (1);
! 2334: }
! 2335: sc->sc_selid = sc->sc_imess[0];
! 2336: NCR_MISC(("selid=%2x ", sc->sc_selid));
! 2337:
! 2338: /* Handle identify message */
! 2339: ncr53c9x_msgin(sc);
! 2340: if (nfifo != 2) {
! 2341: /*
! 2342: * Note: this should not happen
! 2343: * with `dmaselect' on.
! 2344: */
! 2345: sc->sc_flags |= NCR_EXPECT_ILLCMD;
! 2346: NCRCMD(sc, NCRCMD_FLUSH);
! 2347: } else if (sc->sc_features & NCR_F_DMASELECT &&
! 2348: sc->sc_rev == NCR_VARIANT_ESP100) {
! 2349: sc->sc_flags |= NCR_EXPECT_ILLCMD;
! 2350: }
! 2351:
! 2352: if (sc->sc_state != NCR_CONNECTED &&
! 2353: sc->sc_state != NCR_IDENTIFIED) {
! 2354: /* IDENTIFY fail?! */
! 2355: printf("%s: identify failed, state %d, intr %02x\n",
! 2356: sc->sc_dev.dv_xname, sc->sc_state,
! 2357: sc->sc_espintr);
! 2358: ncr53c9x_init(sc, 1);
! 2359: return (1);
! 2360: }
! 2361: goto shortcut; /* ie. next phase expected soon */
! 2362: }
! 2363:
! 2364: #define NCRINTR_DONE (NCRINTR_FC|NCRINTR_BS)
! 2365: if ((sc->sc_espintr & NCRINTR_DONE) == NCRINTR_DONE) {
! 2366: /*
! 2367: * Arbitration won; examine the `step' register
! 2368: * to determine how far the selection could progress.
! 2369: */
! 2370: ecb = sc->sc_nexus;
! 2371: if (!ecb)
! 2372: panic("ncr53c9x: no nexus");
! 2373:
! 2374: sc_link = ecb->xs->sc_link;
! 2375: ti = &sc->sc_tinfo[sc_link->target];
! 2376:
! 2377: switch (sc->sc_espstep) {
! 2378: case 0:
! 2379: /*
! 2380: * The target did not respond with a
! 2381: * message out phase - probably an old
! 2382: * device that doesn't recognize ATN.
! 2383: * Clear ATN and just continue, the
! 2384: * target should be in the command
! 2385: * phase.
! 2386: * XXXX check for command phase?
! 2387: */
! 2388: NCRCMD(sc, NCRCMD_RSTATN);
! 2389: break;
! 2390: case 1:
! 2391: if ((ti->flags & T_NEGOTIATE) == 0 &&
! 2392: ecb->tag[0] == 0) {
! 2393: printf("%s: step 1 & !NEG\n",
! 2394: sc->sc_dev.dv_xname);
! 2395: goto reset;
! 2396: }
! 2397: if (sc->sc_phase != MESSAGE_OUT_PHASE) {
! 2398: printf("%s: !MSGOUT\n",
! 2399: sc->sc_dev.dv_xname);
! 2400: goto reset;
! 2401: }
! 2402: if (ti->flags & T_WIDE) {
! 2403: ncr53c9x_sched_msgout(SEND_WDTR);
! 2404: }
! 2405: if (ti->flags & T_NEGOTIATE) {
! 2406: /* Start negotiating */
! 2407: ti->period = sc->sc_minsync;
! 2408: ti->offset = 15;
! 2409: sc->sc_flags |= NCR_SYNCHNEGO;
! 2410: if (ecb->tag[0])
! 2411: ncr53c9x_sched_msgout(SEND_TAG|SEND_SDTR);
! 2412: else
! 2413: ncr53c9x_sched_msgout(SEND_SDTR);
! 2414: } else {
! 2415: /* Could not do ATN3 so send TAG */
! 2416: ncr53c9x_sched_msgout(SEND_TAG);
! 2417: }
! 2418: sc->sc_prevphase = MESSAGE_OUT_PHASE; /* XXXX */
! 2419: break;
! 2420: case 3:
! 2421: /*
! 2422: * Grr, this is supposed to mean
! 2423: * "target left command phase prematurely".
! 2424: * It seems to happen regularly when
! 2425: * sync mode is on.
! 2426: * Look at FIFO to see if command went out.
! 2427: * (Timing problems?)
! 2428: */
! 2429: if (sc->sc_features & NCR_F_DMASELECT) {
! 2430: if (sc->sc_cmdlen == 0)
! 2431: /* Hope for the best.. */
! 2432: break;
! 2433: } else if ((NCR_READ_REG(sc, NCR_FFLAG)
! 2434: & NCRFIFO_FF) == 0) {
! 2435: /* Hope for the best.. */
! 2436: break;
! 2437: }
! 2438: printf("(%s:%d:%d): selection failed;"
! 2439: " %d left in FIFO "
! 2440: "[intr %x, stat %x, step %d]\n",
! 2441: sc->sc_dev.dv_xname,
! 2442: sc_link->target,
! 2443: sc_link->lun,
! 2444: NCR_READ_REG(sc, NCR_FFLAG)
! 2445: & NCRFIFO_FF,
! 2446: sc->sc_espintr, sc->sc_espstat,
! 2447: sc->sc_espstep);
! 2448: NCRCMD(sc, NCRCMD_FLUSH);
! 2449: ncr53c9x_sched_msgout(SEND_ABORT);
! 2450: return (1);
! 2451: case 2:
! 2452: /* Select stuck at Command Phase */
! 2453: NCRCMD(sc, NCRCMD_FLUSH);
! 2454: break;
! 2455: case 4:
! 2456: if (sc->sc_features & NCR_F_DMASELECT &&
! 2457: sc->sc_cmdlen != 0)
! 2458: printf("(%s:%d:%d): select; "
! 2459: "%lu left in DMA buffer "
! 2460: "[intr %x, stat %x, step %d]\n",
! 2461: sc->sc_dev.dv_xname,
! 2462: sc_link->target,
! 2463: sc_link->lun,
! 2464: (u_long)sc->sc_cmdlen,
! 2465: sc->sc_espintr,
! 2466: sc->sc_espstat,
! 2467: sc->sc_espstep);
! 2468: /* So far, everything went fine */
! 2469: break;
! 2470: }
! 2471:
! 2472: sc->sc_prevphase = INVALID_PHASE; /* ?? */
! 2473: /* Do an implicit RESTORE POINTERS. */
! 2474: sc->sc_dp = ecb->daddr;
! 2475: sc->sc_dleft = ecb->dleft;
! 2476: sc->sc_state = NCR_CONNECTED;
! 2477: break;
! 2478:
! 2479: } else {
! 2480:
! 2481: printf("%s: unexpected status after select"
! 2482: ": [intr %x, stat %x, step %x]\n",
! 2483: sc->sc_dev.dv_xname,
! 2484: sc->sc_espintr, sc->sc_espstat,
! 2485: sc->sc_espstep);
! 2486: NCRCMD(sc, NCRCMD_FLUSH);
! 2487: DELAY(1);
! 2488: goto reset;
! 2489: }
! 2490: if (sc->sc_state == NCR_IDLE) {
! 2491: printf("%s: stray interrupt\n",
! 2492: sc->sc_dev.dv_xname);
! 2493: return (0);
! 2494: }
! 2495: break;
! 2496:
! 2497: case NCR_CONNECTED:
! 2498: if (sc->sc_flags & NCR_ICCS) {
! 2499: /* "Initiate Command Complete Steps" in progress */
! 2500: u_char msg;
! 2501:
! 2502: sc->sc_flags &= ~NCR_ICCS;
! 2503:
! 2504: if (!(sc->sc_espintr & NCRINTR_DONE)) {
! 2505: printf("%s: ICCS: "
! 2506: ": [intr %x, stat %x, step %x]\n",
! 2507: sc->sc_dev.dv_xname,
! 2508: sc->sc_espintr, sc->sc_espstat,
! 2509: sc->sc_espstep);
! 2510: }
! 2511: ncr53c9x_rdfifo(sc, NCR_RDFIFO_START);
! 2512: if (sc->sc_imlen < 2)
! 2513: printf("%s: can't get status, only %d bytes\n",
! 2514: sc->sc_dev.dv_xname, (int)sc->sc_imlen);
! 2515: ecb->stat = sc->sc_imess[sc->sc_imlen - 2];
! 2516: msg = sc->sc_imess[sc->sc_imlen - 1];
! 2517: NCR_PHASE(("<stat:(%x,%x)>", ecb->stat, msg));
! 2518: if (msg == MSG_CMDCOMPLETE) {
! 2519: ecb->dleft = (ecb->flags & ECB_TENTATIVE_DONE)
! 2520: ? 0
! 2521: : sc->sc_dleft;
! 2522: if ((ecb->flags & ECB_SENSE) == 0)
! 2523: ecb->xs->resid = ecb->dleft;
! 2524: sc->sc_state = NCR_CMDCOMPLETE;
! 2525: } else
! 2526: printf("%s: STATUS_PHASE: msg %d\n",
! 2527: sc->sc_dev.dv_xname, msg);
! 2528: sc->sc_imlen = 0;
! 2529: NCRCMD(sc, NCRCMD_MSGOK);
! 2530: goto shortcut; /* ie. wait for disconnect */
! 2531: }
! 2532: break;
! 2533: default:
! 2534: /* Don't panic: reset. */
! 2535: printf("%s: invalid state: %d\n",
! 2536: sc->sc_dev.dv_xname,
! 2537: sc->sc_state);
! 2538: ncr53c9x_scsi_reset(sc);
! 2539: goto out;
! 2540: break;
! 2541: }
! 2542:
! 2543: /*
! 2544: * Driver is now in state NCR_CONNECTED, i.e. we
! 2545: * have a current command working the SCSI bus.
! 2546: */
! 2547: if (sc->sc_state != NCR_CONNECTED || ecb == NULL) {
! 2548: panic("ncr53c9x no nexus");
! 2549: }
! 2550:
! 2551: switch (sc->sc_phase) {
! 2552: case MESSAGE_OUT_PHASE:
! 2553: NCR_PHASE(("MESSAGE_OUT_PHASE "));
! 2554: ncr53c9x_msgout(sc);
! 2555: sc->sc_prevphase = MESSAGE_OUT_PHASE;
! 2556: break;
! 2557: case MESSAGE_IN_PHASE:
! 2558: msgin:
! 2559: NCR_PHASE(("MESSAGE_IN_PHASE "));
! 2560: if (sc->sc_espintr & NCRINTR_BS) {
! 2561: if ((sc->sc_rev != NCR_VARIANT_FAS366) ||
! 2562: !(sc->sc_espstat2 & FAS_STAT2_EMPTY)) {
! 2563: NCRCMD(sc, NCRCMD_FLUSH);
! 2564: }
! 2565: sc->sc_flags |= NCR_WAITI;
! 2566: NCRCMD(sc, NCRCMD_TRANS);
! 2567: } else if (sc->sc_espintr & NCRINTR_FC) {
! 2568: if ((sc->sc_flags & NCR_WAITI) == 0) {
! 2569: printf("%s: MSGIN: unexpected FC bit: "
! 2570: "[intr %x, stat %x, step %x]\n",
! 2571: sc->sc_dev.dv_xname,
! 2572: sc->sc_espintr, sc->sc_espstat,
! 2573: sc->sc_espstep);
! 2574: }
! 2575: sc->sc_flags &= ~NCR_WAITI;
! 2576: ncr53c9x_rdfifo(sc,
! 2577: (sc->sc_prevphase == sc->sc_phase) ?
! 2578: NCR_RDFIFO_CONTINUE : NCR_RDFIFO_START);
! 2579: ncr53c9x_msgin(sc);
! 2580: } else {
! 2581: printf("%s: MSGIN: weird bits: "
! 2582: "[intr %x, stat %x, step %x]\n",
! 2583: sc->sc_dev.dv_xname,
! 2584: sc->sc_espintr, sc->sc_espstat,
! 2585: sc->sc_espstep);
! 2586: }
! 2587: sc->sc_prevphase = MESSAGE_IN_PHASE;
! 2588: goto shortcut; /* i.e. expect data to be ready */
! 2589: break;
! 2590: case COMMAND_PHASE:
! 2591: /*
! 2592: * Send the command block. Normally we don't see this
! 2593: * phase because the SEL_ATN command takes care of
! 2594: * all this. However, we end up here if either the
! 2595: * target or we wanted to exchange some more messages
! 2596: * first (e.g. to start negotiations).
! 2597: */
! 2598:
! 2599: NCR_PHASE(("COMMAND_PHASE 0x%02x (%d) ",
! 2600: ecb->cmd.cmd.opcode, ecb->clen));
! 2601: if (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF) {
! 2602: NCRCMD(sc, NCRCMD_FLUSH);
! 2603: /* DELAY(1); */
! 2604: }
! 2605: if (sc->sc_features & NCR_F_DMASELECT) {
! 2606: size_t size;
! 2607: /* setup DMA transfer for command */
! 2608: size = ecb->clen;
! 2609: sc->sc_cmdlen = size;
! 2610: sc->sc_cmdp = (caddr_t)&ecb->cmd.cmd;
! 2611: NCRDMA_SETUP(sc, &sc->sc_cmdp, &sc->sc_cmdlen,
! 2612: 0, &size);
! 2613: /* Program the SCSI counter */
! 2614: NCR_SET_COUNT(sc, size);
! 2615:
! 2616: /* load the count in */
! 2617: NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
! 2618:
! 2619: /* start the command transfer */
! 2620: NCRCMD(sc, NCRCMD_TRANS | NCRCMD_DMA);
! 2621: NCRDMA_GO(sc);
! 2622: } else {
! 2623: ncr53c9x_wrfifo(sc, (u_char *)&ecb->cmd.cmd, ecb->clen);
! 2624: NCRCMD(sc, NCRCMD_TRANS);
! 2625: }
! 2626: sc->sc_prevphase = COMMAND_PHASE;
! 2627: break;
! 2628: case DATA_OUT_PHASE:
! 2629: NCR_PHASE(("DATA_OUT_PHASE [%ld] ",(long)sc->sc_dleft));
! 2630: NCRCMD(sc, NCRCMD_FLUSH);
! 2631: size = min(sc->sc_dleft, sc->sc_maxxfer);
! 2632: NCRDMA_SETUP(sc, &sc->sc_dp, &sc->sc_dleft,
! 2633: 0, &size);
! 2634: sc->sc_prevphase = DATA_OUT_PHASE;
! 2635: goto setup_xfer;
! 2636: case DATA_IN_PHASE:
! 2637: NCR_PHASE(("DATA_IN_PHASE "));
! 2638: if (sc->sc_rev == NCR_VARIANT_ESP100)
! 2639: NCRCMD(sc, NCRCMD_FLUSH);
! 2640: size = min(sc->sc_dleft, sc->sc_maxxfer);
! 2641: NCRDMA_SETUP(sc, &sc->sc_dp, &sc->sc_dleft,
! 2642: 1, &size);
! 2643: sc->sc_prevphase = DATA_IN_PHASE;
! 2644: setup_xfer:
! 2645: /* Target returned to data phase: wipe "done" memory */
! 2646: ecb->flags &= ~ECB_TENTATIVE_DONE;
! 2647:
! 2648: /* Program the SCSI counter */
! 2649: NCR_SET_COUNT(sc, size);
! 2650:
! 2651: /* load the count in */
! 2652: NCRCMD(sc, NCRCMD_NOP|NCRCMD_DMA);
! 2653:
! 2654: /*
! 2655: * Note that if `size' is 0, we've already transceived
! 2656: * all the bytes we want but we're still in DATA PHASE.
! 2657: * Apparently, the device needs padding. Also, a
! 2658: * transfer size of 0 means "maximum" to the chip
! 2659: * DMA logic.
! 2660: */
! 2661: NCRCMD(sc,
! 2662: (size==0?NCRCMD_TRPAD:NCRCMD_TRANS)|NCRCMD_DMA);
! 2663: NCRDMA_GO(sc);
! 2664: return (1);
! 2665: case STATUS_PHASE:
! 2666: NCR_PHASE(("STATUS_PHASE "));
! 2667: sc->sc_flags |= NCR_ICCS;
! 2668: NCRCMD(sc, NCRCMD_ICCS);
! 2669: sc->sc_prevphase = STATUS_PHASE;
! 2670: goto shortcut; /* i.e. expect status results soon */
! 2671: break;
! 2672: case INVALID_PHASE:
! 2673: break;
! 2674: default:
! 2675: printf("%s: unexpected bus phase; resetting\n",
! 2676: sc->sc_dev.dv_xname);
! 2677: goto reset;
! 2678: }
! 2679:
! 2680: out:
! 2681: return (1);
! 2682:
! 2683: reset:
! 2684: ncr53c9x_init(sc, 1);
! 2685: goto out;
! 2686:
! 2687: finish:
! 2688: ncr53c9x_done(sc, ecb);
! 2689: goto out;
! 2690:
! 2691: sched:
! 2692: sc->sc_state = NCR_IDLE;
! 2693: ncr53c9x_sched(sc);
! 2694: goto out;
! 2695:
! 2696: shortcut:
! 2697: /*
! 2698: * The idea is that many of the SCSI operations take very little
! 2699: * time, and going away and getting interrupted is too high an
! 2700: * overhead to pay. For example, selecting, sending a message
! 2701: * and command and then doing some work can be done in one "pass".
! 2702: *
! 2703: * The delay is a heuristic. It is 2 when at 20MHz, 2 at 25MHz and 1
! 2704: * at 40MHz. This needs testing.
! 2705: */
! 2706: {
! 2707: struct timeval wait, cur;
! 2708:
! 2709: microtime(&wait);
! 2710: wait.tv_usec += 50/sc->sc_freq;
! 2711: if (wait.tv_usec > 1000000) {
! 2712: wait.tv_sec++;
! 2713: wait.tv_usec -= 1000000;
! 2714: }
! 2715: do {
! 2716: if (NCRDMA_ISINTR(sc))
! 2717: goto again;
! 2718: microtime(&cur);
! 2719: } while (timercmp(&cur, &wait, <=));
! 2720: }
! 2721: goto out;
! 2722: }
! 2723:
! 2724: void
! 2725: ncr53c9x_abort(sc, ecb)
! 2726: struct ncr53c9x_softc *sc;
! 2727: struct ncr53c9x_ecb *ecb;
! 2728: {
! 2729:
! 2730: /* 2 secs for the abort */
! 2731: ecb->timeout = NCR_ABORT_TIMEOUT;
! 2732: ecb->flags |= ECB_ABORT;
! 2733:
! 2734: if (ecb == sc->sc_nexus) {
! 2735: int timeout = ecb->timeout;
! 2736:
! 2737: /*
! 2738: * If we're still selecting, the message will be scheduled
! 2739: * after selection is complete.
! 2740: */
! 2741: if (sc->sc_state == NCR_CONNECTED)
! 2742: ncr53c9x_sched_msgout(SEND_ABORT);
! 2743:
! 2744: /*
! 2745: * Reschedule timeout.
! 2746: */
! 2747: if (timeout > 1000000)
! 2748: timeout = (timeout / 1000) * hz;
! 2749: else
! 2750: timeout = (timeout * hz) / 1000;
! 2751: timeout_add(&ecb->to, timeout);
! 2752: } else {
! 2753: /*
! 2754: * Just leave the command where it is.
! 2755: * XXX - what choice do we have but to reset the SCSI
! 2756: * eventually?
! 2757: */
! 2758: if (sc->sc_state == NCR_IDLE)
! 2759: ncr53c9x_sched(sc);
! 2760: }
! 2761: }
! 2762:
! 2763: void
! 2764: ncr53c9x_timeout(arg)
! 2765: void *arg;
! 2766: {
! 2767: struct ncr53c9x_ecb *ecb = arg;
! 2768: struct scsi_xfer *xs = ecb->xs;
! 2769: struct scsi_link *sc_link = xs->sc_link;
! 2770: struct ncr53c9x_softc *sc = sc_link->adapter_softc;
! 2771: struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[sc_link->target];
! 2772: int s;
! 2773:
! 2774: sc_print_addr(sc_link);
! 2775: printf("%s: timed out [ecb %p (flags 0x%x, dleft %x, stat %x)], "
! 2776: "<state %d, nexus %p, phase(l %x, c %x, p %x), resid %lx, "
! 2777: "msg(q %x,o %x) %s>",
! 2778: sc->sc_dev.dv_xname,
! 2779: ecb, ecb->flags, ecb->dleft, ecb->stat,
! 2780: sc->sc_state, sc->sc_nexus,
! 2781: NCR_READ_REG(sc, NCR_STAT),
! 2782: sc->sc_phase, sc->sc_prevphase,
! 2783: (long)sc->sc_dleft, sc->sc_msgpriq, sc->sc_msgout,
! 2784: NCRDMA_ISACTIVE(sc) ? "DMA active" : "");
! 2785: #if NCR53C9X_DEBUG > 1
! 2786: printf("TRACE: %s.", ecb->trace);
! 2787: #endif
! 2788:
! 2789: s = splbio();
! 2790:
! 2791: if (ecb->flags & ECB_ABORT) {
! 2792: /* abort timed out */
! 2793: printf(" AGAIN\n");
! 2794:
! 2795: ncr53c9x_init(sc, 1);
! 2796: } else {
! 2797: /* abort the operation that has timed out */
! 2798: printf("\n");
! 2799: xs->error = XS_TIMEOUT;
! 2800: ncr53c9x_abort(sc, ecb);
! 2801:
! 2802: /* Disable sync mode if stuck in a data phase */
! 2803: if (ecb == sc->sc_nexus &&
! 2804: (ti->flags & T_SYNCMODE) != 0 &&
! 2805: (sc->sc_phase & (MSGI|CDI)) == 0) {
! 2806: sc_print_addr(sc_link);
! 2807: printf("sync negotiation disabled\n");
! 2808: sc->sc_cfflags |= (1 << (sc_link->target + 16));
! 2809: }
! 2810: }
! 2811:
! 2812: splx(s);
! 2813: }
! 2814:
! 2815: void
! 2816: ncr53c9x_watch(arg)
! 2817: void *arg;
! 2818: {
! 2819: struct ncr53c9x_softc *sc = (struct ncr53c9x_softc *)arg;
! 2820: struct ncr53c9x_tinfo *ti;
! 2821: struct ncr53c9x_linfo *li;
! 2822: int t, s;
! 2823: /* Delete any structures that have not been used in 10min. */
! 2824: time_t old = time_second - (10*60);
! 2825:
! 2826: s = splbio();
! 2827: for (t = 0; t < sc->sc_ntarg; t++) {
! 2828: ti = &sc->sc_tinfo[t];
! 2829: for (li = LIST_FIRST(&ti->luns); li != LIST_END(&ti->luns); ) {
! 2830: if (li->last_used < old && !li->untagged && !li->used) {
! 2831: if (li->lun < NCR_NLUN)
! 2832: ti->lun[li->lun] = NULL;
! 2833: LIST_REMOVE(li, link);
! 2834: free(li, M_DEVBUF);
! 2835: /* Restart the search at the beginning */
! 2836: li = LIST_FIRST(&ti->luns);
! 2837: continue;
! 2838: }
! 2839: li = LIST_NEXT(li, link);
! 2840: }
! 2841: }
! 2842: splx(s);
! 2843: timeout_add(&sc->sc_watchdog, 60*hz);
! 2844: }