Annotation of sys/dev/ic/siop.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: siop.c,v 1.48 2007/08/05 19:05:09 kettenis Exp $ */
! 2: /* $NetBSD: siop.c,v 1.79 2005/11/18 23:10:32 bouyer Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 2000 Manuel Bouyer.
! 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 Manuel Bouyer.
! 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: /* SYM53c7/8xx PCI-SCSI I/O Processors driver */
! 35:
! 36: #include <sys/param.h>
! 37: #include <sys/systm.h>
! 38: #include <sys/device.h>
! 39: #include <sys/malloc.h>
! 40: #include <sys/buf.h>
! 41: #include <sys/kernel.h>
! 42:
! 43: #include <machine/endian.h>
! 44: #include <machine/bus.h>
! 45:
! 46: #include <dev/microcode/siop/siop.out>
! 47:
! 48: #include <scsi/scsi_all.h>
! 49: #include <scsi/scsi_message.h>
! 50: #include <scsi/scsiconf.h>
! 51:
! 52: #include <dev/ic/siopreg.h>
! 53: #include <dev/ic/siopvar_common.h>
! 54: #include <dev/ic/siopvar.h>
! 55:
! 56: #ifndef SIOP_DEBUG
! 57: #undef SIOP_DEBUG
! 58: #undef SIOP_DEBUG_DR
! 59: #undef SIOP_DEBUG_INTR
! 60: #undef SIOP_DEBUG_SCHED
! 61: #undef DUMP_SCRIPT
! 62: #else
! 63: #define SIOP_DEBUG_DR
! 64: #define SIOP_DEBUG_INTR
! 65: #define SIOP_DEBUG_SCHED
! 66: #define DUMP_SCRIPT
! 67: #endif
! 68:
! 69:
! 70: #undef SIOP_STATS
! 71:
! 72: #ifndef SIOP_DEFAULT_TARGET
! 73: #define SIOP_DEFAULT_TARGET 7
! 74: #endif
! 75:
! 76: /* number of cmd descriptors per block */
! 77: #define SIOP_NCMDPB (PAGE_SIZE / sizeof(struct siop_xfer))
! 78:
! 79: /* Number of scheduler slot (needs to match script) */
! 80: #define SIOP_NSLOTS 40
! 81:
! 82: void siop_table_sync(struct siop_cmd *, int);
! 83: void siop_script_sync(struct siop_softc *, int);
! 84: u_int32_t siop_script_read(struct siop_softc *, u_int);
! 85: void siop_script_write(struct siop_softc *, u_int, u_int32_t);
! 86: void siop_reset(struct siop_softc *);
! 87: void siop_handle_reset(struct siop_softc *);
! 88: int siop_handle_qtag_reject(struct siop_cmd *);
! 89: void siop_scsicmd_end(struct siop_cmd *);
! 90: void siop_start(struct siop_softc *);
! 91: void siop_timeout(void *);
! 92: int siop_scsicmd(struct scsi_xfer *);
! 93: #ifdef DUMP_SCRIPT
! 94: void siop_dump_script(struct siop_softc *);
! 95: #endif
! 96: void siop_morecbd(struct siop_softc *);
! 97: struct siop_lunsw *siop_get_lunsw(struct siop_softc *);
! 98: void siop_add_reselsw(struct siop_softc *, int);
! 99: void siop_update_scntl3(struct siop_softc *, struct siop_common_target *);
! 100:
! 101: struct cfdriver siop_cd = {
! 102: NULL, "siop", DV_DULL
! 103: };
! 104:
! 105: struct scsi_adapter siop_adapter = {
! 106: siop_scsicmd,
! 107: siop_minphys,
! 108: NULL,
! 109: NULL,
! 110: };
! 111:
! 112: struct scsi_device siop_dev = {
! 113: NULL,
! 114: NULL,
! 115: NULL,
! 116: NULL,
! 117: };
! 118:
! 119: #ifdef SIOP_STATS
! 120: static int siop_stat_intr = 0;
! 121: static int siop_stat_intr_shortxfer = 0;
! 122: static int siop_stat_intr_sdp = 0;
! 123: static int siop_stat_intr_saveoffset = 0;
! 124: static int siop_stat_intr_done = 0;
! 125: static int siop_stat_intr_xferdisc = 0;
! 126: static int siop_stat_intr_lunresel = 0;
! 127: static int siop_stat_intr_qfull = 0;
! 128: void siop_printstats(void);
! 129: #define INCSTAT(x) x++
! 130: #else
! 131: #define INCSTAT(x)
! 132: #endif
! 133:
! 134: void
! 135: siop_table_sync(siop_cmd, ops)
! 136: struct siop_cmd *siop_cmd;
! 137: int ops;
! 138: {
! 139: struct siop_common_softc *sc = siop_cmd->cmd_c.siop_sc;
! 140: bus_addr_t offset;
! 141:
! 142: offset = siop_cmd->cmd_c.dsa -
! 143: siop_cmd->siop_cbdp->xferdma->dm_segs[0].ds_addr;
! 144: bus_dmamap_sync(sc->sc_dmat, siop_cmd->siop_cbdp->xferdma, offset,
! 145: sizeof(struct siop_xfer), ops);
! 146: }
! 147:
! 148: void
! 149: siop_script_sync(sc, ops)
! 150: struct siop_softc *sc;
! 151: int ops;
! 152: {
! 153: if ((sc->sc_c.features & SF_CHIP_RAM) == 0)
! 154: bus_dmamap_sync(sc->sc_c.sc_dmat, sc->sc_c.sc_scriptdma, 0,
! 155: PAGE_SIZE, ops);
! 156: }
! 157:
! 158: u_int32_t
! 159: siop_script_read(sc, offset)
! 160: struct siop_softc *sc;
! 161: u_int offset;
! 162: {
! 163: if (sc->sc_c.features & SF_CHIP_RAM) {
! 164: return bus_space_read_4(sc->sc_c.sc_ramt, sc->sc_c.sc_ramh,
! 165: offset * 4);
! 166: } else {
! 167: return siop_ctoh32(&sc->sc_c, sc->sc_c.sc_script[offset]);
! 168: }
! 169: }
! 170:
! 171: void
! 172: siop_script_write(sc, offset, val)
! 173: struct siop_softc *sc;
! 174: u_int offset;
! 175: u_int32_t val;
! 176: {
! 177: if (sc->sc_c.features & SF_CHIP_RAM) {
! 178: bus_space_write_4(sc->sc_c.sc_ramt, sc->sc_c.sc_ramh,
! 179: offset * 4, val);
! 180: } else {
! 181: sc->sc_c.sc_script[offset] = siop_htoc32(&sc->sc_c, val);
! 182: }
! 183: }
! 184:
! 185: void
! 186: siop_attach(sc)
! 187: struct siop_softc *sc;
! 188: {
! 189: struct scsibus_attach_args saa;
! 190:
! 191: if (siop_common_attach(&sc->sc_c) != 0)
! 192: return;
! 193:
! 194: TAILQ_INIT(&sc->free_list);
! 195: TAILQ_INIT(&sc->ready_list);
! 196: TAILQ_INIT(&sc->urgent_list);
! 197: TAILQ_INIT(&sc->cmds);
! 198: TAILQ_INIT(&sc->lunsw_list);
! 199: sc->sc_currschedslot = 0;
! 200: sc->sc_c.sc_link.adapter = &siop_adapter;
! 201: sc->sc_c.sc_link.device = &siop_dev;
! 202: sc->sc_c.sc_link.openings = SIOP_NTAG;
! 203:
! 204: /* Start with one page worth of commands */
! 205: siop_morecbd(sc);
! 206:
! 207: #ifdef SIOP_DEBUG
! 208: printf("%s: script size = %d, PHY addr=0x%x, VIRT=%p\n",
! 209: sc->sc_c.sc_dev.dv_xname, (int)sizeof(siop_script),
! 210: (u_int32_t)sc->sc_c.sc_scriptaddr, sc->sc_c.sc_script);
! 211: #endif
! 212:
! 213: /* Do a bus reset, so that devices fall back to narrow/async */
! 214: siop_resetbus(&sc->sc_c);
! 215: /*
! 216: * siop_reset() will reset the chip, thus clearing pending interrupts
! 217: */
! 218: siop_reset(sc);
! 219: #ifdef DUMP_SCRIPT
! 220: siop_dump_script(sc);
! 221: #endif
! 222:
! 223: bzero(&saa, sizeof(saa));
! 224: saa.saa_sc_link = &sc->sc_c.sc_link;
! 225:
! 226: config_found((struct device*)sc, &saa, scsiprint);
! 227: }
! 228:
! 229: void
! 230: siop_reset(sc)
! 231: struct siop_softc *sc;
! 232: {
! 233: int i, j;
! 234: struct siop_lunsw *lunsw;
! 235:
! 236: siop_common_reset(&sc->sc_c);
! 237:
! 238: /* copy and patch the script */
! 239: if (sc->sc_c.features & SF_CHIP_RAM) {
! 240: bus_space_write_region_4(sc->sc_c.sc_ramt, sc->sc_c.sc_ramh, 0,
! 241: siop_script, sizeof(siop_script) / sizeof(siop_script[0]));
! 242: for (j = 0; j <
! 243: (sizeof(E_abs_msgin_Used) / sizeof(E_abs_msgin_Used[0]));
! 244: j++) {
! 245: bus_space_write_4(sc->sc_c.sc_ramt, sc->sc_c.sc_ramh,
! 246: E_abs_msgin_Used[j] * 4,
! 247: sc->sc_c.sc_scriptaddr + Ent_msgin_space);
! 248: }
! 249: if (sc->sc_c.features & SF_CHIP_LED0) {
! 250: bus_space_write_region_4(sc->sc_c.sc_ramt,
! 251: sc->sc_c.sc_ramh,
! 252: Ent_led_on1, siop_led_on,
! 253: sizeof(siop_led_on) / sizeof(siop_led_on[0]));
! 254: bus_space_write_region_4(sc->sc_c.sc_ramt,
! 255: sc->sc_c.sc_ramh,
! 256: Ent_led_on2, siop_led_on,
! 257: sizeof(siop_led_on) / sizeof(siop_led_on[0]));
! 258: bus_space_write_region_4(sc->sc_c.sc_ramt,
! 259: sc->sc_c.sc_ramh,
! 260: Ent_led_off, siop_led_off,
! 261: sizeof(siop_led_off) / sizeof(siop_led_off[0]));
! 262: }
! 263: } else {
! 264: for (j = 0;
! 265: j < (sizeof(siop_script) / sizeof(siop_script[0])); j++) {
! 266: sc->sc_c.sc_script[j] =
! 267: siop_htoc32(&sc->sc_c, siop_script[j]);
! 268: }
! 269: for (j = 0; j <
! 270: (sizeof(E_abs_msgin_Used) / sizeof(E_abs_msgin_Used[0]));
! 271: j++) {
! 272: sc->sc_c.sc_script[E_abs_msgin_Used[j]] =
! 273: siop_htoc32(&sc->sc_c,
! 274: sc->sc_c.sc_scriptaddr + Ent_msgin_space);
! 275: }
! 276: if (sc->sc_c.features & SF_CHIP_LED0) {
! 277: for (j = 0; j < (sizeof(siop_led_on) /
! 278: sizeof(siop_led_on[0])); j++)
! 279: sc->sc_c.sc_script[
! 280: Ent_led_on1 / sizeof(siop_led_on[0]) + j
! 281: ] = siop_htoc32(&sc->sc_c, siop_led_on[j]);
! 282: for (j = 0; j < (sizeof(siop_led_on) /
! 283: sizeof(siop_led_on[0])); j++)
! 284: sc->sc_c.sc_script[
! 285: Ent_led_on2 / sizeof(siop_led_on[0]) + j
! 286: ] = siop_htoc32(&sc->sc_c, siop_led_on[j]);
! 287: for (j = 0; j < (sizeof(siop_led_off) /
! 288: sizeof(siop_led_off[0])); j++)
! 289: sc->sc_c.sc_script[
! 290: Ent_led_off / sizeof(siop_led_off[0]) + j
! 291: ] = siop_htoc32(&sc->sc_c, siop_led_off[j]);
! 292: }
! 293: }
! 294: sc->script_free_lo = sizeof(siop_script) / sizeof(siop_script[0]);
! 295: sc->script_free_hi = sc->sc_c.ram_size / 4;
! 296: sc->sc_ntargets = 0;
! 297:
! 298: /* free used and unused lun switches */
! 299: while((lunsw = TAILQ_FIRST(&sc->lunsw_list)) != NULL) {
! 300: #ifdef SIOP_DEBUG
! 301: printf("%s: free lunsw at offset %d\n",
! 302: sc->sc_c.sc_dev.dv_xname, lunsw->lunsw_off);
! 303: #endif
! 304: TAILQ_REMOVE(&sc->lunsw_list, lunsw, next);
! 305: free(lunsw, M_DEVBUF);
! 306: }
! 307: TAILQ_INIT(&sc->lunsw_list);
! 308: /* restore reselect switch */
! 309: for (i = 0; i < sc->sc_c.sc_link.adapter_buswidth; i++) {
! 310: struct siop_target *target;
! 311: if (sc->sc_c.targets[i] == NULL)
! 312: continue;
! 313: #ifdef SIOP_DEBUG
! 314: printf("%s: restore sw for target %d\n",
! 315: sc->sc_c.sc_dev.dv_xname, i);
! 316: #endif
! 317: target = (struct siop_target *)sc->sc_c.targets[i];
! 318: free(target->lunsw, M_DEVBUF);
! 319: target->lunsw = siop_get_lunsw(sc);
! 320: if (target->lunsw == NULL) {
! 321: printf("%s: can't alloc lunsw for target %d\n",
! 322: sc->sc_c.sc_dev.dv_xname, i);
! 323: break;
! 324: }
! 325: siop_add_reselsw(sc, i);
! 326: }
! 327:
! 328: /* start script */
! 329: if ((sc->sc_c.features & SF_CHIP_RAM) == 0) {
! 330: bus_dmamap_sync(sc->sc_c.sc_dmat, sc->sc_c.sc_scriptdma, 0,
! 331: PAGE_SIZE, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 332: }
! 333: bus_space_write_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh, SIOP_DSP,
! 334: sc->sc_c.sc_scriptaddr + Ent_reselect);
! 335: }
! 336:
! 337: #if 0
! 338: #define CALL_SCRIPT(ent) do {\
! 339: printf ("start script DSA 0x%lx DSP 0x%lx\n", \
! 340: siop_cmd->cmd_c.dsa, \
! 341: sc->sc_c.sc_scriptaddr + ent); \
! 342: bus_space_write_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh, SIOP_DSP, sc->sc_c.sc_scriptaddr + ent); \
! 343: } while (0)
! 344: #else
! 345: #define CALL_SCRIPT(ent) do {\
! 346: bus_space_write_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh, SIOP_DSP, sc->sc_c.sc_scriptaddr + ent); \
! 347: } while (0)
! 348: #endif
! 349:
! 350: int
! 351: siop_intr(v)
! 352: void *v;
! 353: {
! 354: struct siop_softc *sc = v;
! 355: struct siop_target *siop_target;
! 356: struct siop_cmd *siop_cmd;
! 357: struct siop_lun *siop_lun;
! 358: struct scsi_xfer *xs;
! 359: int istat, sist, sstat1, dstat = 0;
! 360: u_int32_t irqcode;
! 361: int need_reset = 0;
! 362: int offset, target, lun, tag;
! 363: bus_addr_t dsa;
! 364: struct siop_cbd *cbdp;
! 365: int freetarget = 0;
! 366: int restart = 0;
! 367:
! 368: istat = bus_space_read_1(sc->sc_c.sc_rt, sc->sc_c.sc_rh, SIOP_ISTAT);
! 369: if ((istat & (ISTAT_INTF | ISTAT_DIP | ISTAT_SIP)) == 0)
! 370: return 0;
! 371: INCSTAT(siop_stat_intr);
! 372: if (istat & ISTAT_INTF) {
! 373: printf("INTRF\n");
! 374: bus_space_write_1(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 375: SIOP_ISTAT, ISTAT_INTF);
! 376: }
! 377: if ((istat &(ISTAT_DIP | ISTAT_SIP | ISTAT_ABRT)) ==
! 378: (ISTAT_DIP | ISTAT_ABRT)) {
! 379: /* clear abort */
! 380: bus_space_write_1(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 381: SIOP_ISTAT, 0);
! 382: }
! 383: /* use DSA to find the current siop_cmd */
! 384: siop_cmd = NULL;
! 385: dsa = bus_space_read_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh, SIOP_DSA);
! 386: TAILQ_FOREACH(cbdp, &sc->cmds, next) {
! 387: if (dsa >= cbdp->xferdma->dm_segs[0].ds_addr &&
! 388: dsa < cbdp->xferdma->dm_segs[0].ds_addr + PAGE_SIZE) {
! 389: dsa -= cbdp->xferdma->dm_segs[0].ds_addr;
! 390: siop_cmd = &cbdp->cmds[dsa / sizeof(struct siop_xfer)];
! 391: siop_table_sync(siop_cmd,
! 392: BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
! 393: break;
! 394: }
! 395: }
! 396: if (siop_cmd) {
! 397: xs = siop_cmd->cmd_c.xs;
! 398: siop_target = (struct siop_target *)siop_cmd->cmd_c.siop_target;
! 399: target = siop_cmd->cmd_c.xs->sc_link->target;
! 400: lun = siop_cmd->cmd_c.xs->sc_link->lun;
! 401: tag = siop_cmd->cmd_c.tag;
! 402: siop_lun = siop_target->siop_lun[lun];
! 403: #ifdef DIAGNOSTIC
! 404: if (siop_cmd->cmd_c.status != CMDST_ACTIVE &&
! 405: siop_cmd->cmd_c.status != CMDST_SENSE_ACTIVE) {
! 406: printf("siop_cmd (lun %d) for DSA 0x%x "
! 407: "not active (%d)\n", lun, (u_int)dsa,
! 408: siop_cmd->cmd_c.status);
! 409: xs = NULL;
! 410: siop_target = NULL;
! 411: target = -1;
! 412: lun = -1;
! 413: tag = -1;
! 414: siop_lun = NULL;
! 415: siop_cmd = NULL;
! 416: } else if (siop_lun->siop_tag[tag].active != siop_cmd) {
! 417: printf("siop_cmd (lun %d tag %d) not in siop_lun "
! 418: "active (%p != %p)\n", lun, tag, siop_cmd,
! 419: siop_lun->siop_tag[tag].active);
! 420: }
! 421: #endif
! 422: } else {
! 423: xs = NULL;
! 424: siop_target = NULL;
! 425: target = -1;
! 426: lun = -1;
! 427: tag = -1;
! 428: siop_lun = NULL;
! 429: }
! 430: if (istat & ISTAT_DIP) {
! 431: dstat = bus_space_read_1(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 432: SIOP_DSTAT);
! 433: if (dstat & DSTAT_ABRT) {
! 434: /* was probably generated by a bus reset IOCTL */
! 435: if ((dstat & DSTAT_DFE) == 0)
! 436: siop_clearfifo(&sc->sc_c);
! 437: goto reset;
! 438: }
! 439: if (dstat & DSTAT_SSI) {
! 440: printf("single step dsp 0x%08x dsa 0x08%x\n",
! 441: (int)(bus_space_read_4(sc->sc_c.sc_rt,
! 442: sc->sc_c.sc_rh, SIOP_DSP) -
! 443: sc->sc_c.sc_scriptaddr),
! 444: bus_space_read_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 445: SIOP_DSA));
! 446: if ((dstat & ~(DSTAT_DFE | DSTAT_SSI)) == 0 &&
! 447: (istat & ISTAT_SIP) == 0) {
! 448: bus_space_write_1(sc->sc_c.sc_rt,
! 449: sc->sc_c.sc_rh, SIOP_DCNTL,
! 450: bus_space_read_1(sc->sc_c.sc_rt,
! 451: sc->sc_c.sc_rh, SIOP_DCNTL) | DCNTL_STD);
! 452: }
! 453: return 1;
! 454: }
! 455:
! 456: if (dstat & ~(DSTAT_SIR | DSTAT_DFE | DSTAT_SSI)) {
! 457: printf("%s: DMA IRQ:", sc->sc_c.sc_dev.dv_xname);
! 458: if (dstat & DSTAT_IID)
! 459: printf(" illegal instruction");
! 460: if (dstat & DSTAT_BF)
! 461: printf(" bus fault");
! 462: if (dstat & DSTAT_MDPE)
! 463: printf(" parity");
! 464: if (dstat & DSTAT_DFE)
! 465: printf(" DMA fifo empty");
! 466: else
! 467: siop_clearfifo(&sc->sc_c);
! 468: printf(", DSP=0x%x DSA=0x%x: ",
! 469: (int)(bus_space_read_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 470: SIOP_DSP) - sc->sc_c.sc_scriptaddr),
! 471: bus_space_read_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh, SIOP_DSA));
! 472: if (siop_cmd)
! 473: printf("last msg_in=0x%x status=0x%x\n",
! 474: siop_cmd->cmd_tables->msg_in[0],
! 475: siop_ctoh32(&sc->sc_c,
! 476: siop_cmd->cmd_tables->status));
! 477: else
! 478: printf("current DSA invalid\n");
! 479: need_reset = 1;
! 480: }
! 481: }
! 482: if (istat & ISTAT_SIP) {
! 483: if (istat & ISTAT_DIP)
! 484: delay(10);
! 485: /*
! 486: * Can't read sist0 & sist1 independently, or we have to
! 487: * insert delay
! 488: */
! 489: sist = bus_space_read_2(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 490: SIOP_SIST0);
! 491: sstat1 = bus_space_read_1(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 492: SIOP_SSTAT1);
! 493: #ifdef SIOP_DEBUG_INTR
! 494: printf("scsi interrupt, sist=0x%x sstat1=0x%x "
! 495: "DSA=0x%x DSP=0x%lx\n", sist, sstat1,
! 496: bus_space_read_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh, SIOP_DSA),
! 497: (u_long)(bus_space_read_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 498: SIOP_DSP) -
! 499: sc->sc_c.sc_scriptaddr));
! 500: #endif
! 501: if (sist & SIST0_RST) {
! 502: siop_handle_reset(sc);
! 503: siop_start(sc);
! 504: /* no table to flush here */
! 505: return 1;
! 506: }
! 507: if (sist & SIST0_SGE) {
! 508: if (siop_cmd)
! 509: sc_print_addr(xs->sc_link);
! 510: else
! 511: printf("%s:", sc->sc_c.sc_dev.dv_xname);
! 512: printf("scsi gross error\n");
! 513: goto reset;
! 514: }
! 515: if ((sist & SIST0_MA) && need_reset == 0) {
! 516: if (siop_cmd) {
! 517: int scratcha0;
! 518: /* XXX Why read DSTAT again? */
! 519: dstat = bus_space_read_1(sc->sc_c.sc_rt,
! 520: sc->sc_c.sc_rh, SIOP_DSTAT);
! 521: /*
! 522: * first restore DSA, in case we were in a S/G
! 523: * operation.
! 524: */
! 525: bus_space_write_4(sc->sc_c.sc_rt,
! 526: sc->sc_c.sc_rh,
! 527: SIOP_DSA, siop_cmd->cmd_c.dsa);
! 528: scratcha0 = bus_space_read_1(sc->sc_c.sc_rt,
! 529: sc->sc_c.sc_rh, SIOP_SCRATCHA);
! 530: switch (sstat1 & SSTAT1_PHASE_MASK) {
! 531: case SSTAT1_PHASE_STATUS:
! 532: /*
! 533: * previous phase may be aborted for any reason
! 534: * ( for example, the target has less data to
! 535: * transfer than requested). Compute resid and
! 536: * just go to status, the command should
! 537: * terminate.
! 538: */
! 539: INCSTAT(siop_stat_intr_shortxfer);
! 540: if (scratcha0 & A_flag_data)
! 541: siop_ma(&siop_cmd->cmd_c);
! 542: else if ((dstat & DSTAT_DFE) == 0)
! 543: siop_clearfifo(&sc->sc_c);
! 544: CALL_SCRIPT(Ent_status);
! 545: return 1;
! 546: case SSTAT1_PHASE_MSGIN:
! 547: /*
! 548: * target may be ready to disconnect
! 549: * Compute resid which would be used later
! 550: * if a save data pointer is needed.
! 551: */
! 552: INCSTAT(siop_stat_intr_xferdisc);
! 553: if (scratcha0 & A_flag_data)
! 554: siop_ma(&siop_cmd->cmd_c);
! 555: else if ((dstat & DSTAT_DFE) == 0)
! 556: siop_clearfifo(&sc->sc_c);
! 557: bus_space_write_1(sc->sc_c.sc_rt,
! 558: sc->sc_c.sc_rh, SIOP_SCRATCHA,
! 559: scratcha0 & ~A_flag_data);
! 560: CALL_SCRIPT(Ent_msgin);
! 561: return 1;
! 562: }
! 563: printf("%s: unexpected phase mismatch %d\n",
! 564: sc->sc_c.sc_dev.dv_xname,
! 565: sstat1 & SSTAT1_PHASE_MASK);
! 566: } else {
! 567: printf("%s: phase mismatch without command\n",
! 568: sc->sc_c.sc_dev.dv_xname);
! 569: }
! 570: need_reset = 1;
! 571: }
! 572: if (sist & SIST0_PAR) {
! 573: /* parity error, reset */
! 574: if (siop_cmd)
! 575: sc_print_addr(xs->sc_link);
! 576: else
! 577: printf("%s:", sc->sc_c.sc_dev.dv_xname);
! 578: printf("parity error\n");
! 579: goto reset;
! 580: }
! 581: if ((sist & (SIST1_STO << 8)) && need_reset == 0) {
! 582: /* selection time out, assume there's no device here */
! 583: if (siop_cmd) {
! 584: siop_cmd->cmd_c.status = CMDST_DONE;
! 585: xs->error = XS_SELTIMEOUT;
! 586: freetarget = 1;
! 587: goto end;
! 588: } else {
! 589: printf("%s: selection timeout without "
! 590: "command\n", sc->sc_c.sc_dev.dv_xname);
! 591: need_reset = 1;
! 592: }
! 593: }
! 594: if (sist & SIST0_UDC) {
! 595: /*
! 596: * unexpected disconnect. Usually the target signals
! 597: * a fatal condition this way. Attempt to get sense.
! 598: */
! 599: if (siop_cmd) {
! 600: siop_cmd->cmd_tables->status =
! 601: siop_htoc32(&sc->sc_c, SCSI_CHECK);
! 602: goto end;
! 603: }
! 604: printf("%s: unexpected disconnect without "
! 605: "command\n", sc->sc_c.sc_dev.dv_xname);
! 606: goto reset;
! 607: }
! 608: if (sist & (SIST1_SBMC << 8)) {
! 609: /* SCSI bus mode change */
! 610: if (siop_modechange(&sc->sc_c) == 0 || need_reset == 1)
! 611: goto reset;
! 612: if ((istat & ISTAT_DIP) && (dstat & DSTAT_SIR)) {
! 613: /*
! 614: * we have a script interrupt, it will
! 615: * restart the script.
! 616: */
! 617: goto scintr;
! 618: }
! 619: /*
! 620: * else we have to restart it ourselve, at the
! 621: * interrupted instruction.
! 622: */
! 623: bus_space_write_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 624: SIOP_DSP,
! 625: bus_space_read_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 626: SIOP_DSP) - 8);
! 627: return 1;
! 628: }
! 629: /* Else it's an unhandled exception (for now). */
! 630: printf("%s: unhandled scsi interrupt, sist=0x%x sstat1=0x%x "
! 631: "DSA=0x%x DSP=0x%x\n", sc->sc_c.sc_dev.dv_xname,
! 632: sist, sstat1,
! 633: bus_space_read_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh, SIOP_DSA),
! 634: (int)(bus_space_read_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 635: SIOP_DSP) - sc->sc_c.sc_scriptaddr));
! 636: if (siop_cmd) {
! 637: siop_cmd->cmd_c.status = CMDST_DONE;
! 638: xs->error = XS_SELTIMEOUT;
! 639: goto end;
! 640: }
! 641: need_reset = 1;
! 642: }
! 643: if (need_reset) {
! 644: reset:
! 645: /* fatal error, reset the bus */
! 646: siop_resetbus(&sc->sc_c);
! 647: /* no table to flush here */
! 648: return 1;
! 649: }
! 650:
! 651: scintr:
! 652: if ((istat & ISTAT_DIP) && (dstat & DSTAT_SIR)) { /* script interrupt */
! 653: irqcode = bus_space_read_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 654: SIOP_DSPS);
! 655: #ifdef SIOP_DEBUG_INTR
! 656: printf("script interrupt 0x%x\n", irqcode);
! 657: #endif
! 658: /*
! 659: * no command, or an inactive command is only valid for a
! 660: * reselect interrupt
! 661: */
! 662: if ((irqcode & 0x80) == 0) {
! 663: if (siop_cmd == NULL) {
! 664: printf(
! 665: "%s: script interrupt (0x%x) with invalid DSA !!!\n",
! 666: sc->sc_c.sc_dev.dv_xname, irqcode);
! 667: goto reset;
! 668: }
! 669: if (siop_cmd->cmd_c.status != CMDST_ACTIVE &&
! 670: siop_cmd->cmd_c.status != CMDST_SENSE_ACTIVE) {
! 671: printf("%s: command with invalid status "
! 672: "(IRQ code 0x%x current status %d) !\n",
! 673: sc->sc_c.sc_dev.dv_xname,
! 674: irqcode, siop_cmd->cmd_c.status);
! 675: xs = NULL;
! 676: }
! 677: }
! 678: switch(irqcode) {
! 679: case A_int_err:
! 680: printf("error, DSP=0x%x\n",
! 681: (int)(bus_space_read_4(sc->sc_c.sc_rt,
! 682: sc->sc_c.sc_rh, SIOP_DSP) - sc->sc_c.sc_scriptaddr));
! 683: if (xs) {
! 684: xs->error = XS_SELTIMEOUT;
! 685: goto end;
! 686: } else {
! 687: goto reset;
! 688: }
! 689: case A_int_reseltarg:
! 690: printf("%s: reselect with invalid target\n",
! 691: sc->sc_c.sc_dev.dv_xname);
! 692: goto reset;
! 693: case A_int_resellun:
! 694: INCSTAT(siop_stat_intr_lunresel);
! 695: target = bus_space_read_1(sc->sc_c.sc_rt,
! 696: sc->sc_c.sc_rh, SIOP_SCRATCHA) & 0xf;
! 697: lun = bus_space_read_1(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 698: SIOP_SCRATCHA + 1);
! 699: tag = bus_space_read_1(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 700: SIOP_SCRATCHA + 2);
! 701: siop_target =
! 702: (struct siop_target *)sc->sc_c.targets[target];
! 703: if (siop_target == NULL) {
! 704: printf("%s: reselect with invalid target %d\n",
! 705: sc->sc_c.sc_dev.dv_xname, target);
! 706: goto reset;
! 707: }
! 708: siop_lun = siop_target->siop_lun[lun];
! 709: if (siop_lun == NULL) {
! 710: printf("%s: target %d reselect with invalid "
! 711: "lun %d\n", sc->sc_c.sc_dev.dv_xname,
! 712: target, lun);
! 713: goto reset;
! 714: }
! 715: if (siop_lun->siop_tag[tag].active == NULL) {
! 716: printf("%s: target %d lun %d tag %d reselect "
! 717: "without command\n",
! 718: sc->sc_c.sc_dev.dv_xname,
! 719: target, lun, tag);
! 720: goto reset;
! 721: }
! 722: siop_cmd = siop_lun->siop_tag[tag].active;
! 723: bus_space_write_4(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 724: SIOP_DSP, siop_cmd->cmd_c.dsa +
! 725: sizeof(struct siop_common_xfer) +
! 726: Ent_ldsa_reload_dsa);
! 727: siop_table_sync(siop_cmd, BUS_DMASYNC_PREWRITE);
! 728: return 1;
! 729: case A_int_reseltag:
! 730: printf("%s: reselect with invalid tag\n",
! 731: sc->sc_c.sc_dev.dv_xname);
! 732: goto reset;
! 733: case A_int_msgin:
! 734: {
! 735: int msgin = bus_space_read_1(sc->sc_c.sc_rt,
! 736: sc->sc_c.sc_rh, SIOP_SFBR);
! 737: if (msgin == MSG_MESSAGE_REJECT) {
! 738: int msg, extmsg;
! 739: if (siop_cmd->cmd_tables->msg_out[0] & 0x80) {
! 740: /*
! 741: * message was part of a identify +
! 742: * something else. Identify shouldn't
! 743: * have been rejected.
! 744: */
! 745: msg =
! 746: siop_cmd->cmd_tables->msg_out[1];
! 747: extmsg =
! 748: siop_cmd->cmd_tables->msg_out[3];
! 749: } else {
! 750: msg = siop_cmd->cmd_tables->msg_out[0];
! 751: extmsg =
! 752: siop_cmd->cmd_tables->msg_out[2];
! 753: }
! 754: if (msg == MSG_MESSAGE_REJECT) {
! 755: /* MSG_REJECT for a MSG_REJECT !*/
! 756: if (xs)
! 757: sc_print_addr(xs->sc_link);
! 758: else
! 759: printf("%s: ",
! 760: sc->sc_c.sc_dev.dv_xname);
! 761: printf("our reject message was "
! 762: "rejected\n");
! 763: goto reset;
! 764: }
! 765: if (msg == MSG_EXTENDED &&
! 766: extmsg == MSG_EXT_WDTR) {
! 767: /* WDTR rejected, initiate sync */
! 768: if ((siop_target->target_c.flags &
! 769: TARF_SYNC) == 0) {
! 770: siop_target->target_c.status =
! 771: TARST_OK;
! 772: siop_update_xfer_mode(&sc->sc_c,
! 773: target);
! 774: /* no table to flush here */
! 775: CALL_SCRIPT(Ent_msgin_ack);
! 776: return 1;
! 777: }
! 778: siop_target->target_c.status =
! 779: TARST_SYNC_NEG;
! 780: siop_sdtr_msg(&siop_cmd->cmd_c, 0,
! 781: sc->sc_c.st_minsync,
! 782: sc->sc_c.maxoff);
! 783: siop_table_sync(siop_cmd,
! 784: BUS_DMASYNC_PREREAD |
! 785: BUS_DMASYNC_PREWRITE);
! 786: CALL_SCRIPT(Ent_send_msgout);
! 787: return 1;
! 788: } else if (msg == MSG_EXTENDED &&
! 789: extmsg == MSG_EXT_SDTR) {
! 790: /* sync rejected */
! 791: siop_target->target_c.offset = 0;
! 792: siop_target->target_c.period = 0;
! 793: siop_target->target_c.status = TARST_OK;
! 794: siop_update_xfer_mode(&sc->sc_c,
! 795: target);
! 796: /* no table to flush here */
! 797: CALL_SCRIPT(Ent_msgin_ack);
! 798: return 1;
! 799: } else if (msg == MSG_EXTENDED &&
! 800: extmsg == MSG_EXT_PPR) {
! 801: /* PPR negotiation rejected */
! 802: siop_target->target_c.offset = 0;
! 803: siop_target->target_c.period = 0;
! 804: siop_target->target_c.status = TARST_ASYNC;
! 805: siop_target->target_c.flags &= ~(TARF_DT | TARF_ISDT);
! 806: CALL_SCRIPT(Ent_msgin_ack);
! 807: return 1;
! 808: } else if (msg == MSG_SIMPLE_Q_TAG ||
! 809: msg == MSG_HEAD_OF_Q_TAG ||
! 810: msg == MSG_ORDERED_Q_TAG) {
! 811: if (siop_handle_qtag_reject(
! 812: siop_cmd) == -1)
! 813: goto reset;
! 814: CALL_SCRIPT(Ent_msgin_ack);
! 815: return 1;
! 816: }
! 817: if (xs)
! 818: sc_print_addr(xs->sc_link);
! 819: else
! 820: printf("%s: ",
! 821: sc->sc_c.sc_dev.dv_xname);
! 822: if (msg == MSG_EXTENDED) {
! 823: printf("scsi message reject, extended "
! 824: "message sent was 0x%x\n", extmsg);
! 825: } else {
! 826: printf("scsi message reject, message "
! 827: "sent was 0x%x\n", msg);
! 828: }
! 829: /* no table to flush here */
! 830: CALL_SCRIPT(Ent_msgin_ack);
! 831: return 1;
! 832: }
! 833: if (msgin == MSG_IGN_WIDE_RESIDUE) {
! 834: /* use the extmsgdata table to get the second byte */
! 835: siop_cmd->cmd_tables->t_extmsgdata.count =
! 836: siop_htoc32(&sc->sc_c, 1);
! 837: siop_table_sync(siop_cmd,
! 838: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 839: CALL_SCRIPT(Ent_get_extmsgdata);
! 840: return 1;
! 841: }
! 842: if (xs)
! 843: sc_print_addr(xs->sc_link);
! 844: else
! 845: printf("%s: ", sc->sc_c.sc_dev.dv_xname);
! 846: printf("unhandled message 0x%x\n",
! 847: siop_cmd->cmd_tables->msg_in[0]);
! 848: siop_cmd->cmd_tables->msg_out[0] = MSG_MESSAGE_REJECT;
! 849: siop_cmd->cmd_tables->t_msgout.count =
! 850: siop_htoc32(&sc->sc_c, 1);
! 851: siop_table_sync(siop_cmd,
! 852: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 853: CALL_SCRIPT(Ent_send_msgout);
! 854: return 1;
! 855: }
! 856: case A_int_extmsgin:
! 857: #ifdef SIOP_DEBUG_INTR
! 858: printf("extended message: msg 0x%x len %d\n",
! 859: siop_cmd->cmd_tables->msg_in[2],
! 860: siop_cmd->cmd_tables->msg_in[1]);
! 861: #endif
! 862: if (siop_cmd->cmd_tables->msg_in[1] >
! 863: sizeof(siop_cmd->cmd_tables->msg_in) - 2)
! 864: printf("%s: extended message too big (%d)\n",
! 865: sc->sc_c.sc_dev.dv_xname,
! 866: siop_cmd->cmd_tables->msg_in[1]);
! 867: siop_cmd->cmd_tables->t_extmsgdata.count =
! 868: siop_htoc32(&sc->sc_c,
! 869: siop_cmd->cmd_tables->msg_in[1] - 1);
! 870: siop_table_sync(siop_cmd,
! 871: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 872: CALL_SCRIPT(Ent_get_extmsgdata);
! 873: return 1;
! 874: case A_int_extmsgdata:
! 875: #ifdef SIOP_DEBUG_INTR
! 876: {
! 877: int i;
! 878: printf("extended message: 0x%x, data:",
! 879: siop_cmd->cmd_tables->msg_in[2]);
! 880: for (i = 3; i < 2 + siop_cmd->cmd_tables->msg_in[1];
! 881: i++)
! 882: printf(" 0x%x",
! 883: siop_cmd->cmd_tables->msg_in[i]);
! 884: printf("\n");
! 885: }
! 886: #endif
! 887: if (siop_cmd->cmd_tables->msg_in[0] ==
! 888: MSG_IGN_WIDE_RESIDUE) {
! 889: /* we got the second byte of MSG_IGN_WIDE_RESIDUE */
! 890: if (siop_cmd->cmd_tables->msg_in[3] != 1)
! 891: printf("MSG_IGN_WIDE_RESIDUE: "
! 892: "bad len %d\n",
! 893: siop_cmd->cmd_tables->msg_in[3]);
! 894: switch (siop_iwr(&siop_cmd->cmd_c)) {
! 895: case SIOP_NEG_MSGOUT:
! 896: siop_table_sync(siop_cmd,
! 897: BUS_DMASYNC_PREREAD |
! 898: BUS_DMASYNC_PREWRITE);
! 899: CALL_SCRIPT(Ent_send_msgout);
! 900: return(1);
! 901: case SIOP_NEG_ACK:
! 902: CALL_SCRIPT(Ent_msgin_ack);
! 903: return(1);
! 904: default:
! 905: panic("invalid retval from "
! 906: "siop_iwr()");
! 907: }
! 908: return(1);
! 909: }
! 910: if (siop_cmd->cmd_tables->msg_in[2] == MSG_EXT_WDTR) {
! 911: switch (siop_wdtr_neg(&siop_cmd->cmd_c)) {
! 912: case SIOP_NEG_MSGOUT:
! 913: siop_update_scntl3(sc,
! 914: siop_cmd->cmd_c.siop_target);
! 915: siop_table_sync(siop_cmd,
! 916: BUS_DMASYNC_PREREAD |
! 917: BUS_DMASYNC_PREWRITE);
! 918: CALL_SCRIPT(Ent_send_msgout);
! 919: return(1);
! 920: case SIOP_NEG_ACK:
! 921: siop_update_scntl3(sc,
! 922: siop_cmd->cmd_c.siop_target);
! 923: CALL_SCRIPT(Ent_msgin_ack);
! 924: return(1);
! 925: default:
! 926: panic("invalid retval from "
! 927: "siop_wdtr_neg()");
! 928: }
! 929: return(1);
! 930: }
! 931: if (siop_cmd->cmd_tables->msg_in[2] == MSG_EXT_SDTR) {
! 932: switch (siop_sdtr_neg(&siop_cmd->cmd_c)) {
! 933: case SIOP_NEG_MSGOUT:
! 934: siop_update_scntl3(sc,
! 935: siop_cmd->cmd_c.siop_target);
! 936: siop_table_sync(siop_cmd,
! 937: BUS_DMASYNC_PREREAD |
! 938: BUS_DMASYNC_PREWRITE);
! 939: CALL_SCRIPT(Ent_send_msgout);
! 940: return(1);
! 941: case SIOP_NEG_ACK:
! 942: siop_update_scntl3(sc,
! 943: siop_cmd->cmd_c.siop_target);
! 944: CALL_SCRIPT(Ent_msgin_ack);
! 945: return(1);
! 946: default:
! 947: panic("invalid retval from "
! 948: "siop_sdtr_neg()");
! 949: }
! 950: return(1);
! 951: }
! 952: if (siop_cmd->cmd_tables->msg_in[2] == MSG_EXT_PPR) {
! 953: switch (siop_ppr_neg(&siop_cmd->cmd_c)) {
! 954: case SIOP_NEG_MSGOUT:
! 955: siop_update_scntl3(sc,
! 956: siop_cmd->cmd_c.siop_target);
! 957: siop_table_sync(siop_cmd,
! 958: BUS_DMASYNC_PREREAD |
! 959: BUS_DMASYNC_PREWRITE);
! 960: CALL_SCRIPT(Ent_send_msgout);
! 961: return(1);
! 962: case SIOP_NEG_ACK:
! 963: siop_update_scntl3(sc,
! 964: siop_cmd->cmd_c.siop_target);
! 965: CALL_SCRIPT(Ent_msgin_ack);
! 966: return(1);
! 967: default:
! 968: panic("invalid retval from "
! 969: "siop_wdtr_neg()");
! 970: }
! 971: return(1);
! 972: }
! 973: /* send a message reject */
! 974: siop_cmd->cmd_tables->msg_out[0] = MSG_MESSAGE_REJECT;
! 975: siop_cmd->cmd_tables->t_msgout.count =
! 976: siop_htoc32(&sc->sc_c, 1);
! 977: siop_table_sync(siop_cmd,
! 978: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 979: CALL_SCRIPT(Ent_send_msgout);
! 980: return 1;
! 981: case A_int_disc:
! 982: INCSTAT(siop_stat_intr_sdp);
! 983: offset = bus_space_read_1(sc->sc_c.sc_rt,
! 984: sc->sc_c.sc_rh, SIOP_SCRATCHA + 1);
! 985: #ifdef SIOP_DEBUG_DR
! 986: printf("disconnect offset %d\n", offset);
! 987: #endif
! 988: siop_sdp(&siop_cmd->cmd_c, offset);
! 989: /* we start again with no offset */
! 990: siop_cmd->saved_offset = SIOP_NOOFFSET;
! 991: siop_table_sync(siop_cmd,
! 992: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 993: CALL_SCRIPT(Ent_script_sched);
! 994: return 1;
! 995: case A_int_saveoffset:
! 996: INCSTAT(siop_stat_intr_saveoffset);
! 997: offset = bus_space_read_1(sc->sc_c.sc_rt,
! 998: sc->sc_c.sc_rh, SIOP_SCRATCHA + 1);
! 999: #ifdef SIOP_DEBUG_DR
! 1000: printf("saveoffset offset %d\n", offset);
! 1001: #endif
! 1002: siop_cmd->saved_offset = offset;
! 1003: CALL_SCRIPT(Ent_script_sched);
! 1004: return 1;
! 1005: case A_int_resfail:
! 1006: printf("reselect failed\n");
! 1007: /* check if we can put some command in scheduler */
! 1008: siop_start(sc);
! 1009: CALL_SCRIPT(Ent_script_sched);
! 1010: return 1;
! 1011: case A_int_done:
! 1012: if (xs == NULL) {
! 1013: printf("%s: done without command, DSA=0x%lx\n",
! 1014: sc->sc_c.sc_dev.dv_xname,
! 1015: (u_long)siop_cmd->cmd_c.dsa);
! 1016: siop_cmd->cmd_c.status = CMDST_FREE;
! 1017: siop_start(sc);
! 1018: CALL_SCRIPT(Ent_script_sched);
! 1019: return 1;
! 1020: }
! 1021: #ifdef SIOP_DEBUG_INTR
! 1022: printf("done, DSA=0x%lx target id 0x%x last msg "
! 1023: "in=0x%x status=0x%x\n", (u_long)siop_cmd->cmd_c.dsa,
! 1024: siop_ctoh32(&sc->sc_c, siop_cmd->cmd_tables->id),
! 1025: siop_cmd->cmd_tables->msg_in[0],
! 1026: siop_ctoh32(&sc->sc_c,
! 1027: siop_cmd->cmd_tables->status));
! 1028: #endif
! 1029: INCSTAT(siop_stat_intr_done);
! 1030: /* update resid. */
! 1031: offset = bus_space_read_1(sc->sc_c.sc_rt,
! 1032: sc->sc_c.sc_rh, SIOP_SCRATCHA + 1);
! 1033: /*
! 1034: * if we got a disconnect between the last data phase
! 1035: * and the status phase, offset will be 0. In this
! 1036: * case, siop_cmd->saved_offset will have the proper
! 1037: * value if it got updated by the controller
! 1038: */
! 1039: if (offset == 0 &&
! 1040: siop_cmd->saved_offset != SIOP_NOOFFSET)
! 1041: offset = siop_cmd->saved_offset;
! 1042: siop_update_resid(&siop_cmd->cmd_c, offset);
! 1043: if (siop_cmd->cmd_c.status == CMDST_SENSE_ACTIVE)
! 1044: siop_cmd->cmd_c.status = CMDST_SENSE_DONE;
! 1045: else
! 1046: siop_cmd->cmd_c.status = CMDST_DONE;
! 1047: goto end;
! 1048: default:
! 1049: printf("unknown irqcode %x\n", irqcode);
! 1050: if (xs) {
! 1051: xs->error = XS_SELTIMEOUT;
! 1052: goto end;
! 1053: }
! 1054: goto reset;
! 1055: }
! 1056: return 1;
! 1057: }
! 1058: /* We can get here if ISTAT_DIP and DSTAT_DFE are the only bits set. */
! 1059: /* But that *SHOULDN'T* happen. It does on powerpc (at least). */
! 1060: printf("%s: siop_intr() - we should not be here!\n"
! 1061: " istat = 0x%x, dstat = 0x%x, sist = 0x%x, sstat1 = 0x%x\n"
! 1062: " need_reset = %x, irqcode = %x, siop_cmd %s\n",
! 1063: sc->sc_c.sc_dev.dv_xname,
! 1064: istat, dstat, sist, sstat1, need_reset, irqcode,
! 1065: (siop_cmd == NULL) ? "== NULL" : "!= NULL");
! 1066: goto reset; /* Where we should have gone in the first place! */
! 1067: end:
! 1068: /*
! 1069: * restart the script now if command completed properly
! 1070: * Otherwise wait for siop_scsicmd_end(), we may need to cleanup the
! 1071: * queue
! 1072: */
! 1073: xs->status = siop_ctoh32(&sc->sc_c, siop_cmd->cmd_tables->status);
! 1074: if (xs->status == SCSI_OK)
! 1075: CALL_SCRIPT(Ent_script_sched);
! 1076: else
! 1077: restart = 1;
! 1078: siop_lun->siop_tag[tag].active = NULL;
! 1079: siop_scsicmd_end(siop_cmd);
! 1080: if (freetarget && siop_target->target_c.status == TARST_PROBING)
! 1081: siop_del_dev(sc, target, lun);
! 1082: siop_start(sc);
! 1083: if (restart)
! 1084: CALL_SCRIPT(Ent_script_sched);
! 1085: return 1;
! 1086: }
! 1087:
! 1088: void
! 1089: siop_scsicmd_end(siop_cmd)
! 1090: struct siop_cmd *siop_cmd;
! 1091: {
! 1092: struct scsi_xfer *xs = siop_cmd->cmd_c.xs;
! 1093: struct siop_softc *sc = (struct siop_softc *)siop_cmd->cmd_c.siop_sc;
! 1094: struct siop_lun *siop_lun =
! 1095: ((struct siop_target*)sc->sc_c.targets[xs->sc_link->target])->siop_lun[xs->sc_link->lun];
! 1096:
! 1097: /*
! 1098: * If the command is re-queued (SENSE, QUEUE_FULL) it
! 1099: * must get a new timeout, so delete existing timeout now.
! 1100: */
! 1101: timeout_del(&siop_cmd->cmd_c.xs->stimeout);
! 1102:
! 1103: switch(xs->status) {
! 1104: case SCSI_OK:
! 1105: xs->error = (siop_cmd->cmd_c.status == CMDST_DONE) ?
! 1106: XS_NOERROR : XS_SENSE;
! 1107: break;
! 1108: case SCSI_BUSY:
! 1109: xs->error = XS_BUSY;
! 1110: break;
! 1111: case SCSI_CHECK:
! 1112: if (siop_cmd->cmd_c.status == CMDST_SENSE_DONE) {
! 1113: /* request sense on a request sense ? */
! 1114: printf("%s: request sense failed\n",
! 1115: sc->sc_c.sc_dev.dv_xname);
! 1116: xs->error = XS_DRIVER_STUFFUP;
! 1117: } else {
! 1118: siop_cmd->cmd_c.status = CMDST_SENSE;
! 1119: }
! 1120: break;
! 1121: case SCSI_QUEUE_FULL:
! 1122: /*
! 1123: * Device didn't queue the command. We have to retry
! 1124: * it. We insert it into the urgent list, hoping to
! 1125: * preserve order. But unfortunately, commands already
! 1126: * in the scheduler may be accepted before this one.
! 1127: * Also remember the condition, to avoid starting new
! 1128: * commands for this device before one is done.
! 1129: */
! 1130: INCSTAT(siop_stat_intr_qfull);
! 1131: #ifdef SIOP_DEBUG
! 1132: printf("%s:%d:%d: queue full (tag %d)\n", sc->sc_c.sc_dev.dv_xname,
! 1133: xs->sc_link->target,
! 1134: xs->sc_link->lun, siop_cmd->cmd_c.tag);
! 1135: #endif
! 1136: siop_lun->lun_flags |= SIOP_LUNF_FULL;
! 1137: siop_cmd->cmd_c.status = CMDST_READY;
! 1138: siop_setuptables(&siop_cmd->cmd_c);
! 1139: siop_table_sync(siop_cmd, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 1140: TAILQ_INSERT_TAIL(&sc->urgent_list, siop_cmd, next);
! 1141: return;
! 1142: case SCSI_SIOP_NOCHECK:
! 1143: /*
! 1144: * don't check status, xs->error is already valid
! 1145: */
! 1146: break;
! 1147: case SCSI_SIOP_NOSTATUS:
! 1148: /*
! 1149: * the status byte was not updated, cmd was
! 1150: * aborted
! 1151: */
! 1152: xs->error = XS_SELTIMEOUT;
! 1153: break;
! 1154: default:
! 1155: xs->error = XS_DRIVER_STUFFUP;
! 1156: }
! 1157: if (siop_cmd->cmd_c.status != CMDST_SENSE_DONE &&
! 1158: xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
! 1159: bus_dmamap_sync(sc->sc_c.sc_dmat, siop_cmd->cmd_c.dmamap_data, 0,
! 1160: siop_cmd->cmd_c.dmamap_data->dm_mapsize,
! 1161: (xs->flags & SCSI_DATA_IN) ?
! 1162: BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
! 1163: bus_dmamap_unload(sc->sc_c.sc_dmat, siop_cmd->cmd_c.dmamap_data);
! 1164: }
! 1165: if (siop_cmd->cmd_c.status == CMDST_SENSE) {
! 1166: /* issue a request sense for this target */
! 1167: struct scsi_sense *cmd = (struct scsi_sense *)&siop_cmd->cmd_c.siop_tables->xscmd;
! 1168: int error;
! 1169: bzero(cmd, sizeof(*cmd));
! 1170: siop_cmd->cmd_c.siop_tables->cmd.count =
! 1171: siop_htoc32(&sc->sc_c, sizeof(struct scsi_sense));
! 1172: cmd->opcode = REQUEST_SENSE;
! 1173: cmd->byte2 = xs->sc_link->lun << 5;
! 1174: cmd->unused[0] = cmd->unused[1] = 0;
! 1175: cmd->length = sizeof(struct scsi_sense_data);
! 1176: cmd->control = 0;
! 1177: siop_cmd->cmd_c.flags &= ~CMDFL_TAG;
! 1178: error = bus_dmamap_load(sc->sc_c.sc_dmat, siop_cmd->cmd_c.dmamap_data,
! 1179: &xs->sense, sizeof(struct scsi_sense_data),
! 1180: NULL, BUS_DMA_NOWAIT);
! 1181: if (error) {
! 1182: printf("%s: unable to load data DMA map "
! 1183: "(for SENSE): %d\n",
! 1184: sc->sc_c.sc_dev.dv_xname, error);
! 1185: xs->error = XS_DRIVER_STUFFUP;
! 1186: goto out;
! 1187: }
! 1188: bus_dmamap_sync(sc->sc_c.sc_dmat, siop_cmd->cmd_c.dmamap_data,
! 1189: 0, siop_cmd->cmd_c.dmamap_data->dm_mapsize,
! 1190: BUS_DMASYNC_PREREAD);
! 1191:
! 1192: siop_setuptables(&siop_cmd->cmd_c);
! 1193: siop_table_sync(siop_cmd, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 1194: /* arrange for the cmd to be handled now */
! 1195: TAILQ_INSERT_HEAD(&sc->urgent_list, siop_cmd, next);
! 1196: return;
! 1197: } else if (siop_cmd->cmd_c.status == CMDST_SENSE_DONE) {
! 1198: bus_dmamap_sync(sc->sc_c.sc_dmat, siop_cmd->cmd_c.dmamap_data,
! 1199: 0, siop_cmd->cmd_c.dmamap_data->dm_mapsize,
! 1200: BUS_DMASYNC_POSTREAD);
! 1201: bus_dmamap_unload(sc->sc_c.sc_dmat, siop_cmd->cmd_c.dmamap_data);
! 1202: }
! 1203: out:
! 1204: siop_lun->lun_flags &= ~SIOP_LUNF_FULL;
! 1205: xs->flags |= ITSDONE;
! 1206: siop_cmd->cmd_c.status = CMDST_FREE;
! 1207: TAILQ_INSERT_TAIL(&sc->free_list, siop_cmd, next);
! 1208: #if 0
! 1209: if (xs->resid != 0)
! 1210: printf("resid %d datalen %d\n", xs->resid, xs->datalen);
! 1211: #endif
! 1212: scsi_done(xs);
! 1213: }
! 1214:
! 1215: /*
! 1216: * handle a rejected queue tag message: the command will run untagged,
! 1217: * has to adjust the reselect script.
! 1218: */
! 1219: int
! 1220: siop_handle_qtag_reject(siop_cmd)
! 1221: struct siop_cmd *siop_cmd;
! 1222: {
! 1223: struct siop_softc *sc = (struct siop_softc *)siop_cmd->cmd_c.siop_sc;
! 1224: int target = siop_cmd->cmd_c.xs->sc_link->target;
! 1225: int lun = siop_cmd->cmd_c.xs->sc_link->lun;
! 1226: int tag = siop_cmd->cmd_tables->msg_out[2];
! 1227: struct siop_lun *siop_lun =
! 1228: ((struct siop_target*)sc->sc_c.targets[target])->siop_lun[lun];
! 1229:
! 1230: #ifdef SIOP_DEBUG
! 1231: printf("%s:%d:%d: tag message %d (%d) rejected (status %d)\n",
! 1232: sc->sc_c.sc_dev.dv_xname, target, lun, tag, siop_cmd->cmd_c.tag,
! 1233: siop_cmd->cmd_c.status);
! 1234: #endif
! 1235:
! 1236: if (siop_lun->siop_tag[0].active != NULL) {
! 1237: printf("%s: untagged command already running for target %d "
! 1238: "lun %d (status %d)\n", sc->sc_c.sc_dev.dv_xname,
! 1239: target, lun, siop_lun->siop_tag[0].active->cmd_c.status);
! 1240: return -1;
! 1241: }
! 1242: /* clear tag slot */
! 1243: siop_lun->siop_tag[tag].active = NULL;
! 1244: /* add command to non-tagged slot */
! 1245: siop_lun->siop_tag[0].active = siop_cmd;
! 1246: siop_cmd->cmd_c.tag = 0;
! 1247: /* adjust reselect script if there is one */
! 1248: if (siop_lun->siop_tag[0].reseloff > 0) {
! 1249: siop_script_write(sc,
! 1250: siop_lun->siop_tag[0].reseloff + 1,
! 1251: siop_cmd->cmd_c.dsa + sizeof(struct siop_common_xfer) +
! 1252: Ent_ldsa_reload_dsa);
! 1253: siop_table_sync(siop_cmd, BUS_DMASYNC_PREWRITE);
! 1254: }
! 1255: return 0;
! 1256: }
! 1257:
! 1258: /*
! 1259: * handle a bus reset: reset chip, unqueue all active commands, free all
! 1260: * target struct and report lossage to upper layer.
! 1261: * As the upper layer may requeue immediately we have to first store
! 1262: * all active commands in a temporary queue.
! 1263: */
! 1264: void
! 1265: siop_handle_reset(sc)
! 1266: struct siop_softc *sc;
! 1267: {
! 1268: struct cmd_list reset_list;
! 1269: struct siop_cmd *siop_cmd, *next_siop_cmd;
! 1270: struct siop_lun *siop_lun;
! 1271: int target, lun, tag;
! 1272: /*
! 1273: * scsi bus reset. reset the chip and restart
! 1274: * the queue. Need to clean up all active commands
! 1275: */
! 1276: printf("%s: scsi bus reset\n", sc->sc_c.sc_dev.dv_xname);
! 1277: /* stop, reset and restart the chip */
! 1278: siop_reset(sc);
! 1279: TAILQ_INIT(&reset_list);
! 1280: /*
! 1281: * Process all commands: first commands being executed
! 1282: */
! 1283: for (target = 0; target < sc->sc_c.sc_link.adapter_buswidth;
! 1284: target++) {
! 1285: if (sc->sc_c.targets[target] == NULL)
! 1286: continue;
! 1287: for (lun = 0; lun < 8; lun++) {
! 1288: struct siop_target *siop_target =
! 1289: (struct siop_target *)sc->sc_c.targets[target];
! 1290: siop_lun = siop_target->siop_lun[lun];
! 1291: if (siop_lun == NULL)
! 1292: continue;
! 1293: siop_lun->lun_flags &= ~SIOP_LUNF_FULL;
! 1294: for (tag = 0; tag <
! 1295: ((sc->sc_c.targets[target]->flags & TARF_TAG) ?
! 1296: SIOP_NTAG : 1);
! 1297: tag++) {
! 1298: siop_cmd = siop_lun->siop_tag[tag].active;
! 1299: if (siop_cmd == NULL)
! 1300: continue;
! 1301: siop_lun->siop_tag[tag].active = NULL;
! 1302: TAILQ_INSERT_TAIL(&reset_list, siop_cmd, next);
! 1303: sc_print_addr(siop_cmd->cmd_c.xs->sc_link);
! 1304: printf("cmd %p (tag %d) added to reset list\n",
! 1305: siop_cmd, tag);
! 1306: }
! 1307: }
! 1308: if (sc->sc_c.targets[target]->status != TARST_PROBING) {
! 1309: sc->sc_c.targets[target]->status = TARST_ASYNC;
! 1310: sc->sc_c.targets[target]->flags &= ~TARF_ISWIDE;
! 1311: sc->sc_c.targets[target]->period =
! 1312: sc->sc_c.targets[target]->offset = 0;
! 1313: siop_update_xfer_mode(&sc->sc_c, target);
! 1314: }
! 1315: }
! 1316: /* Next commands from the urgent list */
! 1317: for (siop_cmd = TAILQ_FIRST(&sc->urgent_list); siop_cmd != NULL;
! 1318: siop_cmd = next_siop_cmd) {
! 1319: next_siop_cmd = TAILQ_NEXT(siop_cmd, next);
! 1320: TAILQ_REMOVE(&sc->urgent_list, siop_cmd, next);
! 1321: TAILQ_INSERT_TAIL(&reset_list, siop_cmd, next);
! 1322: sc_print_addr(siop_cmd->cmd_c.xs->sc_link);
! 1323: printf("cmd %p added to reset list from urgent list\n",
! 1324: siop_cmd);
! 1325: }
! 1326: /* Then commands waiting in the input list. */
! 1327: for (siop_cmd = TAILQ_FIRST(&sc->ready_list); siop_cmd != NULL;
! 1328: siop_cmd = next_siop_cmd) {
! 1329: next_siop_cmd = TAILQ_NEXT(siop_cmd, next);
! 1330: TAILQ_REMOVE(&sc->ready_list, siop_cmd, next);
! 1331: TAILQ_INSERT_TAIL(&reset_list, siop_cmd, next);
! 1332: sc_print_addr(siop_cmd->cmd_c.xs->sc_link);
! 1333: printf("cmd %p added to reset list from ready list\n",
! 1334: siop_cmd);
! 1335: }
! 1336:
! 1337: for (siop_cmd = TAILQ_FIRST(&reset_list); siop_cmd != NULL;
! 1338: siop_cmd = next_siop_cmd) {
! 1339: next_siop_cmd = TAILQ_NEXT(siop_cmd, next);
! 1340: siop_cmd->cmd_c.flags &= ~CMDFL_TAG;
! 1341: siop_cmd->cmd_c.xs->error =
! 1342: (siop_cmd->cmd_c.flags & CMDFL_TIMEOUT)
! 1343: ? XS_TIMEOUT : XS_RESET;
! 1344: siop_cmd->cmd_c.xs->status = SCSI_SIOP_NOCHECK;
! 1345: sc_print_addr(siop_cmd->cmd_c.xs->sc_link);
! 1346: printf("cmd %p (status %d) reset",
! 1347: siop_cmd, siop_cmd->cmd_c.status);
! 1348: if (siop_cmd->cmd_c.status == CMDST_SENSE ||
! 1349: siop_cmd->cmd_c.status == CMDST_SENSE_ACTIVE)
! 1350: siop_cmd->cmd_c.status = CMDST_SENSE_DONE;
! 1351: else
! 1352: siop_cmd->cmd_c.status = CMDST_DONE;
! 1353: printf(" with status %d, xs->error %d\n",
! 1354: siop_cmd->cmd_c.status, siop_cmd->cmd_c.xs->error);
! 1355: TAILQ_REMOVE(&reset_list, siop_cmd, next);
! 1356: siop_scsicmd_end(siop_cmd);
! 1357: }
! 1358: }
! 1359:
! 1360: int
! 1361: siop_scsicmd(xs)
! 1362: struct scsi_xfer *xs;
! 1363: {
! 1364: struct siop_softc *sc = (struct siop_softc *)xs->sc_link->adapter_softc;
! 1365: struct siop_cmd *siop_cmd;
! 1366: struct siop_target *siop_target;
! 1367: int s, error, i, j;
! 1368: const int target = xs->sc_link->target;
! 1369: const int lun = xs->sc_link->lun;
! 1370:
! 1371: s = splbio();
! 1372: #ifdef SIOP_DEBUG_SCHED
! 1373: printf("starting cmd for %d:%d\n", target, lun);
! 1374: #endif
! 1375: siop_cmd = TAILQ_FIRST(&sc->free_list);
! 1376: if (siop_cmd == NULL) {
! 1377: splx(s);
! 1378: return(TRY_AGAIN_LATER);
! 1379: }
! 1380: TAILQ_REMOVE(&sc->free_list, siop_cmd, next);
! 1381:
! 1382: /* Always reset xs->stimeout, lest we timeout_del() with trash */
! 1383: timeout_set(&xs->stimeout, siop_timeout, siop_cmd);
! 1384:
! 1385: #ifdef DIAGNOSTIC
! 1386: if (siop_cmd->cmd_c.status != CMDST_FREE)
! 1387: panic("siop_scsicmd: new cmd not free");
! 1388: #endif
! 1389: siop_target = (struct siop_target*)sc->sc_c.targets[target];
! 1390: if (siop_target == NULL) {
! 1391: #ifdef SIOP_DEBUG
! 1392: printf("%s: alloc siop_target for target %d\n",
! 1393: sc->sc_c.sc_dev.dv_xname, target);
! 1394: #endif
! 1395: sc->sc_c.targets[target] =
! 1396: malloc(sizeof(struct siop_target),
! 1397: M_DEVBUF, M_NOWAIT);
! 1398: if (sc->sc_c.targets[target] == NULL) {
! 1399: printf("%s: can't malloc memory for "
! 1400: "target %d\n", sc->sc_c.sc_dev.dv_xname,
! 1401: target);
! 1402: splx(s);
! 1403: return(TRY_AGAIN_LATER);
! 1404: }
! 1405: bzero(sc->sc_c.targets[target], sizeof(struct siop_target));
! 1406: siop_target =
! 1407: (struct siop_target*)sc->sc_c.targets[target];
! 1408: siop_target->target_c.status = TARST_PROBING;
! 1409: siop_target->target_c.flags = 0;
! 1410: siop_target->target_c.id =
! 1411: sc->sc_c.clock_div << 24; /* scntl3 */
! 1412: siop_target->target_c.id |= target << 16; /* id */
! 1413: /* siop_target->target_c.id |= 0x0 << 8; scxfer is 0 */
! 1414:
! 1415: /* get a lun switch script */
! 1416: siop_target->lunsw = siop_get_lunsw(sc);
! 1417: if (siop_target->lunsw == NULL) {
! 1418: printf("%s: can't alloc lunsw for target %d\n",
! 1419: sc->sc_c.sc_dev.dv_xname, target);
! 1420: splx(s);
! 1421: return(TRY_AGAIN_LATER);
! 1422: }
! 1423: for (i=0; i < 8; i++)
! 1424: siop_target->siop_lun[i] = NULL;
! 1425: siop_add_reselsw(sc, target);
! 1426: }
! 1427: if (siop_target->siop_lun[lun] == NULL) {
! 1428: siop_target->siop_lun[lun] =
! 1429: malloc(sizeof(struct siop_lun), M_DEVBUF,
! 1430: M_NOWAIT);
! 1431: if (siop_target->siop_lun[lun] == NULL) {
! 1432: printf("%s: can't alloc siop_lun for "
! 1433: "target %d lun %d\n",
! 1434: sc->sc_c.sc_dev.dv_xname, target, lun);
! 1435: splx(s);
! 1436: return(TRY_AGAIN_LATER);
! 1437: }
! 1438: bzero(siop_target->siop_lun[lun], sizeof(struct siop_lun));
! 1439: }
! 1440: siop_cmd->cmd_c.siop_target = sc->sc_c.targets[target];
! 1441: siop_cmd->cmd_c.xs = xs;
! 1442: siop_cmd->cmd_c.flags = 0;
! 1443: siop_cmd->cmd_c.status = CMDST_READY;
! 1444:
! 1445: bzero(&siop_cmd->cmd_c.siop_tables->xscmd,
! 1446: sizeof(siop_cmd->cmd_c.siop_tables->xscmd));
! 1447: bcopy(xs->cmd, &siop_cmd->cmd_c.siop_tables->xscmd, xs->cmdlen);
! 1448: siop_cmd->cmd_c.siop_tables->cmd.count =
! 1449: siop_htoc32(&sc->sc_c, xs->cmdlen);
! 1450:
! 1451: /* load the DMA maps */
! 1452: if (xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
! 1453: error = bus_dmamap_load(sc->sc_c.sc_dmat,
! 1454: siop_cmd->cmd_c.dmamap_data, xs->data, xs->datalen,
! 1455: NULL, BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
! 1456: ((xs->flags & SCSI_DATA_IN) ?
! 1457: BUS_DMA_READ : BUS_DMA_WRITE));
! 1458: if (error) {
! 1459: printf("%s: unable to load data DMA map: %d\n",
! 1460: sc->sc_c.sc_dev.dv_xname, error);
! 1461: splx(s);
! 1462: return(TRY_AGAIN_LATER);
! 1463: }
! 1464: bus_dmamap_sync(sc->sc_c.sc_dmat,
! 1465: siop_cmd->cmd_c.dmamap_data, 0,
! 1466: siop_cmd->cmd_c.dmamap_data->dm_mapsize,
! 1467: (xs->flags & SCSI_DATA_IN) ?
! 1468: BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
! 1469: }
! 1470:
! 1471: siop_setuptables(&siop_cmd->cmd_c);
! 1472: siop_cmd->saved_offset = SIOP_NOOFFSET;
! 1473: siop_table_sync(siop_cmd,
! 1474: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 1475:
! 1476: TAILQ_INSERT_TAIL(&sc->ready_list, siop_cmd, next);
! 1477:
! 1478: /* Negotiate transfer parameters on first non-polling command. */
! 1479: if (((xs->flags & SCSI_POLL) == 0) &&
! 1480: siop_target->target_c.status == TARST_PROBING)
! 1481: siop_target->target_c.status = TARST_ASYNC;
! 1482:
! 1483: siop_start(sc);
! 1484: if ((xs->flags & SCSI_POLL) == 0) {
! 1485: splx(s);
! 1486: return (SUCCESSFULLY_QUEUED);
! 1487: }
! 1488:
! 1489: /* Poll for command completion. */
! 1490: for(i = xs->timeout; i > 0; i--) {
! 1491: siop_intr(sc);
! 1492: if ((xs->flags & ITSDONE) == 0) {
! 1493: delay(1000);
! 1494: continue;
! 1495: }
! 1496: if (xs->cmd->opcode == INQUIRY && xs->error == XS_NOERROR) {
! 1497: struct scsi_inquiry_data *inqbuf =
! 1498: (struct scsi_inquiry_data *)xs->data;
! 1499: if ((inqbuf->device & SID_QUAL) == SID_QUAL_BAD_LU)
! 1500: break;
! 1501: /*
! 1502: * Allocate cbd's to hold maximum openings worth of
! 1503: * commands. Do this now because doing it dynamically in
! 1504: * siop_startcmd may cause calls to bus_dma* functions
! 1505: * in interrupt context.
! 1506: */
! 1507: for (j = 0; j < SIOP_NTAG; j += SIOP_NCMDPB)
! 1508: siop_morecbd(sc);
! 1509:
! 1510: /*
! 1511: * Set TARF_DT here because if it is turned off during
! 1512: * PPR, it must STAY off!
! 1513: */
! 1514: if ((lun == 0) && (sc->sc_c.features & SF_BUS_ULTRA3))
! 1515: sc->sc_c.targets[target]->flags |= TARF_DT;
! 1516: /*
! 1517: * Can't do lun 0 here, because flags are not set yet.
! 1518: * But have to do other lun's here because they never go
! 1519: * through TARST_ASYNC.
! 1520: */
! 1521: if (lun > 0)
! 1522: siop_add_dev(sc, target, lun);
! 1523: }
! 1524: break;
! 1525: }
! 1526: if (i == 0) {
! 1527: siop_timeout(siop_cmd);
! 1528: while ((xs->flags & ITSDONE) == 0)
! 1529: siop_intr(sc);
! 1530: }
! 1531:
! 1532: splx(s);
! 1533: return (COMPLETE);
! 1534: }
! 1535:
! 1536: void
! 1537: siop_start(sc)
! 1538: struct siop_softc *sc;
! 1539: {
! 1540: struct siop_cmd *siop_cmd, *next_siop_cmd;
! 1541: struct siop_lun *siop_lun;
! 1542: struct siop_xfer *siop_xfer;
! 1543: u_int32_t dsa;
! 1544: int timeout;
! 1545: int target, lun, tag, slot;
! 1546: int newcmd = 0;
! 1547: int doingready = 0;
! 1548:
! 1549: /*
! 1550: * first make sure to read valid data
! 1551: */
! 1552: siop_script_sync(sc, BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
! 1553:
! 1554: /*
! 1555: * The queue management here is a bit tricky: the script always looks
! 1556: * at the slot from first to last, so if we always use the first
! 1557: * free slot commands can stay at the tail of the queue ~forever.
! 1558: * The algorithm used here is to restart from the head when we know
! 1559: * that the queue is empty, and only add commands after the last one.
! 1560: * When we're at the end of the queue wait for the script to clear it.
! 1561: * The best thing to do here would be to implement a circular queue,
! 1562: * but using only 53c720 features this can be "interesting".
! 1563: * A mid-way solution could be to implement 2 queues and swap orders.
! 1564: */
! 1565: slot = sc->sc_currschedslot;
! 1566: /*
! 1567: * If the instruction is 0x80000000 (JUMP foo, IF FALSE) the slot is
! 1568: * free. As this is the last used slot, all previous slots are free,
! 1569: * we can restart from 1.
! 1570: * slot 0 is reserved for request sense commands.
! 1571: */
! 1572: if (siop_script_read(sc, (Ent_script_sched_slot0 / 4) + slot * 2) ==
! 1573: 0x80000000) {
! 1574: slot = sc->sc_currschedslot = 1;
! 1575: } else {
! 1576: slot++;
! 1577: }
! 1578: /* first handle commands from the urgent list */
! 1579: siop_cmd = TAILQ_FIRST(&sc->urgent_list);
! 1580: again:
! 1581: for (; siop_cmd != NULL; siop_cmd = next_siop_cmd) {
! 1582: next_siop_cmd = TAILQ_NEXT(siop_cmd, next);
! 1583: #ifdef DIAGNOSTIC
! 1584: if (siop_cmd->cmd_c.status != CMDST_READY &&
! 1585: siop_cmd->cmd_c.status != CMDST_SENSE)
! 1586: panic("siop: non-ready cmd in ready list");
! 1587: #endif
! 1588: target = siop_cmd->cmd_c.xs->sc_link->target;
! 1589: lun = siop_cmd->cmd_c.xs->sc_link->lun;
! 1590: siop_lun =
! 1591: ((struct siop_target*)sc->sc_c.targets[target])->siop_lun[lun];
! 1592: /* if non-tagged command active, wait */
! 1593: if (siop_lun->siop_tag[0].active != NULL)
! 1594: continue;
! 1595: /*
! 1596: * if we're in a queue full condition don't start a new
! 1597: * command, unless it's a request sense
! 1598: */
! 1599: if ((siop_lun->lun_flags & SIOP_LUNF_FULL) &&
! 1600: siop_cmd->cmd_c.status == CMDST_READY)
! 1601: continue;
! 1602: /* find a free tag if needed */
! 1603: if (siop_cmd->cmd_c.flags & CMDFL_TAG) {
! 1604: for (tag = 1; tag < SIOP_NTAG; tag++) {
! 1605: if (siop_lun->siop_tag[tag].active == NULL)
! 1606: break;
! 1607: }
! 1608: if (tag == SIOP_NTAG) /* no free tag */
! 1609: continue;
! 1610: } else {
! 1611: tag = 0;
! 1612: }
! 1613: siop_cmd->cmd_c.tag = tag;
! 1614: /*
! 1615: * find a free scheduler slot and load it. If it's a request
! 1616: * sense we need to use slot 0.
! 1617: */
! 1618: if (siop_cmd->cmd_c.status != CMDST_SENSE) {
! 1619: for (; slot < SIOP_NSLOTS; slot++) {
! 1620: /*
! 1621: * If cmd if 0x80000000 the slot is free
! 1622: */
! 1623: if (siop_script_read(sc,
! 1624: (Ent_script_sched_slot0 / 4) + slot * 2) ==
! 1625: 0x80000000)
! 1626: break;
! 1627: }
! 1628: /* no more free slots, no need to continue */
! 1629: if (slot == SIOP_NSLOTS) {
! 1630: goto end;
! 1631: }
! 1632: } else {
! 1633: slot = 0;
! 1634: if (siop_script_read(sc, Ent_script_sched_slot0 / 4)
! 1635: != 0x80000000)
! 1636: goto end;
! 1637: }
! 1638:
! 1639: #ifdef SIOP_DEBUG_SCHED
! 1640: printf("using slot %d for DSA 0x%lx\n", slot,
! 1641: (u_long)siop_cmd->cmd_c.dsa);
! 1642: #endif
! 1643: /* Ok, we can add the tag message */
! 1644: if (tag > 0) {
! 1645: #ifdef DIAGNOSTIC
! 1646: int msgcount = siop_ctoh32(&sc->sc_c,
! 1647: siop_cmd->cmd_tables->t_msgout.count);
! 1648: if (msgcount != 1)
! 1649: printf("%s:%d:%d: tag %d with msgcount %d\n",
! 1650: sc->sc_c.sc_dev.dv_xname, target, lun, tag,
! 1651: msgcount);
! 1652: #endif
! 1653: if (siop_cmd->cmd_c.xs->bp != NULL &&
! 1654: (siop_cmd->cmd_c.xs->bp->b_flags & B_ASYNC))
! 1655: siop_cmd->cmd_tables->msg_out[1] =
! 1656: MSG_SIMPLE_Q_TAG;
! 1657: else
! 1658: siop_cmd->cmd_tables->msg_out[1] =
! 1659: MSG_ORDERED_Q_TAG;
! 1660: siop_cmd->cmd_tables->msg_out[2] = tag;
! 1661: siop_cmd->cmd_tables->t_msgout.count =
! 1662: siop_htoc32(&sc->sc_c, 3);
! 1663: }
! 1664: /* note that we started a new command */
! 1665: newcmd = 1;
! 1666: /* mark command as active */
! 1667: if (siop_cmd->cmd_c.status == CMDST_READY) {
! 1668: siop_cmd->cmd_c.status = CMDST_ACTIVE;
! 1669: } else if (siop_cmd->cmd_c.status == CMDST_SENSE) {
! 1670: siop_cmd->cmd_c.status = CMDST_SENSE_ACTIVE;
! 1671: } else
! 1672: panic("siop_start: bad status");
! 1673: if (doingready)
! 1674: TAILQ_REMOVE(&sc->ready_list, siop_cmd, next);
! 1675: else
! 1676: TAILQ_REMOVE(&sc->urgent_list, siop_cmd, next);
! 1677: siop_lun->siop_tag[tag].active = siop_cmd;
! 1678: /* patch scripts with DSA addr */
! 1679: dsa = siop_cmd->cmd_c.dsa;
! 1680: /* first reselect switch, if we have an entry */
! 1681: if (siop_lun->siop_tag[tag].reseloff > 0)
! 1682: siop_script_write(sc,
! 1683: siop_lun->siop_tag[tag].reseloff + 1,
! 1684: dsa + sizeof(struct siop_common_xfer) +
! 1685: Ent_ldsa_reload_dsa);
! 1686: /* CMD script: MOVE MEMORY addr */
! 1687: siop_xfer = (struct siop_xfer*)siop_cmd->cmd_tables;
! 1688: siop_xfer->resel[E_ldsa_abs_slot_Used[0]] =
! 1689: siop_htoc32(&sc->sc_c, sc->sc_c.sc_scriptaddr +
! 1690: Ent_script_sched_slot0 + slot * 8);
! 1691: siop_table_sync(siop_cmd, BUS_DMASYNC_PREWRITE);
! 1692: /* scheduler slot: JUMP ldsa_select */
! 1693: siop_script_write(sc,
! 1694: (Ent_script_sched_slot0 / 4) + slot * 2 + 1,
! 1695: dsa + sizeof(struct siop_common_xfer) + Ent_ldsa_select);
! 1696: /* handle timeout */
! 1697: if (siop_cmd->cmd_c.status == CMDST_ACTIVE) {
! 1698: if ((siop_cmd->cmd_c.xs->flags & SCSI_POLL) == 0) {
! 1699: /* start expire timer */
! 1700: timeout = (u_int64_t) siop_cmd->cmd_c.xs->timeout *
! 1701: (u_int64_t)hz / 1000;
! 1702: if (timeout == 0)
! 1703: timeout = 1;
! 1704: timeout_add(&siop_cmd->cmd_c.xs->stimeout, timeout);
! 1705: }
! 1706: }
! 1707: /*
! 1708: * Change JUMP cmd so that this slot will be handled
! 1709: */
! 1710: siop_script_write(sc, (Ent_script_sched_slot0 / 4) + slot * 2,
! 1711: 0x80080000);
! 1712: /* if we're using the request sense slot, stop here */
! 1713: if (slot == 0)
! 1714: goto end;
! 1715: sc->sc_currschedslot = slot;
! 1716: slot++;
! 1717: }
! 1718: if (doingready == 0) {
! 1719: /* now process ready list */
! 1720: doingready = 1;
! 1721: siop_cmd = TAILQ_FIRST(&sc->ready_list);
! 1722: goto again;
! 1723: }
! 1724:
! 1725: end:
! 1726: /* if nothing changed no need to flush cache and wakeup script */
! 1727: if (newcmd == 0)
! 1728: return;
! 1729: /* make sure SCRIPT processor will read valid data */
! 1730: siop_script_sync(sc,BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 1731: /* Signal script it has some work to do */
! 1732: bus_space_write_1(sc->sc_c.sc_rt, sc->sc_c.sc_rh,
! 1733: SIOP_ISTAT, ISTAT_SIGP);
! 1734: /* and wait for IRQ */
! 1735: return;
! 1736: }
! 1737:
! 1738: void
! 1739: siop_timeout(v)
! 1740: void *v;
! 1741: {
! 1742: struct siop_cmd *siop_cmd = v;
! 1743: struct siop_softc *sc = (struct siop_softc *)siop_cmd->cmd_c.siop_sc;
! 1744: int s;
! 1745:
! 1746: /* deactivate callout */
! 1747: timeout_del(&siop_cmd->cmd_c.xs->stimeout);
! 1748:
! 1749: sc_print_addr(siop_cmd->cmd_c.xs->sc_link);
! 1750: printf("timeout on SCSI command 0x%x\n",
! 1751: siop_cmd->cmd_c.xs->cmd->opcode);
! 1752:
! 1753: s = splbio();
! 1754: /* reset the scsi bus */
! 1755: siop_resetbus(&sc->sc_c);
! 1756: siop_cmd->cmd_c.flags |= CMDFL_TIMEOUT;
! 1757: siop_handle_reset(sc);
! 1758: splx(s);
! 1759:
! 1760: return;
! 1761: }
! 1762:
! 1763: #ifdef DUMP_SCRIPT
! 1764: void
! 1765: siop_dump_script(sc)
! 1766: struct siop_softc *sc;
! 1767: {
! 1768: int i;
! 1769: for (i = 0; i < PAGE_SIZE / 4; i += 2) {
! 1770: printf("0x%04x: 0x%08x 0x%08x", i * 4,
! 1771: siop_ctoh32(&sc->sc_c, sc->sc_c.sc_script[i]),
! 1772: siop_ctoh32(&sc->sc_c, sc->sc_c.sc_script[i+1]));
! 1773: if ((siop_ctoh32(&sc->sc_c,
! 1774: sc->sc_c.sc_script[i]) & 0xe0000000) == 0xc0000000) {
! 1775: i++;
! 1776: printf(" 0x%08x", siop_ctoh32(&sc->sc_c,
! 1777: sc->sc_c.sc_script[i+1]));
! 1778: }
! 1779: printf("\n");
! 1780: }
! 1781: }
! 1782: #endif
! 1783:
! 1784: void
! 1785: siop_morecbd(sc)
! 1786: struct siop_softc *sc;
! 1787: {
! 1788: int error, off, i, j, s;
! 1789: bus_dma_segment_t seg;
! 1790: int rseg;
! 1791: struct siop_cbd *newcbd;
! 1792: struct siop_xfer *xfer;
! 1793: bus_addr_t dsa;
! 1794: u_int32_t *scr;
! 1795:
! 1796: /* allocate a new list head */
! 1797: newcbd = malloc(sizeof(struct siop_cbd), M_DEVBUF, M_NOWAIT);
! 1798: if (newcbd == NULL) {
! 1799: printf("%s: can't allocate memory for command descriptors "
! 1800: "head\n", sc->sc_c.sc_dev.dv_xname);
! 1801: return;
! 1802: }
! 1803: bzero(newcbd, sizeof(struct siop_cbd));
! 1804:
! 1805: /* allocate cmd list */
! 1806: newcbd->cmds = malloc(sizeof(struct siop_cmd) * SIOP_NCMDPB,
! 1807: M_DEVBUF, M_NOWAIT);
! 1808: if (newcbd->cmds == NULL) {
! 1809: printf("%s: can't allocate memory for command descriptors\n",
! 1810: sc->sc_c.sc_dev.dv_xname);
! 1811: goto bad3;
! 1812: }
! 1813: bzero(newcbd->cmds, sizeof(struct siop_cmd) * SIOP_NCMDPB);
! 1814: error = bus_dmamem_alloc(sc->sc_c.sc_dmat, PAGE_SIZE, PAGE_SIZE, 0, &seg,
! 1815: 1, &rseg, BUS_DMA_NOWAIT);
! 1816: if (error) {
! 1817: printf("%s: unable to allocate cbd DMA memory, error = %d\n",
! 1818: sc->sc_c.sc_dev.dv_xname, error);
! 1819: goto bad2;
! 1820: }
! 1821: error = bus_dmamem_map(sc->sc_c.sc_dmat, &seg, rseg, PAGE_SIZE,
! 1822: (caddr_t *)&newcbd->xfers, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
! 1823: if (error) {
! 1824: printf("%s: unable to map cbd DMA memory, error = %d\n",
! 1825: sc->sc_c.sc_dev.dv_xname, error);
! 1826: goto bad2;
! 1827: }
! 1828: error = bus_dmamap_create(sc->sc_c.sc_dmat, PAGE_SIZE, 1, PAGE_SIZE, 0,
! 1829: BUS_DMA_NOWAIT, &newcbd->xferdma);
! 1830: if (error) {
! 1831: printf("%s: unable to create cbd DMA map, error = %d\n",
! 1832: sc->sc_c.sc_dev.dv_xname, error);
! 1833: goto bad1;
! 1834: }
! 1835: error = bus_dmamap_load(sc->sc_c.sc_dmat, newcbd->xferdma, newcbd->xfers,
! 1836: PAGE_SIZE, NULL, BUS_DMA_NOWAIT);
! 1837: if (error) {
! 1838: printf("%s: unable to load cbd DMA map, error = %d\n",
! 1839: sc->sc_c.sc_dev.dv_xname, error);
! 1840: goto bad0;
! 1841: }
! 1842: #ifdef SIOP_DEBUG
! 1843: printf("%s: alloc newcdb at PHY addr 0x%lx\n", sc->sc_c.sc_dev.dv_xname,
! 1844: (unsigned long)newcbd->xferdma->dm_segs[0].ds_addr);
! 1845: #endif
! 1846: for (i = 0; i < SIOP_NCMDPB; i++) {
! 1847: error = bus_dmamap_create(sc->sc_c.sc_dmat, MAXPHYS, SIOP_NSG,
! 1848: MAXPHYS, 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
! 1849: &newcbd->cmds[i].cmd_c.dmamap_data);
! 1850: if (error) {
! 1851: printf("%s: unable to create data DMA map for cbd: "
! 1852: "error %d\n",
! 1853: sc->sc_c.sc_dev.dv_xname, error);
! 1854: goto bad0;
! 1855: }
! 1856: }
! 1857:
! 1858: /* Use two loops since bailing out above releases allocated memory */
! 1859: off = (sc->sc_c.features & SF_CHIP_BE) ? 3 : 0;
! 1860: for (i = 0; i < SIOP_NCMDPB; i++) {
! 1861: newcbd->cmds[i].cmd_c.siop_sc = &sc->sc_c;
! 1862: newcbd->cmds[i].siop_cbdp = newcbd;
! 1863: xfer = &newcbd->xfers[i];
! 1864: newcbd->cmds[i].cmd_tables = (struct siop_common_xfer *)xfer;
! 1865: bzero(newcbd->cmds[i].cmd_tables, sizeof(struct siop_xfer));
! 1866: dsa = newcbd->xferdma->dm_segs[0].ds_addr +
! 1867: i * sizeof(struct siop_xfer);
! 1868: newcbd->cmds[i].cmd_c.dsa = dsa;
! 1869: newcbd->cmds[i].cmd_c.status = CMDST_FREE;
! 1870: xfer->siop_tables.t_msgout.count= siop_htoc32(&sc->sc_c, 1);
! 1871: xfer->siop_tables.t_msgout.addr = siop_htoc32(&sc->sc_c, dsa);
! 1872: xfer->siop_tables.t_msgin.count= siop_htoc32(&sc->sc_c, 1);
! 1873: xfer->siop_tables.t_msgin.addr = siop_htoc32(&sc->sc_c,
! 1874: dsa + offsetof(struct siop_common_xfer, msg_in));
! 1875: xfer->siop_tables.t_extmsgin.count= siop_htoc32(&sc->sc_c, 2);
! 1876: xfer->siop_tables.t_extmsgin.addr = siop_htoc32(&sc->sc_c,
! 1877: dsa + offsetof(struct siop_common_xfer, msg_in) + 1);
! 1878: xfer->siop_tables.t_extmsgdata.addr = siop_htoc32(&sc->sc_c,
! 1879: dsa + offsetof(struct siop_common_xfer, msg_in) + 3);
! 1880: xfer->siop_tables.t_status.count= siop_htoc32(&sc->sc_c, 1);
! 1881: xfer->siop_tables.t_status.addr = siop_htoc32(&sc->sc_c,
! 1882: dsa + offsetof(struct siop_common_xfer, status) + off);
! 1883: xfer->siop_tables.cmd.count = siop_htoc32(&sc->sc_c, 0);
! 1884: xfer->siop_tables.cmd.addr = siop_htoc32(&sc->sc_c,
! 1885: dsa + offsetof(struct siop_common_xfer, xscmd));
! 1886: /* The select/reselect script */
! 1887: scr = &xfer->resel[0];
! 1888: for (j = 0; j < sizeof(load_dsa) / sizeof(load_dsa[0]); j++)
! 1889: scr[j] = siop_htoc32(&sc->sc_c, load_dsa[j]);
! 1890: /*
! 1891: * 0x78000000 is a 'move data8 to reg'. data8 is the second
! 1892: * octet, reg offset is the third.
! 1893: */
! 1894: scr[Ent_rdsa0 / 4] = siop_htoc32(&sc->sc_c,
! 1895: 0x78100000 | ((dsa & 0x000000ff) << 8));
! 1896: scr[Ent_rdsa1 / 4] = siop_htoc32(&sc->sc_c,
! 1897: 0x78110000 | ( dsa & 0x0000ff00 ));
! 1898: scr[Ent_rdsa2 / 4] = siop_htoc32(&sc->sc_c,
! 1899: 0x78120000 | ((dsa & 0x00ff0000) >> 8));
! 1900: scr[Ent_rdsa3 / 4] = siop_htoc32(&sc->sc_c,
! 1901: 0x78130000 | ((dsa & 0xff000000) >> 16));
! 1902: scr[E_ldsa_abs_reselected_Used[0]] = siop_htoc32(&sc->sc_c,
! 1903: sc->sc_c.sc_scriptaddr + Ent_reselected);
! 1904: scr[E_ldsa_abs_reselect_Used[0]] = siop_htoc32(&sc->sc_c,
! 1905: sc->sc_c.sc_scriptaddr + Ent_reselect);
! 1906: scr[E_ldsa_abs_selected_Used[0]] = siop_htoc32(&sc->sc_c,
! 1907: sc->sc_c.sc_scriptaddr + Ent_selected);
! 1908: scr[E_ldsa_abs_data_Used[0]] = siop_htoc32(&sc->sc_c,
! 1909: dsa + sizeof(struct siop_common_xfer) + Ent_ldsa_data);
! 1910: /* JUMP foo, IF FALSE - used by MOVE MEMORY to clear the slot */
! 1911: scr[Ent_ldsa_data / 4] = siop_htoc32(&sc->sc_c, 0x80000000);
! 1912: s = splbio();
! 1913: TAILQ_INSERT_TAIL(&sc->free_list, &newcbd->cmds[i], next);
! 1914: splx(s);
! 1915: #ifdef SIOP_DEBUG
! 1916: printf("tables[%d]: in=0x%x out=0x%x status=0x%x "
! 1917: "offset=0x%x\n", i,
! 1918: siop_ctoh32(&sc->sc_c,
! 1919: newcbd->cmds[i].cmd_tables->t_msgin.addr),
! 1920: siop_ctoh32(&sc->sc_c,
! 1921: newcbd->cmds[i].cmd_tables->t_msgout.addr),
! 1922: siop_ctoh32(&sc->sc_c,
! 1923: newcbd->cmds[i].cmd_tables->t_status.addr));
! 1924: #endif
! 1925: }
! 1926: s = splbio();
! 1927: TAILQ_INSERT_TAIL(&sc->cmds, newcbd, next);
! 1928: splx(s);
! 1929: return;
! 1930: bad0:
! 1931: bus_dmamap_unload(sc->sc_c.sc_dmat, newcbd->xferdma);
! 1932: bus_dmamap_destroy(sc->sc_c.sc_dmat, newcbd->xferdma);
! 1933: bad1:
! 1934: bus_dmamem_free(sc->sc_c.sc_dmat, &seg, rseg);
! 1935: bad2:
! 1936: free(newcbd->cmds, M_DEVBUF);
! 1937: bad3:
! 1938: free(newcbd, M_DEVBUF);
! 1939: return;
! 1940: }
! 1941:
! 1942: struct siop_lunsw *
! 1943: siop_get_lunsw(sc)
! 1944: struct siop_softc *sc;
! 1945: {
! 1946: struct siop_lunsw *lunsw;
! 1947: int i;
! 1948:
! 1949: if (sc->script_free_lo + (sizeof(lun_switch) / sizeof(lun_switch[0])) >=
! 1950: sc->script_free_hi)
! 1951: return NULL;
! 1952: lunsw = TAILQ_FIRST(&sc->lunsw_list);
! 1953: if (lunsw != NULL) {
! 1954: #ifdef SIOP_DEBUG
! 1955: printf("siop_get_lunsw got lunsw at offset %d\n",
! 1956: lunsw->lunsw_off);
! 1957: #endif
! 1958: TAILQ_REMOVE(&sc->lunsw_list, lunsw, next);
! 1959: return lunsw;
! 1960: }
! 1961: lunsw = malloc(sizeof(struct siop_lunsw), M_DEVBUF, M_NOWAIT);
! 1962: if (lunsw == NULL)
! 1963: return NULL;
! 1964: bzero(lunsw, sizeof(struct siop_lunsw));
! 1965: #ifdef SIOP_DEBUG
! 1966: printf("allocating lunsw at offset %d\n", sc->script_free_lo);
! 1967: #endif
! 1968: if (sc->sc_c.features & SF_CHIP_RAM) {
! 1969: bus_space_write_region_4(sc->sc_c.sc_ramt, sc->sc_c.sc_ramh,
! 1970: sc->script_free_lo * 4, lun_switch,
! 1971: sizeof(lun_switch) / sizeof(lun_switch[0]));
! 1972: bus_space_write_4(sc->sc_c.sc_ramt, sc->sc_c.sc_ramh,
! 1973: (sc->script_free_lo + E_abs_lunsw_return_Used[0]) * 4,
! 1974: sc->sc_c.sc_scriptaddr + Ent_lunsw_return);
! 1975: } else {
! 1976: for (i = 0; i < sizeof(lun_switch) / sizeof(lun_switch[0]);
! 1977: i++)
! 1978: sc->sc_c.sc_script[sc->script_free_lo + i] =
! 1979: siop_htoc32(&sc->sc_c, lun_switch[i]);
! 1980: sc->sc_c.sc_script[
! 1981: sc->script_free_lo + E_abs_lunsw_return_Used[0]] =
! 1982: siop_htoc32(&sc->sc_c,
! 1983: sc->sc_c.sc_scriptaddr + Ent_lunsw_return);
! 1984: }
! 1985: lunsw->lunsw_off = sc->script_free_lo;
! 1986: lunsw->lunsw_size = sizeof(lun_switch) / sizeof(lun_switch[0]);
! 1987: sc->script_free_lo += lunsw->lunsw_size;
! 1988: siop_script_sync(sc, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 1989: return lunsw;
! 1990: }
! 1991:
! 1992: void
! 1993: siop_add_reselsw(sc, target)
! 1994: struct siop_softc *sc;
! 1995: int target;
! 1996: {
! 1997: int i,j;
! 1998: struct siop_target *siop_target;
! 1999: struct siop_lun *siop_lun;
! 2000:
! 2001: siop_target = (struct siop_target *)sc->sc_c.targets[target];
! 2002: /*
! 2003: * add an entry to resel switch
! 2004: */
! 2005: siop_script_sync(sc, BUS_DMASYNC_POSTWRITE);
! 2006: for (i = 0; i < 15; i++) {
! 2007: siop_target->reseloff = Ent_resel_targ0 / 4 + i * 2;
! 2008: if ((siop_script_read(sc, siop_target->reseloff) & 0xff)
! 2009: == 0xff) { /* it's free */
! 2010: #ifdef SIOP_DEBUG
! 2011: printf("siop: target %d slot %d offset %d\n",
! 2012: target, i, siop_target->reseloff);
! 2013: #endif
! 2014: /* JUMP abs_foo, IF target | 0x80; */
! 2015: siop_script_write(sc, siop_target->reseloff,
! 2016: 0x800c0080 | target);
! 2017: siop_script_write(sc, siop_target->reseloff + 1,
! 2018: sc->sc_c.sc_scriptaddr +
! 2019: siop_target->lunsw->lunsw_off * 4 +
! 2020: Ent_lun_switch_entry);
! 2021: break;
! 2022: }
! 2023: }
! 2024: if (i == 15) /* no free slot, shouldn't happen */
! 2025: panic("siop: resel switch full");
! 2026:
! 2027: sc->sc_ntargets++;
! 2028: for (i = 0; i < 8; i++) {
! 2029: siop_lun = siop_target->siop_lun[i];
! 2030: if (siop_lun == NULL)
! 2031: continue;
! 2032: if (siop_lun->reseloff > 0) {
! 2033: siop_lun->reseloff = 0;
! 2034: for (j = 0; j < SIOP_NTAG; j++)
! 2035: siop_lun->siop_tag[j].reseloff = 0;
! 2036: siop_add_dev(sc, target, i);
! 2037: }
! 2038: }
! 2039: siop_update_scntl3(sc, sc->sc_c.targets[target]);
! 2040: siop_script_sync(sc, BUS_DMASYNC_PREWRITE);
! 2041: }
! 2042:
! 2043: void
! 2044: siop_update_scntl3(sc, _siop_target)
! 2045: struct siop_softc *sc;
! 2046: struct siop_common_target *_siop_target;
! 2047: {
! 2048: struct siop_target *siop_target = (struct siop_target *)_siop_target;
! 2049: /* MOVE target->id >> 24 TO SCNTL3 */
! 2050: siop_script_write(sc,
! 2051: siop_target->lunsw->lunsw_off + (Ent_restore_scntl3 / 4),
! 2052: 0x78030000 | ((siop_target->target_c.id >> 16) & 0x0000ff00));
! 2053: /* MOVE target->id >> 8 TO SXFER */
! 2054: siop_script_write(sc,
! 2055: siop_target->lunsw->lunsw_off + (Ent_restore_scntl3 / 4) + 2,
! 2056: 0x78050000 | (siop_target->target_c.id & 0x0000ff00));
! 2057: siop_script_sync(sc, BUS_DMASYNC_PREWRITE);
! 2058: }
! 2059:
! 2060: void
! 2061: siop_add_dev(sc, target, lun)
! 2062: struct siop_softc *sc;
! 2063: int target;
! 2064: int lun;
! 2065: {
! 2066: struct siop_lunsw *lunsw;
! 2067: struct siop_target *siop_target =
! 2068: (struct siop_target *)sc->sc_c.targets[target];
! 2069: struct siop_lun *siop_lun = siop_target->siop_lun[lun];
! 2070: int i, ntargets;
! 2071:
! 2072: if (siop_lun->reseloff > 0)
! 2073: return;
! 2074: lunsw = siop_target->lunsw;
! 2075: if ((lunsw->lunsw_off + lunsw->lunsw_size) < sc->script_free_lo) {
! 2076: /*
! 2077: * can't extend this slot. Probably not worth trying to deal
! 2078: * with this case
! 2079: */
! 2080: #ifdef SIOP_DEBUG
! 2081: printf("%s:%d:%d: can't allocate a lun sw slot\n",
! 2082: sc->sc_c.sc_dev.dv_xname, target, lun);
! 2083: #endif
! 2084: return;
! 2085: }
! 2086: /* count how many free targets we still have to probe */
! 2087: ntargets = (sc->sc_c.sc_link.adapter_buswidth - 1) - 1 - sc->sc_ntargets;
! 2088:
! 2089: /*
! 2090: * we need 8 bytes for the lun sw additional entry, and
! 2091: * eventually sizeof(tag_switch) for the tag switch entry.
! 2092: * Keep enough free space for the free targets that could be
! 2093: * probed later.
! 2094: */
! 2095: if (sc->script_free_lo + 2 +
! 2096: (ntargets * sizeof(lun_switch) / sizeof(lun_switch[0])) >=
! 2097: ((siop_target->target_c.flags & TARF_TAG) ?
! 2098: sc->script_free_hi - (sizeof(tag_switch) / sizeof(tag_switch[0])) :
! 2099: sc->script_free_hi)) {
! 2100: /*
! 2101: * not enough space, probably not worth dealing with it.
! 2102: * We can hold 13 tagged-queuing capable devices in the 4k RAM.
! 2103: */
! 2104: #ifdef SIOP_DEBUG
! 2105: printf("%s:%d:%d: not enough memory for a lun sw slot\n",
! 2106: sc->sc_c.sc_dev.dv_xname, target, lun);
! 2107: #endif
! 2108: return;
! 2109: }
! 2110: #ifdef SIOP_DEBUG
! 2111: printf("%s:%d:%d: allocate lun sw entry\n",
! 2112: sc->sc_c.sc_dev.dv_xname, target, lun);
! 2113: #endif
! 2114: /* INT int_resellun */
! 2115: siop_script_write(sc, sc->script_free_lo, 0x98080000);
! 2116: siop_script_write(sc, sc->script_free_lo + 1, A_int_resellun);
! 2117: /* Now the slot entry: JUMP abs_foo, IF lun */
! 2118: siop_script_write(sc, sc->script_free_lo - 2,
! 2119: 0x800c0000 | lun);
! 2120: siop_script_write(sc, sc->script_free_lo - 1, 0);
! 2121: siop_lun->reseloff = sc->script_free_lo - 2;
! 2122: lunsw->lunsw_size += 2;
! 2123: sc->script_free_lo += 2;
! 2124: if (siop_target->target_c.flags & TARF_TAG) {
! 2125: /* we need a tag switch */
! 2126: sc->script_free_hi -=
! 2127: sizeof(tag_switch) / sizeof(tag_switch[0]);
! 2128: if (sc->sc_c.features & SF_CHIP_RAM) {
! 2129: bus_space_write_region_4(sc->sc_c.sc_ramt,
! 2130: sc->sc_c.sc_ramh,
! 2131: sc->script_free_hi * 4, tag_switch,
! 2132: sizeof(tag_switch) / sizeof(tag_switch[0]));
! 2133: } else {
! 2134: for(i = 0;
! 2135: i < sizeof(tag_switch) / sizeof(tag_switch[0]);
! 2136: i++) {
! 2137: sc->sc_c.sc_script[sc->script_free_hi + i] =
! 2138: siop_htoc32(&sc->sc_c, tag_switch[i]);
! 2139: }
! 2140: }
! 2141: siop_script_write(sc,
! 2142: siop_lun->reseloff + 1,
! 2143: sc->sc_c.sc_scriptaddr + sc->script_free_hi * 4 +
! 2144: Ent_tag_switch_entry);
! 2145:
! 2146: for (i = 0; i < SIOP_NTAG; i++) {
! 2147: siop_lun->siop_tag[i].reseloff =
! 2148: sc->script_free_hi + (Ent_resel_tag0 / 4) + i * 2;
! 2149: }
! 2150: } else {
! 2151: /* non-tag case; just work with the lun switch */
! 2152: siop_lun->siop_tag[0].reseloff =
! 2153: siop_target->siop_lun[lun]->reseloff;
! 2154: }
! 2155: siop_script_sync(sc, BUS_DMASYNC_PREWRITE);
! 2156: }
! 2157:
! 2158: void
! 2159: siop_del_dev(sc, target, lun)
! 2160: struct siop_softc *sc;
! 2161: int target;
! 2162: int lun;
! 2163: {
! 2164: int i;
! 2165: struct siop_target *siop_target;
! 2166: #ifdef SIOP_DEBUG
! 2167: printf("%s:%d:%d: free lun sw entry\n",
! 2168: sc->sc_c.sc_dev.dv_xname, target, lun);
! 2169: #endif
! 2170: if (sc->sc_c.targets[target] == NULL)
! 2171: return;
! 2172: siop_target = (struct siop_target *)sc->sc_c.targets[target];
! 2173: free(siop_target->siop_lun[lun], M_DEVBUF);
! 2174: siop_target->siop_lun[lun] = NULL;
! 2175: /* XXX compact sw entry too ? */
! 2176: /* check if we can free the whole target */
! 2177: for (i = 0; i < 8; i++) {
! 2178: if (siop_target->siop_lun[i] != NULL)
! 2179: return;
! 2180: }
! 2181: #ifdef SIOP_DEBUG
! 2182: printf("%s: free siop_target for target %d lun %d lunsw offset %d\n",
! 2183: sc->sc_c.sc_dev.dv_xname, target, lun,
! 2184: siop_target->lunsw->lunsw_off);
! 2185: #endif
! 2186: /*
! 2187: * nothing here, free the target struct and resel
! 2188: * switch entry
! 2189: */
! 2190: siop_script_write(sc, siop_target->reseloff, 0x800c00ff);
! 2191: siop_script_sync(sc, BUS_DMASYNC_PREWRITE);
! 2192: TAILQ_INSERT_TAIL(&sc->lunsw_list, siop_target->lunsw, next);
! 2193: free(sc->sc_c.targets[target], M_DEVBUF);
! 2194: sc->sc_c.targets[target] = NULL;
! 2195: sc->sc_ntargets--;
! 2196: }
! 2197:
! 2198: #ifdef SIOP_STATS
! 2199: void
! 2200: siop_printstats()
! 2201: {
! 2202: printf("siop_stat_intr %d\n", siop_stat_intr);
! 2203: printf("siop_stat_intr_shortxfer %d\n", siop_stat_intr_shortxfer);
! 2204: printf("siop_stat_intr_xferdisc %d\n", siop_stat_intr_xferdisc);
! 2205: printf("siop_stat_intr_sdp %d\n", siop_stat_intr_sdp);
! 2206: printf("siop_stat_intr_saveoffset %d\n", siop_stat_intr_saveoffset);
! 2207: printf("siop_stat_intr_done %d\n", siop_stat_intr_done);
! 2208: printf("siop_stat_intr_lunresel %d\n", siop_stat_intr_lunresel);
! 2209: printf("siop_stat_intr_qfull %d\n", siop_stat_intr_qfull);
! 2210: }
! 2211: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to siop.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic