Annotation of sys/arch/mvme68k/dev/vs.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: vs.c,v 1.20 2006/06/02 18:53:56 miod Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 1999 Steve Murphree, Jr.
! 5: * Copyright (c) 1990 The Regents of the University of California.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to Berkeley by
! 9: * Van Jacobson of Lawrence Berkeley Laboratory.
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. Neither the name of the University nor the names of its contributors
! 20: * may be used to endorse or promote products derived from this software
! 21: * without specific prior written permission.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 33: * SUCH DAMAGE.
! 34: */
! 35:
! 36: /*
! 37: * MVME328 scsi adaptor driver
! 38: */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/device.h>
! 43: #include <sys/disklabel.h>
! 44: #include <sys/dkstat.h>
! 45: #include <sys/buf.h>
! 46: #include <sys/malloc.h>
! 47:
! 48: #include <scsi/scsi_all.h>
! 49: #include <scsi/scsiconf.h>
! 50:
! 51: #include <machine/autoconf.h>
! 52: #include <machine/param.h>
! 53:
! 54: #include <uvm/uvm_param.h>
! 55:
! 56: #ifdef mvme88k
! 57: #include <mvme88k/dev/vsreg.h>
! 58: #include <mvme88k/dev/vsvar.h>
! 59: #include <machine/mmu.h>
! 60: #else
! 61: #include <mvme68k/dev/vsreg.h>
! 62: #include <mvme68k/dev/vsvar.h>
! 63: #endif
! 64:
! 65: void scopy(void *, void *, u_int);
! 66: void szero(void *, u_int);
! 67: int do_vspoll(struct vs_softc *, int, int);
! 68: void thaw_queue(struct vs_softc *, u_int8_t);
! 69: int vs_checkintr(struct vs_softc *, struct scsi_xfer *, int *);
! 70: void vs_chksense(struct scsi_xfer *);
! 71: void vs_reset(struct vs_softc *);
! 72: void vs_resync(struct vs_softc *);
! 73: void vs_initialize(struct vs_softc *);
! 74: void vs_intr(void *);
! 75: int vs_poll(struct vs_softc *, struct scsi_xfer *);
! 76: void vs_scsidone(struct scsi_xfer *, int);
! 77: M328_CQE *vs_getcqe(struct vs_softc *);
! 78: M328_IOPB *vs_getiopb(struct vs_softc *);
! 79: void vs_link_sg_element(sg_list_element_t *, vaddr_t, int);
! 80: void vs_link_sg_list(sg_list_element_t *, vaddr_t, int);
! 81:
! 82: /*
! 83: * 16 bit 's' memory functions. MVME328 is a D16 board.
! 84: * We must program with that in mind or else...
! 85: * bcopy/bzero (the 'b' meaning byte) is implemented in
! 86: * 32 bit operations for speed, so thay are not really
! 87: * 'byte' operations at all!! MVME1x7 can be set up to
! 88: * handle D32 -> D16 read/writes via VMEChip2 Address
! 89: * modifiers, however MVME188 can not. These next two
! 90: * functions insure 16 bit copy/zero operations. The
! 91: * structures are all implemented with 16 bit or less
! 92: * types. smurph
! 93: */
! 94:
! 95: void
! 96: scopy(src, dst, cnt)
! 97: void *src, *dst;
! 98: u_int cnt;
! 99: {
! 100: u_int16_t volatile *x, *y, z;
! 101:
! 102: z = cnt >> 1;
! 103: x = (u_int16_t *) src;
! 104: y = (u_int16_t *) dst;
! 105:
! 106: while (z--) {
! 107: *y++ = *x++;
! 108: }
! 109: }
! 110:
! 111: void
! 112: szero(src, cnt)
! 113: void *src;
! 114: u_int cnt;
! 115: {
! 116: u_int16_t *source;
! 117: u_int16_t zero = 0;
! 118: u_int16_t z;
! 119:
! 120: source = (u_int16_t *) src;
! 121: z = cnt >> 1;
! 122:
! 123: while (z--) {
! 124: *source++ = zero;
! 125: }
! 126: }
! 127:
! 128: /*
! 129: * default minphys routine for MVME328 based controllers
! 130: */
! 131: void
! 132: vs_minphys(bp)
! 133: struct buf *bp;
! 134: {
! 135: /*
! 136: * No max transfer at this level.
! 137: */
! 138: minphys(bp);
! 139: }
! 140:
! 141: int
! 142: do_vspoll(sc, to, canreset)
! 143: struct vs_softc *sc;
! 144: int to;
! 145: int canreset;
! 146: {
! 147: int i;
! 148:
! 149: if (to <= 0 ) to = 50000;
! 150: /* use cmd_wait values? */
! 151: i = 50000;
! 152: /*spl0();*/
! 153: while (!(CRSW & (M_CRSW_CRBV | M_CRSW_CC))) {
! 154: if (--i <= 0) {
! 155: #ifdef DEBUG
! 156: printf ("waiting: timeout %d crsw 0x%x\n", to, CRSW);
! 157: #endif
! 158: i = 50000;
! 159: --to;
! 160: if (to <= 0) {
! 161: /*splx(s);*/
! 162: if (canreset) {
! 163: vs_reset(sc);
! 164: vs_resync(sc);
! 165: }
! 166: printf ("timed out: timeout %d crsw 0x%x\n",
! 167: to, CRSW);
! 168: return 1;
! 169: }
! 170: }
! 171: }
! 172: return 0;
! 173: }
! 174:
! 175: int
! 176: vs_poll(sc, xs)
! 177: struct vs_softc *sc;
! 178: struct scsi_xfer *xs;
! 179: {
! 180: int status;
! 181: int to;
! 182:
! 183: /*s = splbio();*/
! 184: to = xs->timeout / 1000;
! 185: for (;;) {
! 186: if (do_vspoll(sc, to, 1)) break;
! 187: if (vs_checkintr(sc, xs, &status)) {
! 188: vs_scsidone(xs, status);
! 189: }
! 190: if (CRSW & M_CRSW_ER)
! 191: CRB_CLR_ER(CRSW);
! 192: CRB_CLR_DONE(CRSW);
! 193: if (xs->flags & ITSDONE) break;
! 194: }
! 195: return (COMPLETE);
! 196: }
! 197:
! 198: void
! 199: thaw_queue(sc, target)
! 200: struct vs_softc *sc;
! 201: u_int8_t target;
! 202: {
! 203: u_short t;
! 204: t = target << 8;
! 205: t |= 0x0001;
! 206: THAW_REG = t;
! 207: /* loop until thawed */
! 208: while (THAW_REG & 0x01);
! 209: }
! 210:
! 211: void
! 212: vs_scsidone (xs, stat)
! 213: struct scsi_xfer *xs;
! 214: int stat;
! 215: {
! 216: struct scsi_link *slp = xs->sc_link;
! 217: struct vs_softc *sc = slp->adapter_softc;
! 218: M328_IOPB *riopb = (M328_IOPB *)&sc->sc_vsreg->sh_RET_IOPB;
! 219:
! 220: xs->status = stat;
! 221: while (xs->status == SCSI_CHECK) {
! 222: vs_chksense(xs);
! 223: thaw_queue(sc, slp->target + 1);
! 224: }
! 225: xs->flags |= ITSDONE;
! 226: /*sc->sc_tinfo[slp->target].cmds++;*/
! 227: if (CRSW & M_CRSW_ER)
! 228: CRB_CLR_ER(CRSW);
! 229: CRB_CLR_DONE(CRSW);
! 230: thaw_queue(sc, slp->target + 1);
! 231: szero(riopb, sizeof(M328_IOPB));
! 232: scsi_done(xs);
! 233: }
! 234:
! 235: int
! 236: vs_scsicmd(xs)
! 237: struct scsi_xfer *xs;
! 238: {
! 239: struct scsi_link *slp = xs->sc_link;
! 240: struct vs_softc *sc = slp->adapter_softc;
! 241: int flags;
! 242: unsigned long buf, len;
! 243: u_short iopb_len;
! 244: M328_CQE *mc = (M328_CQE*)&sc->sc_vsreg->sh_MCE;
! 245: M328_CRB *crb = (M328_CRB *)&sc->sc_vsreg->sh_CRB;
! 246: M328_IOPB *miopb = (M328_IOPB *)&sc->sc_vsreg->sh_MCE_IOPB;
! 247: M328_CQE *cqep;
! 248: M328_IOPB *iopb;
! 249: M328_CMD *m328_cmd;
! 250:
! 251: /* If the target doesn't exist, abort */
! 252: if (!sc->sc_tinfo[slp->target].avail) {
! 253: xs->error = XS_SELTIMEOUT;
! 254: xs->status = -1;
! 255: xs->flags |= ITSDONE;
! 256: scsi_done(xs);
! 257: }
! 258:
! 259: flags = xs->flags;
! 260: #ifdef SDEBUG
! 261: printf("scsi_cmd() ");
! 262: if (xs->cmd->opcode == 0) {
! 263: printf("TEST_UNIT_READY ");
! 264: } else if (xs->cmd->opcode == REQUEST_SENSE) {
! 265: printf("REQUEST_SENSE ");
! 266: } else if (xs->cmd->opcode == INQUIRY) {
! 267: printf("INQUIRY ");
! 268: } else if (xs->cmd->opcode == MODE_SELECT) {
! 269: printf("MODE_SELECT ");
! 270: } else if (xs->cmd->opcode == MODE_SENSE) {
! 271: printf("MODE_SENSE ");
! 272: } else if (xs->cmd->opcode == START_STOP) {
! 273: printf("START_STOP ");
! 274: } else if (xs->cmd->opcode == RESERVE) {
! 275: printf("RESERVE ");
! 276: } else if (xs->cmd->opcode == RELEASE) {
! 277: printf("RELEASE ");
! 278: } else if (xs->cmd->opcode == PREVENT_ALLOW) {
! 279: printf("PREVENT_ALLOW ");
! 280: } else if (xs->cmd->opcode == POSITION_TO_ELEMENT) {
! 281: printf("POSITION_TO_EL ");
! 282: } else if (xs->cmd->opcode == CHANGE_DEFINITION) {
! 283: printf("CHANGE_DEF ");
! 284: } else if (xs->cmd->opcode == MODE_SENSE_BIG) {
! 285: printf("MODE_SENSE_BIG ");
! 286: } else if (xs->cmd->opcode == MODE_SELECT_BIG) {
! 287: printf("MODE_SELECT_BIG ");
! 288: } else if (xs->cmd->opcode == 0x25) {
! 289: printf("READ_CAPACITY ");
! 290: } else if (xs->cmd->opcode == 0x08) {
! 291: printf("READ_COMMAND ");
! 292: }
! 293: #endif
! 294: if (flags & SCSI_POLL) {
! 295: cqep = mc;
! 296: iopb = miopb;
! 297: } else {
! 298: cqep = vs_getcqe(sc);
! 299: if (cqep == NULL) {
! 300: return (TRY_AGAIN_LATER);
! 301: }
! 302: iopb = vs_getiopb(sc);
! 303: }
! 304:
! 305: /* s = splbio();*/
! 306: iopb_len = sizeof(M328_short_IOPB) + xs->cmdlen;
! 307: szero(iopb, sizeof(M328_IOPB));
! 308:
! 309: scopy(xs->cmd, &iopb->iopb_SCSI[0], xs->cmdlen);
! 310: iopb->iopb_CMD = IOPB_SCSI;
! 311: #if 0
! 312: LV(iopb->iopb_BUFF, kvtop(xs->data));
! 313: LV(iopb->iopb_LENGTH, xs->datalen);
! 314: #endif
! 315: iopb->iopb_UNIT = slp->lun << 3;
! 316: iopb->iopb_UNIT |= slp->target;
! 317: iopb->iopb_NVCT = (u_char)sc->sc_nvec;
! 318: iopb->iopb_EVCT = (u_char)sc->sc_evec;
! 319:
! 320: /*
! 321: * Since the 88k's don't support cache snooping, we have
! 322: * to flush the cache for a write and flush with inval for
! 323: * a read, prior to starting the IO.
! 324: */
! 325: if (xs->flags & SCSI_DATA_IN) { /* read */
! 326: #if defined(mvme88k)
! 327: dma_cachectl(xs->data, xs->datalen,
! 328: DMA_CACHE_SYNC_INVAL);
! 329: #endif
! 330: iopb->iopb_OPTION |= OPT_READ;
! 331: } else { /* write */
! 332: #if defined(mvme88k)
! 333: dma_cachectl(xs->data, xs->datalen,
! 334: DMA_CACHE_SYNC);
! 335: #endif
! 336: iopb->iopb_OPTION |= OPT_WRITE;
! 337: }
! 338:
! 339: if (flags & SCSI_POLL) {
! 340: iopb->iopb_OPTION |= OPT_INTDIS;
! 341: iopb->iopb_LEVEL = 0;
! 342: } else {
! 343: iopb->iopb_OPTION |= OPT_INTEN;
! 344: iopb->iopb_LEVEL = sc->sc_ipl;
! 345: }
! 346: iopb->iopb_ADDR = ADDR_MOD;
! 347:
! 348: /*
! 349: * Wait until we can use the command queue entry.
! 350: * Should only have to wait if the master command
! 351: * queue entry is busy.
! 352: */
! 353: while (cqep->cqe_QECR & M_QECR_GO);
! 354:
! 355: cqep->cqe_IOPB_ADDR = OFF(iopb);
! 356: cqep->cqe_IOPB_LENGTH = iopb_len;
! 357: if (flags & SCSI_POLL) {
! 358: cqep->cqe_WORK_QUEUE = slp->target + 1;
! 359: } else {
! 360: cqep->cqe_WORK_QUEUE = slp->target + 1;
! 361: }
! 362:
! 363: MALLOC(m328_cmd, M328_CMD*, sizeof(M328_CMD), M_DEVBUF, M_WAITOK);
! 364:
! 365: m328_cmd->xs = xs;
! 366: if (xs->datalen) {
! 367: m328_cmd->top_sg_list = vs_build_memory_structure(xs, iopb);
! 368: } else {
! 369: m328_cmd->top_sg_list = (M328_SG)0;
! 370: }
! 371:
! 372: LV(cqep->cqe_CTAG, m328_cmd);
! 373:
! 374: if (crb->crb_CRSW & M_CRSW_AQ) {
! 375: cqep->cqe_QECR = M_QECR_AA;
! 376: }
! 377: VL(buf, iopb->iopb_BUFF);
! 378: VL(len, iopb->iopb_LENGTH);
! 379: #ifdef SDEBUG
! 380: printf("tgt %d lun %d buf %x len %d wqn %d ipl %d\n", slp->target,
! 381: slp->lun, buf, len, cqep->cqe_WORK_QUEUE, iopb->iopb_LEVEL);
! 382: #endif
! 383: cqep->cqe_QECR |= M_QECR_GO;
! 384:
! 385: if (flags & SCSI_POLL) {
! 386: /* poll for the command to complete */
! 387: /*splx(s);*/
! 388: vs_poll(sc, xs);
! 389: return (COMPLETE);
! 390: }
! 391: /*splx(s);*/
! 392: return (SUCCESSFULLY_QUEUED);
! 393: }
! 394:
! 395: void
! 396: vs_chksense(xs)
! 397: struct scsi_xfer *xs;
! 398: {
! 399: int s;
! 400: struct scsi_link *slp = xs->sc_link;
! 401: struct vs_softc *sc = slp->adapter_softc;
! 402: struct scsi_sense *ss;
! 403: M328_CQE *mc = (M328_CQE*)&sc->sc_vsreg->sh_MCE;
! 404: M328_IOPB *riopb = (M328_IOPB *)&sc->sc_vsreg->sh_RET_IOPB;
! 405: M328_IOPB *miopb = (M328_IOPB *)&sc->sc_vsreg->sh_MCE_IOPB;
! 406:
! 407: /* ack and clear the error */
! 408: CRB_CLR_DONE(CRSW);
! 409: CRB_CLR_ER(CRSW);
! 410: xs->status = 0;
! 411:
! 412: szero(miopb, sizeof(M328_IOPB));
! 413: /* This is a command, so point to it */
! 414: ss = (void *)&miopb->iopb_SCSI[0];
! 415: szero(ss, sizeof(*ss));
! 416: ss->opcode = REQUEST_SENSE;
! 417: ss->byte2 = slp->lun << 5;
! 418: ss->length = sizeof(struct scsi_sense_data);
! 419:
! 420: miopb->iopb_CMD = IOPB_SCSI;
! 421: miopb->iopb_OPTION = OPT_READ;
! 422: miopb->iopb_NVCT = (u_char)sc->sc_nvec;
! 423: miopb->iopb_EVCT = (u_char)sc->sc_evec;
! 424: miopb->iopb_LEVEL = 0; /*sc->sc_ipl;*/
! 425: miopb->iopb_ADDR = ADDR_MOD;
! 426: LV(miopb->iopb_BUFF, kvtop((vaddr_t)&xs->sense));
! 427: LV(miopb->iopb_LENGTH, sizeof(struct scsi_sense_data));
! 428:
! 429: szero(mc, sizeof(M328_CQE));
! 430: mc->cqe_IOPB_ADDR = OFF(miopb);
! 431: mc->cqe_IOPB_LENGTH = sizeof(M328_short_IOPB) +
! 432: sizeof(struct scsi_sense);
! 433: mc->cqe_WORK_QUEUE = 0;
! 434: mc->cqe_QECR = M_QECR_GO;
! 435: /* poll for the command to complete */
! 436: s = splbio();
! 437: do_vspoll(sc, 0, 1);
! 438: /*
! 439: if (xs->cmd->opcode != PREVENT_ALLOW) {
! 440: xs->error = XS_SENSE;
! 441: }
! 442: */
! 443: xs->status = riopb->iopb_STATUS >> 8;
! 444: #ifdef SDEBUG
! 445: scsi_print_sense(xs);
! 446: #endif
! 447: splx(s);
! 448: }
! 449:
! 450: M328_CQE *
! 451: vs_getcqe(sc)
! 452: struct vs_softc *sc;
! 453: {
! 454: M328_MCSB *mcsb = (M328_MCSB *)&sc->sc_vsreg->sh_MCSB;
! 455: M328_CQE *cqep;
! 456:
! 457: cqep = (M328_CQE *)&sc->sc_vsreg->sh_CQE[mcsb->mcsb_QHDP];
! 458:
! 459: if (cqep->cqe_QECR & M_QECR_GO)
! 460: return NULL; /* Hopefully, this will never happen */
! 461: mcsb->mcsb_QHDP++;
! 462: if (mcsb->mcsb_QHDP == NUM_CQE) mcsb->mcsb_QHDP = 0;
! 463: szero(cqep, sizeof(M328_CQE));
! 464: return cqep;
! 465: }
! 466:
! 467: M328_IOPB *
! 468: vs_getiopb(sc)
! 469: struct vs_softc *sc;
! 470: {
! 471: M328_MCSB *mcsb = (M328_MCSB *)&sc->sc_vsreg->sh_MCSB;
! 472: M328_IOPB *iopb;
! 473: int slot;
! 474:
! 475: if (mcsb->mcsb_QHDP == 0) {
! 476: slot = NUM_CQE - 1;
! 477: } else {
! 478: slot = mcsb->mcsb_QHDP - 1;
! 479: }
! 480: iopb = (M328_IOPB *)&sc->sc_vsreg->sh_IOPB[slot];
! 481: szero(iopb, sizeof(M328_IOPB));
! 482: return iopb;
! 483: }
! 484:
! 485: void
! 486: vs_initialize(sc)
! 487: struct vs_softc *sc;
! 488: {
! 489: M328_CIB *cib = (M328_CIB *)&sc->sc_vsreg->sh_CIB;
! 490: M328_CQE *mc = (M328_CQE*)&sc->sc_vsreg->sh_MCE;
! 491: M328_CRB *crb = (M328_CRB *)&sc->sc_vsreg->sh_CRB;
! 492: M328_IOPB *riopb = (M328_IOPB *)&sc->sc_vsreg->sh_RET_IOPB;
! 493: M328_MCSB *mcsb = (M328_MCSB *)&sc->sc_vsreg->sh_MCSB;
! 494: M328_IOPB *iopb;
! 495: M328_WQCF *wiopb = (M328_WQCF *)&sc->sc_vsreg->sh_MCE_IOPB;
! 496: u_short i, crsw;
! 497: int failed = 0;
! 498:
! 499: CRB_CLR_DONE(CRSW);
! 500: szero(cib, sizeof(M328_CIB));
! 501: mcsb->mcsb_QHDP = 0;
! 502: sc->sc_qhp = 0;
! 503: cib->cib_NCQE = 10;
! 504: cib->cib_BURST = 0;
! 505: cib->cib_NVECT = sc->sc_ipl << 8;
! 506: cib->cib_NVECT |= sc->sc_nvec;
! 507: cib->cib_EVECT = sc->sc_ipl << 8;
! 508: cib->cib_EVECT |= sc->sc_evec;
! 509: cib->cib_PID = 0x07;
! 510: cib->cib_SID = 0x00;
! 511: cib->cib_CRBO = OFF(crb);
! 512: cib->cib_SELECT_msw = HI(SELECTION_TIMEOUT);
! 513: cib->cib_SELECT_lsw = LO(SELECTION_TIMEOUT);
! 514: cib->cib_WQ0TIMO_msw = HI(4);
! 515: cib->cib_WQ0TIMO_lsw = LO(4);
! 516: cib->cib_VMETIMO_msw = 0; /*HI(VME_BUS_TIMEOUT);*/
! 517: cib->cib_VMETIMO_lsw = 0; /*LO(VME_BUS_TIMEOUT);*/
! 518: cib->cib_SBRIV = sc->sc_ipl << 8;
! 519: cib->cib_SBRIV |= sc->sc_evec;
! 520: cib->cib_SOF0 = 0x15;
! 521: cib->cib_SRATE0 = 100/4;
! 522: cib->cib_SOF1 = 0x0;
! 523: cib->cib_SRATE1 = 0x0;
! 524:
! 525: iopb = (M328_IOPB *)&sc->sc_vsreg->sh_MCE_IOPB;
! 526: szero(iopb, sizeof(M328_IOPB));
! 527: iopb->iopb_CMD = CNTR_INIT;
! 528: iopb->iopb_OPTION = 0;
! 529: iopb->iopb_NVCT = (u_char)sc->sc_nvec;
! 530: iopb->iopb_EVCT = (u_char)sc->sc_evec;
! 531: iopb->iopb_LEVEL = 0; /*sc->sc_ipl;*/
! 532: iopb->iopb_ADDR = SHIO_MOD;
! 533: LV(iopb->iopb_BUFF, OFF(cib));
! 534: LV(iopb->iopb_LENGTH, sizeof(M328_CIB));
! 535:
! 536: szero(mc, sizeof(M328_CQE));
! 537: mc->cqe_IOPB_ADDR = OFF(iopb);
! 538: mc->cqe_IOPB_LENGTH = sizeof(M328_IOPB);
! 539: mc->cqe_WORK_QUEUE = 0;
! 540: mc->cqe_QECR = M_QECR_GO;
! 541: /* poll for the command to complete */
! 542: do_vspoll(sc, 0, 1);
! 543: CRB_CLR_DONE(CRSW);
! 544:
! 545: /* initialize work queues */
! 546: for (i=1; i<8; i++) {
! 547: szero(wiopb, sizeof(M328_IOPB));
! 548: wiopb->wqcf_CMD = CNTR_INIT_WORKQ;
! 549: wiopb->wqcf_OPTION = 0;
! 550: wiopb->wqcf_NVCT = (u_char)sc->sc_nvec;
! 551: wiopb->wqcf_EVCT = (u_char)sc->sc_evec;
! 552: wiopb->wqcf_ILVL = 0; /*sc->sc_ipl;*/
! 553: wiopb->wqcf_WORKQ = i;
! 554: wiopb->wqcf_WOPT = (WQO_FOE | WQO_INIT);
! 555: wiopb->wqcf_SLOTS = JAGUAR_MAX_Q_SIZ;
! 556: LV(wiopb->wqcf_CMDTO, 2);
! 557:
! 558: szero(mc, sizeof(M328_CQE));
! 559: mc->cqe_IOPB_ADDR = OFF(wiopb);
! 560: mc->cqe_IOPB_LENGTH = sizeof(M328_IOPB);
! 561: mc->cqe_WORK_QUEUE = 0;
! 562: mc->cqe_QECR = M_QECR_GO;
! 563: /* poll for the command to complete */
! 564: do_vspoll(sc, 0, 1);
! 565: if (CRSW & M_CRSW_ER) {
! 566: /*printf("\nerror: queue %d status = 0x%x\n",
! 567: i, riopb->iopb_STATUS);*/
! 568: /*failed = 1;*/
! 569: CRB_CLR_ER(CRSW);
! 570: }
! 571: CRB_CLR_DONE(CRSW);
! 572: delay(500);
! 573: }
! 574: /* start queue mode */
! 575: CRSW = 0;
! 576: mcsb->mcsb_MCR |= M_MCR_SQM;
! 577: crsw = CRSW;
! 578: do_vspoll(sc, 0, 1);
! 579: if (CRSW & M_CRSW_ER) {
! 580: printf("error: status = 0x%x\n", riopb->iopb_STATUS);
! 581: CRB_CLR_ER(CRSW);
! 582: }
! 583: CRB_CLR_DONE(CRSW);
! 584:
! 585: if (failed) {
! 586: printf(": failed!\n");
! 587: return;
! 588: }
! 589: /* reset SCSI bus */
! 590: vs_reset(sc);
! 591: /* sync all devices */
! 592: vs_resync(sc);
! 593: printf(": target %d\n", sc->sc_link.adapter_target);
! 594: }
! 595:
! 596: void
! 597: vs_resync(sc)
! 598: struct vs_softc *sc;
! 599: {
! 600: M328_CQE *mc = (M328_CQE*)&sc->sc_vsreg->sh_MCE;
! 601: M328_IOPB *riopb = (M328_IOPB *)&sc->sc_vsreg->sh_RET_IOPB;
! 602: M328_DRCF *devreset = (M328_DRCF *)&sc->sc_vsreg->sh_MCE_IOPB;
! 603: u_short i;
! 604:
! 605: for (i=0; i<7; i++) {
! 606: szero(devreset, sizeof(M328_DRCF));
! 607: devreset->drcf_CMD = CNTR_DEV_REINIT;
! 608: devreset->drcf_OPTION = 0x00; /* no interrupts yet... */
! 609: devreset->drcf_NVCT = sc->sc_nvec;
! 610: devreset->drcf_EVCT = sc->sc_evec;
! 611: devreset->drcf_ILVL = 0;
! 612: devreset->drcf_UNIT = i;
! 613:
! 614: szero(mc, sizeof(M328_CQE));
! 615: mc->cqe_IOPB_ADDR = OFF(devreset);
! 616: mc->cqe_IOPB_LENGTH = sizeof(M328_DRCF);
! 617: mc->cqe_WORK_QUEUE = 0;
! 618: mc->cqe_QECR = M_QECR_GO;
! 619: /* poll for the command to complete */
! 620: do_vspoll(sc, 0, 0);
! 621: if (riopb->iopb_STATUS) {
! 622: sc->sc_tinfo[i].avail = 0;
! 623: } else {
! 624: sc->sc_tinfo[i].avail = 1;
! 625: }
! 626: if (CRSW & M_CRSW_ER) {
! 627: CRB_CLR_ER(CRSW);
! 628: }
! 629: CRB_CLR_DONE(CRSW);
! 630: }
! 631: }
! 632:
! 633: void
! 634: vs_reset(sc)
! 635: struct vs_softc *sc;
! 636: {
! 637: u_int s;
! 638: M328_CQE *mc = (M328_CQE*)&sc->sc_vsreg->sh_MCE;
! 639: M328_IOPB *riopb = (M328_IOPB *)&sc->sc_vsreg->sh_RET_IOPB;
! 640: M328_SRCF *reset = (M328_SRCF *)&sc->sc_vsreg->sh_MCE_IOPB;
! 641:
! 642: szero(reset, sizeof(M328_SRCF));
! 643: reset->srcf_CMD = IOPB_RESET;
! 644: reset->srcf_OPTION = 0x00; /* no interrupts yet... */
! 645: reset->srcf_NVCT = sc->sc_nvec;
! 646: reset->srcf_EVCT = sc->sc_evec;
! 647: reset->srcf_ILVL = 0;
! 648: reset->srcf_BUSID = 0;
! 649: s = splbio();
! 650:
! 651: szero(mc, sizeof(M328_CQE));
! 652: mc->cqe_IOPB_ADDR = OFF(reset);
! 653: mc->cqe_IOPB_LENGTH = sizeof(M328_SRCF);
! 654: mc->cqe_WORK_QUEUE = 0;
! 655: mc->cqe_QECR = M_QECR_GO;
! 656: /* poll for the command to complete */
! 657: for (;;) {
! 658: do_vspoll(sc, 0, 0);
! 659: /* ack & clear scsi error condition cause by reset */
! 660: if (CRSW & M_CRSW_ER) {
! 661: CRB_CLR_ER(CRSW);
! 662: CRB_CLR_DONE(CRSW);
! 663: riopb->iopb_STATUS = 0;
! 664: break;
! 665: }
! 666: CRB_CLR_DONE(CRSW);
! 667: }
! 668: /* thaw all work queues */
! 669: thaw_queue(sc, 0xFF);
! 670: splx(s);
! 671: }
! 672:
! 673: /*
! 674: * Process an interrupt from the MVME328
! 675: * We'll generally update: xs->{flags,resid,error,sense,status} and
! 676: * occasionally xs->retries.
! 677: */
! 678:
! 679: int
! 680: vs_checkintr(sc, xs, status)
! 681: struct vs_softc *sc;
! 682: struct scsi_xfer *xs;
! 683: int *status;
! 684: {
! 685: int target = -1;
! 686: int lun = -1;
! 687: M328_IOPB *riopb = (M328_IOPB *)&sc->sc_vsreg->sh_RET_IOPB;
! 688: struct scsi_generic *cmd;
! 689: u_long buf;
! 690: u_long len;
! 691: u_char error;
! 692:
! 693: target = xs->sc_link->target;
! 694: lun = xs->sc_link->lun;
! 695: cmd = (struct scsi_generic *)&riopb->iopb_SCSI[0];
! 696:
! 697: VL(buf, riopb->iopb_BUFF);
! 698: VL(len, riopb->iopb_LENGTH);
! 699: *status = riopb->iopb_STATUS >> 8;
! 700: error = riopb->iopb_STATUS & 0xFF;
! 701:
! 702: #ifdef SDEBUG
! 703: printf("scsi_chk() ");
! 704:
! 705: if (xs->cmd->opcode == 0) {
! 706: printf("TEST_UNIT_READY ");
! 707: } else if (xs->cmd->opcode == REQUEST_SENSE) {
! 708: printf("REQUEST_SENSE ");
! 709: } else if (xs->cmd->opcode == INQUIRY) {
! 710: printf("INQUIRY ");
! 711: } else if (xs->cmd->opcode == MODE_SELECT) {
! 712: printf("MODE_SELECT ");
! 713: } else if (xs->cmd->opcode == MODE_SENSE) {
! 714: printf("MODE_SENSE ");
! 715: } else if (xs->cmd->opcode == START_STOP) {
! 716: printf("START_STOP ");
! 717: } else if (xs->cmd->opcode == RESERVE) {
! 718: printf("RESERVE ");
! 719: } else if (xs->cmd->opcode == RELEASE) {
! 720: printf("RELEASE ");
! 721: } else if (xs->cmd->opcode == PREVENT_ALLOW) {
! 722: printf("PREVENT_ALLOW ");
! 723: } else if (xs->cmd->opcode == POSITION_TO_ELEMENT) {
! 724: printf("POSITION_TO_EL ");
! 725: } else if (xs->cmd->opcode == CHANGE_DEFINITION) {
! 726: printf("CHANGE_DEF ");
! 727: } else if (xs->cmd->opcode == MODE_SENSE_BIG) {
! 728: printf("MODE_SENSE_BIG ");
! 729: } else if (xs->cmd->opcode == MODE_SELECT_BIG) {
! 730: printf("MODE_SELECT_BIG ");
! 731: } else if (xs->cmd->opcode == 0x25) {
! 732: printf("READ_CAPACITY ");
! 733: } else if (xs->cmd->opcode == 0x08) {
! 734: printf("READ_COMMAND ");
! 735: }
! 736:
! 737: printf("tgt %d lun %d buf %x len %d status %x ",
! 738: target, lun, buf, len, riopb->iopb_STATUS);
! 739:
! 740: if (CRSW & M_CRSW_EX) {
! 741: printf("[ex]");
! 742: }
! 743: if (CRSW & M_CRSW_QMS) {
! 744: printf("[qms]");
! 745: }
! 746: if (CRSW & M_CRSW_SC) {
! 747: printf("[sc]");
! 748: }
! 749: if (CRSW & M_CRSW_SE) {
! 750: printf("[se]");
! 751: }
! 752: if (CRSW & M_CRSW_AQ) {
! 753: printf("[aq]");
! 754: }
! 755: if (CRSW & M_CRSW_ER) {
! 756: printf("[er]");
! 757: }
! 758: printf("\n");
! 759: #endif
! 760: if (len != xs->datalen) {
! 761: xs->resid = xs->datalen - len;
! 762: } else {
! 763: xs->resid = 0;
! 764: }
! 765:
! 766: if (error == SCSI_SELECTION_TO) {
! 767: xs->error = XS_SELTIMEOUT;
! 768: xs->status = -1;
! 769: *status = -1;
! 770: }
! 771: return 1;
! 772: }
! 773:
! 774: void
! 775: vs_intr(arg)
! 776: void *arg;
! 777: {
! 778: struct vs_softc *sc = (struct vs_softc *)arg;
! 779: M328_CRB *crb = (M328_CRB *)&sc->sc_vsreg->sh_CRB;
! 780: struct scsi_xfer *xs;
! 781: M328_CMD *m328_cmd;
! 782: unsigned long loc;
! 783: int status;
! 784: int s;
! 785:
! 786: s = splbio();
! 787: /* Got a valid interrupt on this device */
! 788:
! 789: VL(loc, crb->crb_CTAG);
! 790: #ifdef SDEBUG
! 791: printf("Interrupt!!! ");
! 792: printf("loc == 0x%x\n", loc);
! 793: #endif
! 794: /*
! 795: * If this is a controller error, there won't be a m328_cmd
! 796: * pointer in the CTAG field. Bad things happen if you try
! 797: * to point to address 0. Controller error should be handled
! 798: * in vsdma.c I'll change this soon - steve.
! 799: */
! 800: if (loc) {
! 801: m328_cmd = (M328_CMD *)loc;
! 802: xs = m328_cmd->xs;
! 803: if (m328_cmd->top_sg_list) {
! 804: vs_dealloc_scatter_gather(m328_cmd->top_sg_list);
! 805: m328_cmd->top_sg_list = (M328_SG)0;
! 806: }
! 807:
! 808: FREE(m328_cmd, M_DEVBUF); /* free the command tag */
! 809: if (vs_checkintr (sc, xs, &status)) {
! 810: vs_scsidone(xs, status);
! 811: }
! 812: }
! 813: splx(s);
! 814: }
! 815:
! 816: /*
! 817: * Useful functions for scatter/gather list
! 818: */
! 819:
! 820: M328_SG
! 821: vs_alloc_scatter_gather()
! 822: {
! 823: M328_SG sg;
! 824:
! 825: MALLOC(sg, M328_SG, sizeof(struct m328_sg), M_DEVBUF, M_WAITOK);
! 826: bzero(sg, sizeof(struct m328_sg));
! 827:
! 828: return (sg);
! 829: }
! 830:
! 831: void
! 832: vs_dealloc_scatter_gather(sg)
! 833: M328_SG sg;
! 834: {
! 835: int i;
! 836:
! 837: if (sg->level > 0) {
! 838: for (i = 0; sg->down[i] && i<MAX_SG_ELEMENTS; i++) {
! 839: vs_dealloc_scatter_gather(sg->down[i]);
! 840: }
! 841: }
! 842: FREE(sg, M_DEVBUF);
! 843: }
! 844:
! 845: void
! 846: vs_link_sg_element(element, phys_add, len)
! 847: sg_list_element_t *element;
! 848: vaddr_t phys_add;
! 849: int len;
! 850: {
! 851:
! 852: element->count.bytes = len;
! 853: LV(element->address, phys_add);
! 854: element->link = 0; /* FALSE */
! 855: element->transfer_type = NORMAL_TYPE;
! 856: element->memory_type = LONG_TRANSFER;
! 857: element->address_modifier = 0xD;
! 858: }
! 859:
! 860: void
! 861: vs_link_sg_list(list, phys_add, elements)
! 862: sg_list_element_t *list;
! 863: vaddr_t phys_add;
! 864: int elements;
! 865: {
! 866:
! 867: list->count.scatter.gather = elements;
! 868: LV(list->address, phys_add);
! 869: list->link = 1; /* TRUE */
! 870: list->transfer_type = NORMAL_TYPE;
! 871: list->memory_type = LONG_TRANSFER;
! 872: list->address_modifier = 0xD;
! 873: }
! 874:
! 875: M328_SG
! 876: vs_build_memory_structure(xs, iopb)
! 877: struct scsi_xfer *xs;
! 878: M328_IOPB *iopb; /* the iopb */
! 879: {
! 880: M328_SG sg;
! 881: vaddr_t starting_point_virt, point_virt, virt;
! 882: paddr_t starting_point_phys, point1_phys, point2_phys;
! 883: u_int len;
! 884: int level;
! 885:
! 886: sg = (M328_SG)0; /* Hopefully we need no scatter/gather list */
! 887:
! 888: /*
! 889: * We have the following things:
! 890: * virt the virtual address of the contiguous virtual
! 891: * memory block
! 892: * len the length of the contiguous virtual memory
! 893: * block
! 894: * starting_point_virt the virtual address of the contiguous
! 895: * *physical* memory block
! 896: * starting_point_phys the *physical* address of the contiguous
! 897: * *physical* memory block
! 898: * point_virt the pointer to the virtual memory we are
! 899: * checking at the moment
! 900: * point1_phys the pointer to the *physical* memory we are
! 901: * checking at the moment
! 902: * point2_phys the pointer to the *physical* memory we are
! 903: * checking at the moment
! 904: */
! 905:
! 906: level = 0;
! 907: virt = starting_point_virt = (vaddr_t)xs->data;
! 908: point1_phys = starting_point_phys = kvtop((vaddr_t)xs->data);
! 909: len = xs->datalen;
! 910:
! 911: /*
! 912: * Check if we need scatter/gather
! 913: */
! 914: if (len > PAGE_SIZE) {
! 915: for (level = 0, point_virt = round_page(starting_point_virt+1);
! 916: /* if we do already scatter/gather we have to stay in
! 917: the loop and jump */
! 918: point_virt < virt + (vaddr_t)len || sg;
! 919: point_virt += PAGE_SIZE) { /* out later */
! 920:
! 921: point2_phys = kvtop(point_virt);
! 922:
! 923: if ((point2_phys - trunc_page(point1_phys) - PAGE_SIZE) ||
! 924: /* physical memory is not contiguous */
! 925: (point_virt - starting_point_virt >=
! 926: MAX_SG_BLOCK_SIZE && sg)) {
! 927: /* we only can access (1<<16)-1 bytes in
! 928: scatter/gather_mode */
! 929: if (point_virt - starting_point_virt >=
! 930: MAX_SG_BLOCK_SIZE) {
! 931: /* We were walking too far for one
! 932: scatter/gather block ... */
! 933: assert( MAX_SG_BLOCK_SIZE > PAGE_SIZE );
! 934: point_virt =
! 935: trunc_page(starting_point_virt +
! 936: MAX_SG_BLOCK_SIZE-1);
! 937: /* So go back to the beginning of the
! 938: last matching page and generate the
! 939: physical address of this location
! 940: for the next time. */
! 941: point2_phys = kvtop(point_virt);
! 942: }
! 943:
! 944: if (!sg) {
! 945: /* We allocate our fist scatter/gather
! 946: list */
! 947: sg = vs_alloc_scatter_gather();
! 948: }
! 949: #if 1 /* broken firmware */
! 950: if (sg->elements >= MAX_SG_ELEMENTS) {
! 951: vs_dealloc_scatter_gather(sg);
! 952: return (NULL);
! 953: }
! 954: #else /* if the firmware will ever get fixed */
! 955: while (sg->elements >= MAX_SG_ELEMENTS) {
! 956: /* If the list full in this layer ? */
! 957: if (!sg->up) {
! 958: sg->up =
! 959: vs_alloc_scatter_gather();
! 960: sg->up->level = sg->level+1;
! 961: sg->up->down[0] = sg;
! 962: sg->up->elements = 1;
! 963: }
! 964: /* link this full list also in physical
! 965: memory */
! 966: vs_link_sg_list(
! 967: &(sg->up->list[
! 968: sg->up->elements - 1]),
! 969: kvtop((vaddr_t)sg->list),
! 970: sg->elements);
! 971: sg = sg->up; /* Climb up */
! 972: }
! 973: /* As long as we are not a the base level */
! 974: while (sg->level) {
! 975: int i;
! 976:
! 977: i = sg->elements;
! 978: /* We need a new element */
! 979: sg->down[i] =
! 980: vs_alloc_scatter_gather();
! 981: sg->down[i]->level = sg->level - 1;
! 982: sg->down[i]->up = sg;
! 983: sg->elements++;
! 984: sg = sg->down[i]; /* Climb down */
! 985: }
! 986: #endif /* 1 */
! 987:
! 988: if (point_virt < virt+(vaddr_t)len) {
! 989: /* linking element */
! 990: vs_link_sg_element(
! 991: &(sg->list[sg->elements]),
! 992: starting_point_phys,
! 993: point_virt-starting_point_virt);
! 994: sg->elements++;
! 995: } else {
! 996: /* linking last element */
! 997: vs_link_sg_element(
! 998: &(sg->list[sg->elements]),
! 999: starting_point_phys,
! 1000: (vaddr_t)(virt + len) -
! 1001: starting_point_virt);
! 1002: sg->elements++;
! 1003: break;
! 1004: /* We have now collected all blocks */
! 1005: }
! 1006: starting_point_virt = point_virt;
! 1007: starting_point_phys = point2_phys;
! 1008: }
! 1009: point1_phys = point2_phys;
! 1010: }
! 1011: }
! 1012:
! 1013: /*
! 1014: * Climb up along the right side of the tree until we reach the top.
! 1015: */
! 1016:
! 1017: if (sg) {
! 1018: while (sg->up) {
! 1019: /* link this list also in physical memory */
! 1020: vs_link_sg_list(&(sg->up->list[sg->up->elements-1]),
! 1021: kvtop((vaddr_t)sg->list), sg->elements);
! 1022: sg = sg->up; /* Climb up */
! 1023: }
! 1024:
! 1025: iopb->iopb_OPTION |= M_OPT_SG;
! 1026: iopb->iopb_ADDR |= M_ADR_SG_LINK;
! 1027: LV(iopb->iopb_BUFF, kvtop((vaddr_t)sg->list));
! 1028: LV(iopb->iopb_LENGTH, sg->elements);
! 1029: LV(iopb->iopb_SGTTL, len);
! 1030: } else {
! 1031: /* no scatter/gather necessary */
! 1032: LV(iopb->iopb_BUFF, starting_point_phys);
! 1033: LV(iopb->iopb_LENGTH, len);
! 1034: }
! 1035: return (sg);
! 1036: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to vs.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mvme68k / dev