Annotation of sys/arch/mvme88k/dev/vs.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: vs.c,v 1.64 2006/12/01 19:36:09 miod Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2004, Miodrag Vallat.
! 5: * Copyright (c) 1999 Steve Murphree, Jr.
! 6: * Copyright (c) 1990 The Regents of the University of California.
! 7: * All rights reserved.
! 8: *
! 9: * This code is derived from software contributed to Berkeley by
! 10: * Van Jacobson of Lawrence Berkeley Laboratory.
! 11: *
! 12: * Redistribution and use in source and binary forms, with or without
! 13: * modification, are permitted provided that the following conditions
! 14: * are met:
! 15: * 1. Redistributions of source code must retain the above copyright
! 16: * notice, this list of conditions and the following disclaimer.
! 17: * 2. Redistributions in binary form must reproduce the above copyright
! 18: * notice, this list of conditions and the following disclaimer in the
! 19: * documentation and/or other materials provided with the distribution.
! 20: * 3. Neither the name of the University nor the names of its contributors
! 21: * may be used to endorse or promote products derived from this software
! 22: * without specific prior written permission.
! 23: *
! 24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 34: * SUCH DAMAGE.
! 35: */
! 36:
! 37: /*
! 38: * MVME328S SCSI adaptor driver
! 39: */
! 40:
! 41: /* This card lives in D16 space */
! 42: #define __BUS_SPACE_RESTRICT_D16__
! 43:
! 44: #include <sys/param.h>
! 45: #include <sys/systm.h>
! 46: #include <sys/device.h>
! 47: #include <sys/disklabel.h>
! 48: #include <sys/dkstat.h>
! 49: #include <sys/buf.h>
! 50: #include <sys/malloc.h>
! 51:
! 52: #include <uvm/uvm_extern.h>
! 53:
! 54: #include <scsi/scsi_all.h>
! 55: #include <scsi/scsiconf.h>
! 56:
! 57: #include <machine/autoconf.h>
! 58: #include <machine/cmmu.h>
! 59: #include <machine/cpu.h>
! 60:
! 61: #include <mvme88k/dev/vsreg.h>
! 62: #include <mvme88k/dev/vsvar.h>
! 63: #include <mvme88k/dev/vme.h>
! 64:
! 65: int vsmatch(struct device *, void *, void *);
! 66: void vsattach(struct device *, struct device *, void *);
! 67: int vs_scsicmd(struct scsi_xfer *);
! 68:
! 69: struct scsi_adapter vs_scsiswitch = {
! 70: vs_scsicmd,
! 71: minphys,
! 72: 0, /* no lun support */
! 73: 0, /* no lun support */
! 74: };
! 75:
! 76: struct scsi_device vs_scsidev = {
! 77: NULL, /* use default error handler */
! 78: NULL, /* do not have a start function */
! 79: NULL, /* have no async handler */
! 80: NULL, /* Use default done routine */
! 81: };
! 82:
! 83: struct cfattach vs_ca = {
! 84: sizeof(struct vs_softc), vsmatch, vsattach,
! 85: };
! 86:
! 87: struct cfdriver vs_cd = {
! 88: NULL, "vs", DV_DULL,
! 89: };
! 90:
! 91: int do_vspoll(struct vs_softc *, struct scsi_xfer *, int);
! 92: void thaw_queue(struct vs_softc *, int);
! 93: void thaw_all_queues(struct vs_softc *);
! 94: M328_SG vs_alloc_scatter_gather(void);
! 95: M328_SG vs_build_memory_structure(struct vs_softc *, struct scsi_xfer *,
! 96: bus_addr_t);
! 97: void vs_chksense(struct scsi_xfer *);
! 98: void vs_dealloc_scatter_gather(M328_SG);
! 99: int vs_eintr(void *);
! 100: bus_addr_t vs_getcqe(struct vs_softc *);
! 101: bus_addr_t vs_getiopb(struct vs_softc *);
! 102: int vs_initialize(struct vs_softc *);
! 103: int vs_intr(struct vs_softc *);
! 104: void vs_link_sg_element(sg_list_element_t *, vaddr_t, int);
! 105: void vs_link_sg_list(sg_list_element_t *, vaddr_t, int);
! 106: int vs_nintr(void *);
! 107: int vs_poll(struct vs_softc *, struct vs_cb *);
! 108: void vs_print_addr(struct vs_softc *, struct scsi_xfer *);
! 109: struct vs_cb *vs_find_queue(struct scsi_link *, struct vs_softc *);
! 110: void vs_reset(struct vs_softc *, int);
! 111: void vs_resync(struct vs_softc *);
! 112: void vs_scsidone(struct vs_softc *, struct vs_cb *);
! 113:
! 114: static __inline__ void vs_free(struct vs_cb *);
! 115: static __inline__ void vs_clear_return_info(struct vs_softc *);
! 116: static __inline__ paddr_t kvtop(vaddr_t);
! 117:
! 118: int
! 119: vsmatch(struct device *device, void *cf, void *args)
! 120: {
! 121: struct confargs *ca = args;
! 122: bus_space_tag_t iot = ca->ca_iot;
! 123: bus_space_handle_t ioh;
! 124: int rc;
! 125:
! 126: if (bus_space_map(iot, ca->ca_paddr, S_SHORTIO, 0, &ioh) != 0)
! 127: return 0;
! 128: rc = badaddr((vaddr_t)bus_space_vaddr(iot, ioh), 1);
! 129: bus_space_unmap(iot, ioh, S_SHORTIO);
! 130:
! 131: return rc == 0;
! 132: }
! 133:
! 134: void
! 135: vsattach(struct device *parent, struct device *self, void *args)
! 136: {
! 137: struct vs_softc *sc = (struct vs_softc *)self;
! 138: struct confargs *ca = args;
! 139: struct scsi_link *sc_link;
! 140: struct scsibus_attach_args saa;
! 141: int evec, bus;
! 142: int tmp;
! 143:
! 144: /* get the next available vector for the error interrupt */
! 145: evec = vme_findvec(ca->ca_vec);
! 146:
! 147: if (ca->ca_vec < 0 || evec < 0) {
! 148: printf(": no more interrupts!\n");
! 149: return;
! 150: }
! 151: if (ca->ca_ipl < 0)
! 152: ca->ca_ipl = IPL_BIO;
! 153:
! 154: printf(" vec 0x%x: ", evec);
! 155:
! 156: sc->sc_paddr = ca->ca_paddr;
! 157: sc->sc_iot = ca->ca_iot;
! 158: if (bus_space_map(sc->sc_iot, sc->sc_paddr, S_SHORTIO, 0,
! 159: &sc->sc_ioh) != 0) {
! 160: printf("can't map registers!\n");
! 161: return;
! 162: }
! 163:
! 164: sc->sc_ipl = ca->ca_ipl;
! 165: sc->sc_nvec = ca->ca_vec;
! 166: sc->sc_evec = evec;
! 167:
! 168: if (vs_initialize(sc))
! 169: return;
! 170:
! 171: sc->sc_ih_n.ih_fn = vs_nintr;
! 172: sc->sc_ih_n.ih_arg = sc;
! 173: sc->sc_ih_n.ih_wantframe = 0;
! 174: sc->sc_ih_n.ih_ipl = ca->ca_ipl;
! 175:
! 176: sc->sc_ih_e.ih_fn = vs_eintr;
! 177: sc->sc_ih_e.ih_arg = sc;
! 178: sc->sc_ih_e.ih_wantframe = 0;
! 179: sc->sc_ih_e.ih_ipl = ca->ca_ipl;
! 180:
! 181: vmeintr_establish(sc->sc_nvec, &sc->sc_ih_n, self->dv_xname);
! 182: snprintf(sc->sc_intrname_e, sizeof sc->sc_intrname_e,
! 183: "%s_err", self->dv_xname);
! 184: vmeintr_establish(sc->sc_evec, &sc->sc_ih_e, sc->sc_intrname_e);
! 185:
! 186: printf("SCSI ID");
! 187:
! 188: for (bus = 0; bus < 2; bus++) {
! 189: if (sc->sc_id[bus] < 0)
! 190: continue;
! 191:
! 192: sc_link = &sc->sc_link[bus];
! 193: sc_link->adapter = &vs_scsiswitch;
! 194: sc_link->adapter_buswidth = 8;
! 195: sc_link->adapter_softc = sc;
! 196: sc_link->adapter_target = sc->sc_id[bus];
! 197: sc_link->device = &vs_scsidev;
! 198: #if 0
! 199: sc_link->luns = 1;
! 200: #endif
! 201: sc_link->openings = NUM_IOPB / 8;
! 202: if (bus != 0)
! 203: sc_link->flags = SDEV_2NDBUS;
! 204:
! 205: printf("%c%d", bus == 0 ? ' ' : '/', sc->sc_id[bus]);
! 206: }
! 207:
! 208: printf("\n");
! 209:
! 210: /*
! 211: * Attach all scsi units on us, watching for boot device
! 212: * (see device_register).
! 213: */
! 214: tmp = bootpart;
! 215: if (sc->sc_paddr != bootaddr)
! 216: bootpart = -1; /* invalid flag to device_register */
! 217:
! 218: for (bus = 0; bus < 2; bus++) {
! 219: if (sc->sc_id[bus] < 0)
! 220: continue;
! 221:
! 222: bzero(&saa, sizeof(saa));
! 223: saa.saa_sc_link = &sc->sc_link[bus];
! 224:
! 225: bootbus = bus;
! 226: config_found(self, &saa, scsiprint);
! 227: }
! 228:
! 229: bootpart = tmp; /* restore old values */
! 230: bootbus = 0;
! 231: }
! 232:
! 233: void
! 234: vs_print_addr(struct vs_softc *sc, struct scsi_xfer *xs)
! 235: {
! 236: if (xs == NULL)
! 237: printf("%s: ", sc->sc_dev.dv_xname);
! 238: else {
! 239: sc_print_addr(xs->sc_link);
! 240:
! 241: /* print bus number too if appropriate */
! 242: if (sc->sc_id[1] >= 0)
! 243: printf("(bus %d) ",
! 244: !!(xs->sc_link->flags & SDEV_2NDBUS));
! 245: }
! 246: }
! 247:
! 248: int
! 249: do_vspoll(struct vs_softc *sc, struct scsi_xfer *xs, int canreset)
! 250: {
! 251: int to;
! 252: int crsw, bus;
! 253:
! 254: if (xs != NULL) {
! 255: bus = !!(xs->sc_link->flags & SDEV_2NDBUS);
! 256: to = xs->timeout;
! 257: if (to == 0)
! 258: to = 2000;
! 259: } else {
! 260: bus = -1;
! 261: to = 2000;
! 262: }
! 263:
! 264: while (((crsw = CRSW) & (M_CRSW_CRBV | M_CRSW_CC)) == 0) {
! 265: if (to-- <= 0) {
! 266: vs_print_addr(sc, xs);
! 267: printf("command timeout, crsw 0x%x\n", crsw);
! 268:
! 269: if (canreset) {
! 270: vs_reset(sc, bus);
! 271: vs_resync(sc);
! 272: }
! 273: return 1;
! 274: }
! 275: delay(1000);
! 276: }
! 277: return 0;
! 278: }
! 279:
! 280: int
! 281: vs_poll(struct vs_softc *sc, struct vs_cb *cb)
! 282: {
! 283: struct scsi_xfer *xs;
! 284: int s;
! 285: int rc;
! 286:
! 287: xs = cb->cb_xs;
! 288: rc = do_vspoll(sc, xs, 1);
! 289:
! 290: s = splbio();
! 291: if (rc != 0) {
! 292: xs->error = XS_SELTIMEOUT;
! 293: xs->status = -1;
! 294: xs->flags |= ITSDONE;
! 295: #if 0
! 296: scsi_done(xs);
! 297: #endif
! 298: vs_free(cb);
! 299: } else
! 300: vs_scsidone(sc, cb);
! 301: splx(s);
! 302:
! 303: if (CRSW & M_CRSW_ER)
! 304: CRB_CLR_ER;
! 305: CRB_CLR_DONE;
! 306:
! 307: vs_clear_return_info(sc);
! 308: return (COMPLETE);
! 309: }
! 310:
! 311: void
! 312: thaw_queue(struct vs_softc *sc, int target)
! 313: {
! 314: THAW(target);
! 315:
! 316: /* loop until thawed */
! 317: while (THAW_REG & M_THAW_TWQE)
! 318: ;
! 319: }
! 320:
! 321: void
! 322: thaw_all_queues(struct vs_softc *sc)
! 323: {
! 324: int i;
! 325:
! 326: for (i = 1; i < NUM_WQ; i++)
! 327: thaw_queue(sc, i);
! 328: }
! 329:
! 330: void
! 331: vs_scsidone(struct vs_softc *sc, struct vs_cb *cb)
! 332: {
! 333: struct scsi_xfer *xs = cb->cb_xs;
! 334: u_int32_t len;
! 335: int error;
! 336:
! 337: len = vs_read(4, sh_RET_IOPB + IOPB_LENGTH);
! 338: xs->resid = xs->datalen - len;
! 339:
! 340: error = vs_read(2, sh_RET_IOPB + IOPB_STATUS);
! 341: if ((error & 0xff) == SCSI_SELECTION_TO) {
! 342: xs->error = XS_SELTIMEOUT;
! 343: xs->status = -1;
! 344: } else
! 345: xs->status = error >> 8;
! 346:
! 347: while (xs->status == SCSI_CHECK) {
! 348: vs_chksense(xs);
! 349: }
! 350:
! 351: xs->flags |= ITSDONE;
! 352: thaw_queue(sc, cb->cb_q);
! 353:
! 354: scsi_done(xs);
! 355:
! 356: vs_free(cb);
! 357: }
! 358:
! 359: int
! 360: vs_scsicmd(struct scsi_xfer *xs)
! 361: {
! 362: struct scsi_link *slp = xs->sc_link;
! 363: struct vs_softc *sc = slp->adapter_softc;
! 364: int flags, option;
! 365: unsigned int iopb_len;
! 366: bus_addr_t cqep, iopb;
! 367: struct vs_cb *cb;
! 368: u_int queue;
! 369: int s;
! 370:
! 371: flags = xs->flags;
! 372: if (flags & SCSI_POLL) {
! 373: cb = &sc->sc_cb[0];
! 374: cqep = sh_MCE;
! 375: iopb = sh_MCE_IOPB;
! 376:
! 377: #ifdef VS_DEBUG
! 378: if (mce_read(2, CQE_QECR) & M_QECR_GO)
! 379: printf("%s: master command queue busy\n",
! 380: sc->sc_dev.dv_xname);
! 381: #endif
! 382: /* Wait until we can use the command queue entry. */
! 383: while (mce_read(2, CQE_QECR) & M_QECR_GO)
! 384: ;
! 385: #ifdef VS_DEBUG
! 386: if (cb->cb_xs != NULL) {
! 387: printf("%s: master command not idle\n",
! 388: sc->sc_dev.dv_xname);
! 389: return (TRY_AGAIN_LATER);
! 390: }
! 391: #endif
! 392: s = splbio();
! 393: } else {
! 394: s = splbio();
! 395: cb = vs_find_queue(slp, sc);
! 396: if (cb == NULL) {
! 397: splx(s);
! 398: #ifdef VS_DEBUG
! 399: printf("%s: no free queues\n", sc->sc_dev.dv_xname);
! 400: #endif
! 401: return (TRY_AGAIN_LATER);
! 402: }
! 403: cqep = vs_getcqe(sc);
! 404: if (cqep == 0) {
! 405: splx(s);
! 406: return (TRY_AGAIN_LATER);
! 407: }
! 408: iopb = vs_getiopb(sc);
! 409: }
! 410:
! 411: queue = cb->cb_q;
! 412:
! 413: vs_bzero(iopb, IOPB_LONG_SIZE);
! 414:
! 415: /*
! 416: * We should only provide the iopb len if the controller is not
! 417: * able to compute it from the SCSI command group.
! 418: * Note that it has no knowledge of group 2.
! 419: */
! 420: switch ((xs->cmd->opcode) >> 5) {
! 421: case 0:
! 422: case 1:
! 423: case 5:
! 424: iopb_len = 0;
! 425: break;
! 426: default:
! 427: iopb_len = IOPB_SHORT_SIZE + xs->cmdlen;
! 428: break;
! 429: }
! 430:
! 431: bus_space_write_region_1(sc->sc_iot, sc->sc_ioh, iopb + IOPB_SCSI_DATA,
! 432: (u_int8_t *)xs->cmd, xs->cmdlen);
! 433:
! 434: vs_write(2, iopb + IOPB_CMD, IOPB_PASSTHROUGH);
! 435: vs_write(2, iopb + IOPB_UNIT,
! 436: IOPB_UNIT_VALUE(!!(slp->flags & SDEV_2NDBUS), slp->target, slp->lun));
! 437: vs_write(1, iopb + IOPB_NVCT, sc->sc_nvec);
! 438: vs_write(1, iopb + IOPB_EVCT, sc->sc_evec);
! 439:
! 440: /*
! 441: * Since the 88k doesn't support cache snooping, we have
! 442: * to flush the cache for a write and flush with inval for
! 443: * a read, prior to starting the IO.
! 444: */
! 445: dma_cachectl(pmap_kernel(), (vaddr_t)xs->data, xs->datalen,
! 446: flags & SCSI_DATA_IN ? DMA_CACHE_SYNC_INVAL : DMA_CACHE_SYNC);
! 447:
! 448: option = 0;
! 449: if (flags & SCSI_DATA_OUT)
! 450: option |= M_OPT_DIR;
! 451:
! 452: if (flags & SCSI_POLL) {
! 453: vs_write(2, iopb + IOPB_OPTION, option);
! 454: vs_write(2, iopb + IOPB_LEVEL, 0);
! 455: } else {
! 456: vs_write(2, iopb + IOPB_OPTION, option | M_OPT_IE);
! 457: vs_write(2, iopb + IOPB_LEVEL, sc->sc_ipl);
! 458: }
! 459: vs_write(2, iopb + IOPB_ADDR, ADDR_MOD);
! 460:
! 461: vs_write(2, cqep + CQE_IOPB_ADDR, iopb);
! 462: vs_write(1, cqep + CQE_IOPB_LENGTH, iopb_len);
! 463: vs_write(1, cqep + CQE_WORK_QUEUE, queue);
! 464:
! 465: cb->cb_xs = xs;
! 466: splx(s);
! 467:
! 468: if (xs->datalen != 0)
! 469: cb->cb_sg = vs_build_memory_structure(sc, xs, iopb);
! 470: else
! 471: cb->cb_sg = NULL;
! 472:
! 473: vs_write(4, cqep + CQE_CTAG, (u_int32_t)cb);
! 474:
! 475: if (crb_read(2, CRB_CRSW) & M_CRSW_AQ)
! 476: vs_write(2, cqep + CQE_QECR, M_QECR_AA | M_QECR_GO);
! 477: else
! 478: vs_write(2, cqep + CQE_QECR, M_QECR_GO);
! 479:
! 480: if (flags & SCSI_POLL) {
! 481: /* poll for the command to complete */
! 482: return vs_poll(sc, cb);
! 483: }
! 484:
! 485: return (SUCCESSFULLY_QUEUED);
! 486: }
! 487:
! 488: void
! 489: vs_chksense(struct scsi_xfer *xs)
! 490: {
! 491: int s;
! 492: struct scsi_link *slp = xs->sc_link;
! 493: struct vs_softc *sc = slp->adapter_softc;
! 494: struct scsi_sense *ss;
! 495:
! 496: /* ack and clear the error */
! 497: if (CRSW & M_CRSW_ER)
! 498: CRB_CLR_ER;
! 499: CRB_CLR_DONE;
! 500: xs->status = 0;
! 501:
! 502: /* Wait until we can use the command queue entry. */
! 503: while (mce_read(2, CQE_QECR) & M_QECR_GO)
! 504: ;
! 505:
! 506: vs_bzero(sh_MCE_IOPB, IOPB_LONG_SIZE);
! 507: /* This is a command, so point to it */
! 508: ss = (void *)(bus_space_vaddr(sc->sc_iot, sc->sc_ioh) +
! 509: sh_MCE_IOPB + IOPB_SCSI_DATA);
! 510: ss->opcode = REQUEST_SENSE;
! 511: ss->byte2 = slp->lun << 5;
! 512: ss->length = sizeof(struct scsi_sense_data);
! 513:
! 514: mce_iopb_write(2, IOPB_CMD, IOPB_PASSTHROUGH);
! 515: mce_iopb_write(2, IOPB_OPTION, 0);
! 516: mce_iopb_write(1, IOPB_NVCT, sc->sc_nvec);
! 517: mce_iopb_write(1, IOPB_EVCT, sc->sc_evec);
! 518: mce_iopb_write(2, IOPB_LEVEL, 0 /* sc->sc_ipl */);
! 519: mce_iopb_write(2, IOPB_ADDR, ADDR_MOD);
! 520: mce_iopb_write(4, IOPB_BUFF, kvtop((vaddr_t)&xs->sense));
! 521: mce_iopb_write(4, IOPB_LENGTH, sizeof(struct scsi_sense_data));
! 522: mce_iopb_write(2, IOPB_UNIT,
! 523: IOPB_UNIT_VALUE(!!(slp->flags & SDEV_2NDBUS), slp->target, slp->lun));
! 524:
! 525: vs_bzero(sh_MCE, CQE_SIZE);
! 526: mce_write(2, CQE_IOPB_ADDR, sh_MCE_IOPB);
! 527: mce_write(1, CQE_IOPB_LENGTH, 0);
! 528: mce_write(1, CQE_WORK_QUEUE, 0);
! 529: mce_write(2, CQE_QECR, M_QECR_GO);
! 530:
! 531: /* poll for the command to complete */
! 532: s = splbio();
! 533: do_vspoll(sc, xs, 1);
! 534: xs->status = vs_read(2, sh_RET_IOPB + IOPB_STATUS) >> 8;
! 535: splx(s);
! 536: }
! 537:
! 538: bus_addr_t
! 539: vs_getcqe(struct vs_softc *sc)
! 540: {
! 541: bus_addr_t cqep;
! 542: int qhdp;
! 543:
! 544: qhdp = mcsb_read(2, MCSB_QHDP);
! 545: cqep = sh_CQE(qhdp);
! 546:
! 547: if (vs_read(2, cqep + CQE_QECR) & M_QECR_GO) {
! 548: /* should never happen */
! 549: return 0;
! 550: }
! 551:
! 552: if (++qhdp == NUM_CQE)
! 553: qhdp = 0;
! 554: mcsb_write(2, MCSB_QHDP, qhdp);
! 555:
! 556: vs_bzero(cqep, CQE_SIZE);
! 557: return cqep;
! 558: }
! 559:
! 560: bus_addr_t
! 561: vs_getiopb(struct vs_softc *sc)
! 562: {
! 563: bus_addr_t iopb;
! 564: int qhdp;
! 565:
! 566: /*
! 567: * Since we are always invoked after vs_getcqe(), qhdp has already
! 568: * been incremented...
! 569: */
! 570: qhdp = mcsb_read(2, MCSB_QHDP);
! 571: if (--qhdp < 0)
! 572: qhdp = NUM_CQE - 1;
! 573:
! 574: iopb = sh_IOPB(qhdp);
! 575: return iopb;
! 576: }
! 577:
! 578: int
! 579: vs_initialize(struct vs_softc *sc)
! 580: {
! 581: int i, msr, dbid;
! 582:
! 583: for (i = 0; i < NUM_WQ; i++)
! 584: sc->sc_cb[i].cb_q = i;
! 585:
! 586: /*
! 587: * Reset the board, and wait for it to get ready.
! 588: * The reset signal is applied for 70 usec, and the board status
! 589: * is not tested until 100 usec after the reset signal has been
! 590: * cleared, per the manual (MVME328/D1) pages 4-6 and 4-9.
! 591: */
! 592:
! 593: mcsb_write(2, MCSB_MCR, M_MCR_RES | M_MCR_SFEN);
! 594: delay(70);
! 595: mcsb_write(2, MCSB_MCR, M_MCR_SFEN);
! 596:
! 597: delay(100);
! 598: i = 0;
! 599: for (;;) {
! 600: msr = mcsb_read(2, MCSB_MSR);
! 601: if ((msr & (M_MSR_BOK | M_MSR_CNA)) == M_MSR_BOK)
! 602: break;
! 603: if (++i > 5000) {
! 604: printf("board reset failed, status %x\n", msr);
! 605: return 1;
! 606: }
! 607: delay(1000);
! 608: }
! 609:
! 610: /* initialize channels id */
! 611: sc->sc_id[0] = csb_read(1, CSB_PID);
! 612: sc->sc_id[1] = -1;
! 613: switch (dbid = csb_read(1, CSB_DBID)) {
! 614: case DBID_SCSI2:
! 615: case DBID_SCSI:
! 616: #if 0
! 617: printf("daughter board, ");
! 618: #endif
! 619: sc->sc_id[1] = csb_read(1, CSB_SID);
! 620: break;
! 621: case DBID_PRINTER:
! 622: printf("printer port, ");
! 623: break;
! 624: case DBID_NONE:
! 625: break;
! 626: default:
! 627: printf("unknown daughterboard id %x, ", dbid);
! 628: break;
! 629: }
! 630:
! 631: CRB_CLR_DONE;
! 632: mcsb_write(2, MCSB_QHDP, 0);
! 633:
! 634: vs_bzero(sh_CIB, CIB_SIZE);
! 635: cib_write(2, CIB_NCQE, NUM_CQE);
! 636: cib_write(2, CIB_BURST, 0);
! 637: cib_write(2, CIB_NVECT, (sc->sc_ipl << 8) | sc->sc_nvec);
! 638: cib_write(2, CIB_EVECT, (sc->sc_ipl << 8) | sc->sc_evec);
! 639: cib_write(2, CIB_PID, 0x08); /* XXX default */
! 640: cib_write(2, CIB_SID, 0x08);
! 641: cib_write(2, CIB_CRBO, sh_CRB);
! 642: cib_write(4, CIB_SELECT, SELECTION_TIMEOUT);
! 643: cib_write(4, CIB_WQTIMO, 4);
! 644: cib_write(4, CIB_VMETIMO, 0 /* VME_BUS_TIMEOUT */);
! 645: cib_write(2, CIB_ERR_FLGS, M_ERRFLGS_RIN | M_ERRFLGS_RSE);
! 646: cib_write(2, CIB_SBRIV, (sc->sc_ipl << 8) | sc->sc_evec);
! 647: cib_write(1, CIB_SOF0, 0x15);
! 648: cib_write(1, CIB_SRATE0, 100 / 4);
! 649: cib_write(1, CIB_SOF1, 0);
! 650: cib_write(1, CIB_SRATE1, 0);
! 651:
! 652: vs_bzero(sh_MCE_IOPB, IOPB_LONG_SIZE);
! 653: mce_iopb_write(2, IOPB_CMD, CNTR_INIT);
! 654: mce_iopb_write(2, IOPB_OPTION, 0);
! 655: mce_iopb_write(1, IOPB_NVCT, sc->sc_nvec);
! 656: mce_iopb_write(1, IOPB_EVCT, sc->sc_evec);
! 657: mce_iopb_write(2, IOPB_LEVEL, 0 /* sc->sc_ipl */);
! 658: mce_iopb_write(2, IOPB_ADDR, SHIO_MOD);
! 659: mce_iopb_write(4, IOPB_BUFF, sh_CIB);
! 660: mce_iopb_write(4, IOPB_LENGTH, CIB_SIZE);
! 661:
! 662: vs_bzero(sh_MCE, CQE_SIZE);
! 663: mce_write(2, CQE_IOPB_ADDR, sh_MCE_IOPB);
! 664: mce_write(1, CQE_IOPB_LENGTH, 0);
! 665: mce_write(1, CQE_WORK_QUEUE, 0);
! 666: mce_write(2, CQE_QECR, M_QECR_GO);
! 667:
! 668: /* poll for the command to complete */
! 669: do_vspoll(sc, NULL, 1);
! 670:
! 671: /* initialize work queues */
! 672: for (i = 1; i < NUM_WQ; i++) {
! 673: /* Wait until we can use the command queue entry. */
! 674: while (mce_read(2, CQE_QECR) & M_QECR_GO)
! 675: ;
! 676:
! 677: vs_bzero(sh_MCE_IOPB, IOPB_LONG_SIZE);
! 678: mce_iopb_write(2, WQCF_CMD, CNTR_INIT_WORKQ);
! 679: mce_iopb_write(2, WQCF_OPTION, 0);
! 680: mce_iopb_write(1, WQCF_NVCT, sc->sc_nvec);
! 681: mce_iopb_write(1, WQCF_EVCT, sc->sc_evec);
! 682: mce_iopb_write(2, WQCF_ILVL, 0 /* sc->sc_ipl */);
! 683: mce_iopb_write(2, WQCF_WORKQ, i);
! 684: mce_iopb_write(2, WQCF_WOPT, M_WOPT_FE | M_WOPT_IWQ);
! 685: mce_iopb_write(2, WQCF_SLOTS, JAGUAR_MAX_Q_SIZ);
! 686: mce_iopb_write(4, WQCF_CMDTO, 4); /* 1 second */
! 687:
! 688: vs_bzero(sh_MCE, CQE_SIZE);
! 689: mce_write(2, CQE_IOPB_ADDR, sh_MCE_IOPB);
! 690: mce_write(1, CQE_IOPB_LENGTH, 0);
! 691: mce_write(1, CQE_WORK_QUEUE, 0);
! 692: mce_write(2, CQE_QECR, M_QECR_GO);
! 693:
! 694: /* poll for the command to complete */
! 695: do_vspoll(sc, NULL, 1);
! 696: if (CRSW & M_CRSW_ER) {
! 697: printf("work queue %d initialization error 0x%x\n",
! 698: i, vs_read(2, sh_RET_IOPB + IOPB_STATUS));
! 699: return 1;
! 700: }
! 701: CRB_CLR_DONE;
! 702: }
! 703:
! 704: /* start queue mode */
! 705: mcsb_write(2, MCSB_MCR, mcsb_read(2, MCSB_MCR) | M_MCR_SQM);
! 706:
! 707: /* reset all SCSI buses */
! 708: vs_reset(sc, -1);
! 709: /* sync all devices */
! 710: vs_resync(sc);
! 711:
! 712: return 0;
! 713: }
! 714:
! 715: void
! 716: vs_resync(struct vs_softc *sc)
! 717: {
! 718: int bus, target;
! 719:
! 720: for (bus = 0; bus < 2; bus++) {
! 721: if (sc->sc_id[bus] < 0)
! 722: break;
! 723:
! 724: for (target = 0; target < 8; target++) {
! 725: if (target == sc->sc_id[bus])
! 726: continue;
! 727:
! 728: /* Wait until we can use the command queue entry. */
! 729: while (mce_read(2, CQE_QECR) & M_QECR_GO)
! 730: ;
! 731:
! 732: vs_bzero(sh_MCE_IOPB, IOPB_SHORT_SIZE);
! 733: mce_iopb_write(2, DRCF_CMD, CNTR_DEV_REINIT);
! 734: mce_iopb_write(2, DRCF_OPTION, 0); /* prefer polling */
! 735: mce_iopb_write(1, DRCF_NVCT, sc->sc_nvec);
! 736: mce_iopb_write(1, DRCF_EVCT, sc->sc_evec);
! 737: mce_iopb_write(2, DRCF_ILVL, 0);
! 738: mce_iopb_write(2, DRCF_UNIT,
! 739: IOPB_UNIT_VALUE(bus, target, 0));
! 740:
! 741: vs_bzero(sh_MCE, CQE_SIZE);
! 742: mce_write(2, CQE_IOPB_ADDR, sh_MCE_IOPB);
! 743: mce_write(1, CQE_IOPB_LENGTH, 0);
! 744: mce_write(1, CQE_WORK_QUEUE, 0);
! 745: mce_write(2, CQE_QECR, M_QECR_GO);
! 746:
! 747: /* poll for the command to complete */
! 748: do_vspoll(sc, NULL, 0);
! 749: if (CRSW & M_CRSW_ER)
! 750: CRB_CLR_ER;
! 751: CRB_CLR_DONE;
! 752: }
! 753: }
! 754: }
! 755:
! 756: void
! 757: vs_reset(struct vs_softc *sc, int bus)
! 758: {
! 759: int b, s;
! 760:
! 761: s = splbio();
! 762:
! 763: for (b = 0; b < 2; b++) {
! 764: if (bus >= 0 && b != bus)
! 765: continue;
! 766:
! 767: /* Wait until we can use the command queue entry. */
! 768: while (mce_read(2, CQE_QECR) & M_QECR_GO)
! 769: ;
! 770:
! 771: vs_bzero(sh_MCE_IOPB, IOPB_SHORT_SIZE);
! 772: mce_iopb_write(2, SRCF_CMD, IOPB_RESET);
! 773: mce_iopb_write(2, SRCF_OPTION, 0); /* prefer polling */
! 774: mce_iopb_write(1, SRCF_NVCT, sc->sc_nvec);
! 775: mce_iopb_write(1, SRCF_EVCT, sc->sc_evec);
! 776: mce_iopb_write(2, SRCF_ILVL, 0);
! 777: mce_iopb_write(2, SRCF_BUSID, b << 15);
! 778:
! 779: vs_bzero(sh_MCE, CQE_SIZE);
! 780: mce_write(2, CQE_IOPB_ADDR, sh_MCE_IOPB);
! 781: mce_write(1, CQE_IOPB_LENGTH, 0);
! 782: mce_write(1, CQE_WORK_QUEUE, 0);
! 783: mce_write(2, CQE_QECR, M_QECR_GO);
! 784:
! 785: /* poll for the command to complete */
! 786: for (;;) {
! 787: do_vspoll(sc, NULL, 0);
! 788: /* ack & clear scsi error condition cause by reset */
! 789: if (CRSW & M_CRSW_ER) {
! 790: CRB_CLR_DONE;
! 791: vs_write(2, sh_RET_IOPB + IOPB_STATUS, 0);
! 792: break;
! 793: }
! 794: CRB_CLR_DONE;
! 795: }
! 796: }
! 797:
! 798: thaw_all_queues(sc);
! 799:
! 800: splx(s);
! 801: }
! 802:
! 803: /* free a cb; invoked at splbio */
! 804: static __inline__ void
! 805: vs_free(struct vs_cb *cb)
! 806: {
! 807: if (cb->cb_sg != NULL) {
! 808: vs_dealloc_scatter_gather(cb->cb_sg);
! 809: cb->cb_sg = NULL;
! 810: }
! 811: cb->cb_xs = NULL;
! 812: }
! 813:
! 814: /* normal interrupt routine */
! 815: int
! 816: vs_nintr(void *vsc)
! 817: {
! 818: struct vs_softc *sc = (struct vs_softc *)vsc;
! 819: struct vs_cb *cb;
! 820: int s;
! 821:
! 822: if ((CRSW & CONTROLLER_ERROR) == CONTROLLER_ERROR)
! 823: return vs_eintr(sc);
! 824:
! 825: /* Got a valid interrupt on this device */
! 826: s = splbio();
! 827: cb = (struct vs_cb *)crb_read(4, CRB_CTAG);
! 828:
! 829: /*
! 830: * If this is a controller error, there won't be a cb
! 831: * pointer in the CTAG field. Bad things happen if you try
! 832: * to point to address 0. But then, we should have caught
! 833: * the controller error above.
! 834: */
! 835: if (cb != NULL)
! 836: vs_scsidone(sc, cb);
! 837:
! 838: /* ack the interrupt */
! 839: if (CRSW & M_CRSW_ER)
! 840: CRB_CLR_ER;
! 841: CRB_CLR_DONE;
! 842:
! 843: vs_clear_return_info(sc);
! 844: splx(s);
! 845:
! 846: return 1;
! 847: }
! 848:
! 849: /* error interrupts */
! 850: int
! 851: vs_eintr(void *vsc)
! 852: {
! 853: struct vs_softc *sc = (struct vs_softc *)vsc;
! 854: struct vs_cb *cb;
! 855: struct scsi_xfer *xs;
! 856: int crsw, ecode;
! 857: int s;
! 858:
! 859: /* Got a valid interrupt on this device */
! 860: s = splbio();
! 861:
! 862: crsw = vs_read(2, sh_CEVSB + CEVSB_CRSW);
! 863: ecode = vs_read(1, sh_CEVSB + CEVSB_ERROR);
! 864: cb = (struct vs_cb *)crb_read(4, CRB_CTAG);
! 865: xs = cb != NULL ? cb->cb_xs : NULL;
! 866:
! 867: vs_print_addr(sc, xs);
! 868:
! 869: if (crsw & M_CRSW_RST) {
! 870: printf("bus reset\n");
! 871: } else {
! 872: switch (ecode) {
! 873: case CEVSB_ERR_TYPE:
! 874: printf("IOPB type error\n");
! 875: break;
! 876: case CEVSB_ERR_TO:
! 877: printf("timeout\n");
! 878: break;
! 879: case CEVSB_ERR_TR:
! 880: printf("reconnect error\n");
! 881: break;
! 882: case CEVSB_ERR_OF:
! 883: printf("overflow\n");
! 884: break;
! 885: case CEVSB_ERR_BD:
! 886: printf("bad direction\n");
! 887: break;
! 888: case CEVSB_ERR_NR:
! 889: printf("non-recoverable error\n");
! 890: break;
! 891: case CEVSB_ERR_PANIC:
! 892: printf("board panic\n");
! 893: break;
! 894: default:
! 895: printf("unexpected error %x\n", ecode);
! 896: break;
! 897: }
! 898: }
! 899:
! 900: if (xs != NULL) {
! 901: xs->error = XS_SELTIMEOUT;
! 902: xs->status = -1;
! 903: xs->flags |= ITSDONE;
! 904: scsi_done(xs);
! 905: }
! 906:
! 907: if (CRSW & M_CRSW_ER)
! 908: CRB_CLR_ER;
! 909: CRB_CLR_DONE;
! 910:
! 911: thaw_all_queues(sc);
! 912: vs_clear_return_info(sc);
! 913: splx(s);
! 914:
! 915: return 1;
! 916: }
! 917:
! 918: static void
! 919: vs_clear_return_info(struct vs_softc *sc)
! 920: {
! 921: vs_bzero(sh_RET_IOPB, CRB_SIZE + IOPB_LONG_SIZE);
! 922: }
! 923:
! 924: /*
! 925: * Choose the first available work queue (invoked at splbio).
! 926: * We used a simple round-robin mechanism which is faster than rescanning
! 927: * from the beginning if we have more than one target on the bus.
! 928: */
! 929: struct vs_cb *
! 930: vs_find_queue(struct scsi_link *sl, struct vs_softc *sc)
! 931: {
! 932: struct vs_cb *cb;
! 933: static u_int last = 0;
! 934: u_int q;
! 935:
! 936: q = last;
! 937: for (;;) {
! 938: if (++q == NUM_WQ)
! 939: q = 1;
! 940: if (q == last)
! 941: break;
! 942:
! 943: if ((cb = &sc->sc_cb[q])->cb_xs == NULL) {
! 944: last = q;
! 945: return (cb);
! 946: }
! 947: }
! 948:
! 949: return (NULL);
! 950: }
! 951:
! 952: /*
! 953: * Useful functions for scatter/gather list
! 954: */
! 955:
! 956: M328_SG
! 957: vs_alloc_scatter_gather(void)
! 958: {
! 959: M328_SG sg;
! 960:
! 961: MALLOC(sg, M328_SG, sizeof(struct m328_sg), M_DEVBUF, M_WAITOK);
! 962: bzero(sg, sizeof(struct m328_sg));
! 963:
! 964: return (sg);
! 965: }
! 966:
! 967: void
! 968: vs_dealloc_scatter_gather(M328_SG sg)
! 969: {
! 970: int i;
! 971:
! 972: if (sg->level > 0) {
! 973: for (i = 0; sg->down[i] && i < MAX_SG_ELEMENTS; i++) {
! 974: vs_dealloc_scatter_gather(sg->down[i]);
! 975: }
! 976: }
! 977: FREE(sg, M_DEVBUF);
! 978: }
! 979:
! 980: void
! 981: vs_link_sg_element(sg_list_element_t *element, vaddr_t phys_add, int len)
! 982: {
! 983: element->count.bytes = len;
! 984: element->addrlo = phys_add;
! 985: element->addrhi = phys_add >> 16;
! 986: element->link = 0; /* FALSE */
! 987: element->transfer_type = NORMAL_TYPE;
! 988: element->memory_type = LONG_TRANSFER;
! 989: element->address_modifier = ADRM_EXT_S_D;
! 990: }
! 991:
! 992: void
! 993: vs_link_sg_list(sg_list_element_t *list, vaddr_t phys_add, int elements)
! 994: {
! 995: list->count.scatter.gather = elements;
! 996: list->addrlo = phys_add;
! 997: list->addrhi = phys_add >> 16;
! 998: list->link = 1; /* TRUE */
! 999: list->transfer_type = NORMAL_TYPE;
! 1000: list->memory_type = LONG_TRANSFER;
! 1001: list->address_modifier = ADRM_EXT_S_D;
! 1002: }
! 1003:
! 1004: M328_SG
! 1005: vs_build_memory_structure(struct vs_softc *sc, struct scsi_xfer *xs,
! 1006: bus_addr_t iopb)
! 1007: {
! 1008: M328_SG sg;
! 1009: vaddr_t starting_point_virt, starting_point_phys, point_virt,
! 1010: point1_phys, point2_phys, virt;
! 1011: unsigned int len;
! 1012: int level;
! 1013:
! 1014: sg = NULL; /* Hopefully we need no scatter/gather list */
! 1015:
! 1016: /*
! 1017: * We have the following things:
! 1018: * virt va of the virtual memory block
! 1019: * len length of the virtual memory block
! 1020: * starting_point_virt va of the physical memory block
! 1021: * starting_point_phys pa of the physical memory block
! 1022: * point_virt va of the virtual memory
! 1023: * we are checking at the moment
! 1024: * point1_phys pa of the physical memory
! 1025: * we are checking at the moment
! 1026: * point2_phys pa of another physical memory
! 1027: * we are checking at the moment
! 1028: */
! 1029:
! 1030: level = 0;
! 1031: virt = starting_point_virt = (vaddr_t)xs->data;
! 1032: point1_phys = starting_point_phys = kvtop((vaddr_t)xs->data);
! 1033: len = xs->datalen;
! 1034:
! 1035: /*
! 1036: * Check if we need scatter/gather
! 1037: */
! 1038: if (trunc_page(virt + len - 1) != trunc_page(virt)) {
! 1039: for (point_virt = round_page(starting_point_virt + 1);
! 1040: /* if we do already scatter/gather we have to stay in the loop and jump */
! 1041: point_virt < virt + len || sg != NULL;
! 1042: point_virt += PAGE_SIZE) { /* out later */
! 1043:
! 1044: point2_phys = kvtop(point_virt);
! 1045:
! 1046: if ((point2_phys != trunc_page(point1_phys) + PAGE_SIZE) || /* physical memory is not contiguous */
! 1047: (point_virt - starting_point_virt >= MAX_SG_BLOCK_SIZE && sg)) { /* we only can access (1<<16)-1 bytes in scatter/gather_mode */
! 1048: if (point_virt - starting_point_virt >= MAX_SG_BLOCK_SIZE) { /* We were walking too far for one scatter/gather block ... */
! 1049: point_virt = trunc_page(starting_point_virt+MAX_SG_BLOCK_SIZE-1); /* So go back to the beginning of the last matching page */
! 1050: /* and generate the physical address of
! 1051: * this location for the next time. */
! 1052: point2_phys = kvtop(point_virt);
! 1053: }
! 1054:
! 1055: if (sg == NULL)
! 1056: sg = vs_alloc_scatter_gather();
! 1057:
! 1058: #if 1 /* broken firmware */
! 1059: if (sg->elements >= MAX_SG_ELEMENTS) {
! 1060: vs_dealloc_scatter_gather(sg);
! 1061: printf("%s: scatter/gather list too large\n",
! 1062: sc->sc_dev.dv_xname);
! 1063: return (NULL);
! 1064: }
! 1065: #else /* if the firmware will ever get fixed */
! 1066: while (sg->elements >= MAX_SG_ELEMENTS) {
! 1067: if (!sg->up) { /* If the list full in this layer ? */
! 1068: sg->up = vs_alloc_scatter_gather();
! 1069: sg->up->level = sg->level+1;
! 1070: sg->up->down[0] = sg;
! 1071: sg->up->elements = 1;
! 1072: }
! 1073: /* link this full list also in physical memory */
! 1074: vs_link_sg_list(&(sg->up->list[sg->up->elements-1]),
! 1075: kvtop((vaddr_t)sg->list),
! 1076: sg->elements);
! 1077: sg = sg->up; /* Climb up */
! 1078: }
! 1079: while (sg->level) { /* As long as we are not a the base level */
! 1080: int i;
! 1081:
! 1082: i = sg->elements;
! 1083: /* We need a new element */
! 1084: sg->down[i] = vs_alloc_scatter_gather();
! 1085: sg->down[i]->level = sg->level - 1;
! 1086: sg->down[i]->up = sg;
! 1087: sg->elements++;
! 1088: sg = sg->down[i]; /* Climb down */
! 1089: }
! 1090: #endif /* 1 */
! 1091: if (point_virt < virt + len) {
! 1092: /* linking element */
! 1093: vs_link_sg_element(&(sg->list[sg->elements]),
! 1094: starting_point_phys,
! 1095: point_virt - starting_point_virt);
! 1096: sg->elements++;
! 1097: } else {
! 1098: /* linking last element */
! 1099: vs_link_sg_element(&(sg->list[sg->elements]),
! 1100: starting_point_phys,
! 1101: virt + len - starting_point_virt);
! 1102: sg->elements++;
! 1103: break; /* We have now collected all blocks */
! 1104: }
! 1105: starting_point_virt = point_virt;
! 1106: starting_point_phys = point2_phys;
! 1107: }
! 1108: point1_phys = point2_phys;
! 1109: }
! 1110: }
! 1111:
! 1112: /*
! 1113: * Climb up along the right side of the tree until we reach the top.
! 1114: */
! 1115:
! 1116: if (sg != NULL) {
! 1117: while (sg->up) {
! 1118: /* link this list also in physical memory */
! 1119: vs_link_sg_list(&(sg->up->list[sg->up->elements-1]),
! 1120: kvtop((vaddr_t)sg->list),
! 1121: sg->elements);
! 1122: sg = sg->up; /* Climb up */
! 1123: }
! 1124:
! 1125: vs_write(2, iopb + IOPB_OPTION,
! 1126: vs_read(2, iopb + IOPB_OPTION) | M_OPT_SG);
! 1127: vs_write(2, iopb + IOPB_ADDR,
! 1128: vs_read(2, iopb + IOPB_ADDR) | M_ADR_SG_LINK);
! 1129: vs_write(4, iopb + IOPB_BUFF, kvtop((vaddr_t)sg->list));
! 1130: vs_write(4, iopb + IOPB_LENGTH, sg->elements);
! 1131: vs_write(4, iopb + IOPB_SGTTL, len);
! 1132: } else {
! 1133: /* no scatter/gather necessary */
! 1134: vs_write(4, iopb + IOPB_BUFF, starting_point_phys);
! 1135: vs_write(4, iopb + IOPB_LENGTH, len);
! 1136: }
! 1137: return sg;
! 1138: }
! 1139:
! 1140: static paddr_t
! 1141: kvtop(vaddr_t va)
! 1142: {
! 1143: paddr_t pa;
! 1144:
! 1145: pmap_extract(pmap_kernel(), va, &pa);
! 1146: /* XXX check for failure */
! 1147: return pa;
! 1148: }
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 / mvme88k / dev