Annotation of sys/dev/isa/wds.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: wds.c,v 1.23 2006/11/28 23:59:45 dlg Exp $ */
! 2: /* $NetBSD: wds.c,v 1.13 1996/11/03 16:20:31 mycroft Exp $ */
! 3:
! 4: #undef WDSDIAG
! 5: #ifdef DDB
! 6: #define integrate
! 7: #else
! 8: #define integrate static inline
! 9: #endif
! 10:
! 11: /*
! 12: * XXX
! 13: * sense data
! 14: * aborts
! 15: * resets
! 16: */
! 17:
! 18: /*
! 19: * Copyright (c) 1994, 1995 Julian Highfield. All rights reserved.
! 20: * Portions copyright (c) 1994, 1996 Charles M. Hannum. All rights reserved.
! 21: *
! 22: * Redistribution and use in source and binary forms, with or without
! 23: * modification, are permitted provided that the following conditions
! 24: * are met:
! 25: * 1. Redistributions of source code must retain the above copyright
! 26: * notice, this list of conditions and the following disclaimer.
! 27: * 2. Redistributions in binary form must reproduce the above copyright
! 28: * notice, this list of conditions and the following disclaimer in the
! 29: * documentation and/or other materials provided with the distribution.
! 30: * 3. All advertising materials mentioning features or use of this software
! 31: * must display the following acknowledgement:
! 32: * This product includes software developed by Julian Highfield.
! 33: * 4. The name of the author may not be used to endorse or promote products
! 34: * derived from this software without specific prior written permission.
! 35: *
! 36: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 37: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 38: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 39: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 40: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 41: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 42: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 43: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 44: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 45: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 46: */
! 47:
! 48: /*
! 49: * This driver is for the WD7000 family of SCSI controllers:
! 50: * the WD7000-ASC, a bus-mastering DMA controller,
! 51: * the WD7000-FASST2, an -ASC with new firmware and scatter-gather,
! 52: * and the WD7000-ASE, which was custom manufactured for Apollo
! 53: * workstations and seems to include an -ASC as well as floppy
! 54: * and ESDI interfaces.
! 55: *
! 56: * Loosely based on Theo Deraadt's unfinished attempt says the NetBSD group
! 57: * so they decided to delete the copyright that file had on it.
! 58: */
! 59:
! 60: #include <sys/types.h>
! 61: #include <sys/param.h>
! 62: #include <sys/systm.h>
! 63: #include <sys/kernel.h>
! 64: #include <sys/errno.h>
! 65: #include <sys/ioctl.h>
! 66: #include <sys/device.h>
! 67: #include <sys/malloc.h>
! 68: #include <sys/buf.h>
! 69: #include <sys/proc.h>
! 70: #include <sys/user.h>
! 71:
! 72: #include <machine/bus.h>
! 73: #include <machine/intr.h>
! 74:
! 75: #include <scsi/scsi_all.h>
! 76: #include <scsi/scsiconf.h>
! 77:
! 78: #include <dev/isa/isavar.h>
! 79: #include <dev/isa/isadmavar.h>
! 80: #include <dev/isa/wdsreg.h>
! 81:
! 82: #ifndef DDB
! 83: #define Debugger() panic("should call debugger here (wds.c)")
! 84: #endif /* ! DDB */
! 85:
! 86: #define WDS_MBX_SIZE 16
! 87:
! 88: #define WDS_SCB_MAX 32
! 89: #define SCB_HASH_SIZE 32 /* hash table size for phystokv */
! 90: #define SCB_HASH_SHIFT 9
! 91: #define SCB_HASH(x) ((((long)(x))>>SCB_HASH_SHIFT) & (SCB_HASH_SIZE - 1))
! 92:
! 93: #define wds_nextmbx(wmb, mbx, mbio) \
! 94: if ((wmb) == &(mbx)->mbio[WDS_MBX_SIZE - 1]) \
! 95: (wmb) = &(mbx)->mbio[0]; \
! 96: else \
! 97: (wmb)++;
! 98:
! 99: struct wds_mbx {
! 100: struct wds_mbx_out mbo[WDS_MBX_SIZE];
! 101: struct wds_mbx_in mbi[WDS_MBX_SIZE];
! 102: struct wds_mbx_out *cmbo; /* Collection Mail Box out */
! 103: struct wds_mbx_out *tmbo; /* Target Mail Box out */
! 104: struct wds_mbx_in *tmbi; /* Target Mail Box in */
! 105: };
! 106:
! 107: #define KVTOPHYS(x) vtophys((vaddr_t)(x))
! 108:
! 109: struct wds_softc {
! 110: struct device sc_dev;
! 111: struct isadev sc_id;
! 112: void *sc_ih;
! 113:
! 114: bus_space_tag_t sc_iot; /* bus identifier */
! 115: bus_space_handle_t sc_ioh; /* io handle */
! 116: int sc_irq, sc_drq;
! 117:
! 118: int sc_revision;
! 119:
! 120: struct wds_mbx sc_mbx;
! 121: #define wmbx (&sc->sc_mbx)
! 122: struct wds_scb *sc_scbhash[SCB_HASH_SIZE];
! 123: TAILQ_HEAD(, wds_scb) sc_free_scb, sc_waiting_scb;
! 124: int sc_numscbs, sc_mbofull;
! 125: int sc_scsi_dev;
! 126: struct scsi_link sc_link; /* prototype for subdevs */
! 127: };
! 128:
! 129: /* Define the bounce buffer length... */
! 130: #define BUFLEN (64*1024)
! 131: /* ..and how many there are. One per device! Non-FASST boards need these. */
! 132: #define BUFCNT 8
! 133: /* The macro for deciding whether the board needs a buffer. */
! 134: #define NEEDBUFFER(sc) (sc->sc_revision < 0x800)
! 135:
! 136: struct wds_buf {
! 137: u_char data[BUFLEN];
! 138: int busy;
! 139: TAILQ_ENTRY(wds_buf) chain;
! 140: } wds_buffer[BUFCNT];
! 141:
! 142: TAILQ_HEAD(, wds_buf) wds_free_buffer;
! 143:
! 144: #ifdef WDSDEBUG
! 145: int wds_debug = WDSDEBUG;
! 146: #endif
! 147:
! 148: integrate void wds_wait(bus_space_tag_t, bus_space_handle_t, int, int, int);
! 149: int wds_cmd(struct wds_softc *, u_char *, int);
! 150: integrate void wds_finish_scbs(struct wds_softc *);
! 151: int wdsintr(void *);
! 152: integrate void wds_reset_scb(struct wds_softc *, struct wds_scb *);
! 153: void wds_free_scb(struct wds_softc *, struct wds_scb *);
! 154: void wds_free_buf(struct wds_softc *, struct wds_buf *);
! 155: integrate void wds_init_scb(struct wds_softc *, struct wds_scb *);
! 156: struct wds_scb *wds_get_scb(struct wds_softc *, int, int);
! 157: struct wds_buf *wds_get_buf(struct wds_softc *, int);
! 158: struct wds_scb *wds_scb_phys_kv(struct wds_softc *, u_long);
! 159: void wds_queue_scb(struct wds_softc *, struct wds_scb *);
! 160: void wds_collect_mbo(struct wds_softc *);
! 161: void wds_start_scbs(struct wds_softc *);
! 162: void wds_done(struct wds_softc *, struct wds_scb *, u_char);
! 163: int wds_find(struct isa_attach_args *, struct wds_softc *);
! 164: void wds_init(struct wds_softc *);
! 165: void wds_inquire_setup_information(struct wds_softc *);
! 166: void wdsminphys(struct buf *);
! 167: int wds_scsi_cmd(struct scsi_xfer *);
! 168: void wds_sense(struct wds_softc *, struct wds_scb *);
! 169: int wds_poll(struct wds_softc *, struct scsi_xfer *, int);
! 170: int wds_ipoll(struct wds_softc *, struct wds_scb *, int);
! 171: void wds_timeout(void *);
! 172: int wdsprint(void *, const char *);
! 173:
! 174: struct scsi_adapter wds_switch = {
! 175: wds_scsi_cmd,
! 176: wdsminphys,
! 177: 0,
! 178: 0,
! 179: };
! 180:
! 181: /* the below structure is so we have a default dev struct for our link struct */
! 182: struct scsi_device wds_dev = {
! 183: NULL, /* Use default error handler */
! 184: NULL, /* have a queue, served by this */
! 185: NULL, /* have no async handler */
! 186: NULL, /* Use default 'done' routine */
! 187: };
! 188:
! 189: int wdsprobe(struct device *, void *, void *);
! 190: void wdsattach(struct device *, struct device *, void *);
! 191:
! 192: struct cfattach wds_ca = {
! 193: sizeof(struct wds_softc), wdsprobe, wdsattach
! 194: };
! 195:
! 196: struct cfdriver wds_cd = {
! 197: NULL, "wds", DV_DULL
! 198: };
! 199:
! 200: #define WDS_ABORT_TIMEOUT 2000 /* time to wait for abort (mSec) */
! 201:
! 202: integrate void
! 203: wds_wait(iot, ioh, port, mask, val)
! 204: bus_space_tag_t iot;
! 205: bus_space_handle_t ioh;
! 206: int port;
! 207: int mask;
! 208: int val;
! 209: {
! 210: while ((bus_space_read_1(iot, ioh, port) & mask) != val)
! 211: ;
! 212: }
! 213:
! 214: /*
! 215: * Write a command to the board's I/O ports.
! 216: */
! 217: int
! 218: wds_cmd(sc, ibuf, icnt)
! 219: struct wds_softc *sc;
! 220: u_int8_t *ibuf;
! 221: int icnt;
! 222: {
! 223: bus_space_tag_t iot = sc->sc_iot;
! 224: bus_space_handle_t ioh = sc->sc_ioh;
! 225: u_int8_t c;
! 226:
! 227: wds_wait(iot, ioh, WDS_STAT, WDSS_RDY, WDSS_RDY);
! 228:
! 229: while (icnt--) {
! 230: bus_space_write_1(iot, ioh, WDS_CMD, *ibuf++);
! 231: wds_wait(iot, ioh, WDS_STAT, WDSS_RDY, WDSS_RDY);
! 232: c = bus_space_read_1(iot, ioh, WDS_STAT);
! 233: if (c & WDSS_REJ)
! 234: return 1;
! 235: }
! 236:
! 237: return 0;
! 238: }
! 239:
! 240: /*
! 241: * Check for the presence of a WD7000 SCSI controller.
! 242: */
! 243: int
! 244: wdsprobe(parent, match, aux)
! 245: struct device *parent;
! 246: void *match, *aux;
! 247: {
! 248: register struct isa_attach_args *ia = aux;
! 249: bus_space_tag_t iot = ia->ia_iot;
! 250: bus_space_handle_t ioh;
! 251: int rv;
! 252:
! 253: if (bus_space_map(iot, ia->ia_iobase, WDS_IO_PORTS, 0, &ioh))
! 254: return (0);
! 255:
! 256: /* See if there is a unit at this location. */
! 257: rv = wds_find(ia, NULL);
! 258:
! 259: bus_space_unmap(iot, ioh, WDS_IO_PORTS);
! 260:
! 261: if (rv) {
! 262: ia->ia_msize = 0;
! 263: ia->ia_iosize = WDS_IO_PORTS;
! 264: }
! 265:
! 266: return (rv);
! 267: }
! 268:
! 269: int
! 270: wdsprint(aux, name)
! 271: void *aux;
! 272: const char *name;
! 273: {
! 274:
! 275: if (name != NULL)
! 276: printf("%s: scsibus ", name);
! 277: return UNCONF;
! 278: }
! 279:
! 280: /*
! 281: * Attach all available units.
! 282: */
! 283: void
! 284: wdsattach(parent, self, aux)
! 285: struct device *parent, *self;
! 286: void *aux;
! 287: {
! 288: struct isa_attach_args *ia = aux;
! 289: struct wds_softc *sc = (void *)self;
! 290: struct scsibus_attach_args saa;
! 291: bus_space_tag_t iot = ia->ia_iot;
! 292: bus_space_handle_t ioh;
! 293:
! 294: if (bus_space_map(iot, ia->ia_iobase, WDS_IO_PORTS, 0, &ioh)) {
! 295: printf("%s: can't map i/o space\n", sc->sc_dev.dv_xname);
! 296: return;
! 297: }
! 298:
! 299: if (!wds_find(ia, sc))
! 300: panic("wdsattach: wds_find of %s failed", self->dv_xname);
! 301: wds_init(sc);
! 302:
! 303: if (sc->sc_drq != DRQUNK)
! 304: isadma_cascade(sc->sc_drq);
! 305:
! 306: TAILQ_INIT(&sc->sc_free_scb);
! 307: TAILQ_INIT(&sc->sc_waiting_scb);
! 308: wds_inquire_setup_information(sc);
! 309:
! 310: /*
! 311: * fill in the prototype scsi_link.
! 312: */
! 313: #ifdef notyet
! 314: sc->sc_link.channel = SCSI_CHANNEL_ONLY_ONE;
! 315: #endif
! 316: sc->sc_link.adapter_softc = sc;
! 317: sc->sc_link.adapter_target = sc->sc_scsi_dev;
! 318: sc->sc_link.adapter = &wds_switch;
! 319: sc->sc_link.device = &wds_dev;
! 320: /* XXX */
! 321: /* I don't think the -ASE can handle openings > 1. */
! 322: /* It gives Vendor Error 26 whenever I try it. */
! 323: sc->sc_link.openings = 1;
! 324:
! 325: sc->sc_ih = isa_intr_establish(ia->ia_ic, sc->sc_irq, IST_EDGE,
! 326: IPL_BIO, wdsintr, sc, sc->sc_dev.dv_xname);
! 327:
! 328: bzero(&saa, sizeof(saa));
! 329: saa.saa_sc_link = &sc->sc_link;
! 330:
! 331: /*
! 332: * ask the adapter what subunits are present
! 333: */
! 334: config_found(self, &saa, wdsprint);
! 335: }
! 336:
! 337: integrate void
! 338: wds_finish_scbs(sc)
! 339: struct wds_softc *sc;
! 340: {
! 341: struct wds_mbx_in *wmbi;
! 342: struct wds_scb *scb;
! 343: int i;
! 344:
! 345: wmbi = wmbx->tmbi;
! 346:
! 347: if (wmbi->stat == WDS_MBI_FREE) {
! 348: for (i = 0; i < WDS_MBX_SIZE; i++) {
! 349: if (wmbi->stat != WDS_MBI_FREE) {
! 350: printf("%s: mbi not in round-robin order\n",
! 351: sc->sc_dev.dv_xname);
! 352: goto AGAIN;
! 353: }
! 354: wds_nextmbx(wmbi, wmbx, mbi);
! 355: }
! 356: #ifdef WDSDIAGnot
! 357: printf("%s: mbi interrupt with no full mailboxes\n",
! 358: sc->sc_dev.dv_xname);
! 359: #endif
! 360: return;
! 361: }
! 362:
! 363: AGAIN:
! 364: do {
! 365: scb = wds_scb_phys_kv(sc, phystol(wmbi->scb_addr));
! 366: if (!scb) {
! 367: printf("%s: bad mbi scb pointer; skipping\n",
! 368: sc->sc_dev.dv_xname);
! 369: goto next;
! 370: }
! 371:
! 372: #ifdef WDSDEBUG
! 373: if (wds_debug) {
! 374: u_int8_t *cp = (u_int8_t *)&scb->cmd.scb;
! 375: printf("op=%x %x %x %x %x %x\n",
! 376: cp[0], cp[1], cp[2], cp[3], cp[4], cp[5]);
! 377: printf("stat %x for mbi addr = 0x%08x, ",
! 378: wmbi->stat, wmbi);
! 379: printf("scb addr = 0x%x\n", scb);
! 380: }
! 381: #endif /* WDSDEBUG */
! 382:
! 383: timeout_del(&scb->xs->stimeout);
! 384: #ifdef notyet
! 385: isadma_copyfrombuf((caddr_t)scb, SCB_PHYS_SIZE,
! 386: 1, scb->scb_phys);
! 387: #endif
! 388: wds_done(sc, scb, wmbi->stat);
! 389:
! 390: next:
! 391: wmbi->stat = WDS_MBI_FREE;
! 392: wds_nextmbx(wmbi, wmbx, mbi);
! 393: } while (wmbi->stat != WDS_MBI_FREE);
! 394:
! 395: wmbx->tmbi = wmbi;
! 396: }
! 397:
! 398: /*
! 399: * Process an interrupt.
! 400: */
! 401: int
! 402: wdsintr(arg)
! 403: void *arg;
! 404: {
! 405: struct wds_softc *sc = arg;
! 406: bus_space_tag_t iot = sc->sc_iot;
! 407: bus_space_handle_t ioh = sc->sc_ioh;
! 408: u_char c;
! 409:
! 410: /* Was it really an interrupt from the board? */
! 411: if ((bus_space_read_1(iot, ioh, WDS_STAT) & WDSS_IRQ) == 0)
! 412: return 0;
! 413:
! 414: /* Get the interrupt status byte. */
! 415: c = bus_space_read_1(iot, ioh, WDS_IRQSTAT) & WDSI_MASK;
! 416:
! 417: /* Acknowledge (which resets) the interrupt. */
! 418: bus_space_write_1(iot, ioh, WDS_IRQACK, 0x00);
! 419:
! 420: switch (c) {
! 421: case WDSI_MSVC:
! 422: wds_finish_scbs(sc);
! 423: break;
! 424:
! 425: case WDSI_MFREE:
! 426: wds_start_scbs(sc);
! 427: break;
! 428:
! 429: default:
! 430: printf("%s: unrecognized interrupt type %02x",
! 431: sc->sc_dev.dv_xname, c);
! 432: break;
! 433: }
! 434:
! 435: return 1;
! 436: }
! 437:
! 438: integrate void
! 439: wds_reset_scb(sc, scb)
! 440: struct wds_softc *sc;
! 441: struct wds_scb *scb;
! 442: {
! 443:
! 444: scb->flags = 0;
! 445: }
! 446:
! 447: /*
! 448: * Free the command structure, the outgoing mailbox and the data buffer.
! 449: */
! 450: void
! 451: wds_free_scb(sc, scb)
! 452: struct wds_softc *sc;
! 453: struct wds_scb *scb;
! 454: {
! 455: int s;
! 456:
! 457: if (scb->buf != 0) {
! 458: wds_free_buf(sc, scb->buf);
! 459: scb->buf = 0;
! 460: }
! 461:
! 462: s = splbio();
! 463:
! 464: #ifdef notyet
! 465: if (scb->scb_phys[0].addr)
! 466: isadma_unmap((caddr_t)scb, SCB_PHYS_SIZE, 1, scb->scb_phys);
! 467: #endif
! 468:
! 469: wds_reset_scb(sc, scb);
! 470: TAILQ_INSERT_HEAD(&sc->sc_free_scb, scb, chain);
! 471:
! 472: /*
! 473: * If there were none, wake anybody waiting for one to come free,
! 474: * starting with queued entries.
! 475: */
! 476: if (TAILQ_NEXT(scb, chain) == NULL)
! 477: wakeup(&sc->sc_free_scb);
! 478:
! 479: splx(s);
! 480: }
! 481:
! 482: void
! 483: wds_free_buf(sc, buf)
! 484: struct wds_softc *sc;
! 485: struct wds_buf *buf;
! 486: {
! 487: int s;
! 488:
! 489: s = splbio();
! 490:
! 491: buf->busy = 0;
! 492: TAILQ_INSERT_HEAD(&wds_free_buffer, buf, chain);
! 493:
! 494: /*
! 495: * If there were none, wake anybody waiting for one to come free,
! 496: * starting with queued entries.
! 497: */
! 498: if (TAILQ_NEXT(buf, chain) == NULL)
! 499: wakeup(&wds_free_buffer);
! 500:
! 501: splx(s);
! 502: }
! 503:
! 504: integrate void
! 505: wds_init_scb(sc, scb)
! 506: struct wds_softc *sc;
! 507: struct wds_scb *scb;
! 508: {
! 509: int hashnum;
! 510:
! 511: bzero(scb, sizeof(struct wds_scb));
! 512: /*
! 513: * put in the phystokv hash table
! 514: * Never gets taken out.
! 515: */
! 516: scb->hashkey = KVTOPHYS(scb);
! 517: hashnum = SCB_HASH(scb->hashkey);
! 518: scb->nexthash = sc->sc_scbhash[hashnum];
! 519: sc->sc_scbhash[hashnum] = scb;
! 520: wds_reset_scb(sc, scb);
! 521: }
! 522:
! 523: /*
! 524: * Get a free scb
! 525: *
! 526: * If there are none, see if we can allocate a new one. If so, put it in
! 527: * the hash table too otherwise either return an error or sleep.
! 528: */
! 529: struct wds_scb *
! 530: wds_get_scb(sc, flags, needbuffer)
! 531: struct wds_softc *sc;
! 532: int flags;
! 533: int needbuffer;
! 534: {
! 535: struct wds_scb *scb;
! 536: int s;
! 537: #ifdef notyet
! 538: int mflags, hashnum;
! 539: #endif
! 540:
! 541: s = splbio();
! 542:
! 543: #ifdef notyet
! 544: if (flags & SCSI_NOSLEEP)
! 545: mflags = ISADMA_MAP_BOUNCE;
! 546: else
! 547: mflags = ISADMA_MAP_BOUNCE | ISADMA_MAP_WAITOK;
! 548: #endif
! 549:
! 550: /*
! 551: * If we can and have to, sleep waiting for one to come free
! 552: * but only if we can't allocate a new one.
! 553: */
! 554: for (;;) {
! 555: scb = TAILQ_FIRST(&sc->sc_free_scb);
! 556: if (scb) {
! 557: TAILQ_REMOVE(&sc->sc_free_scb, scb, chain);
! 558: break;
! 559: }
! 560: if (sc->sc_numscbs < WDS_SCB_MAX) {
! 561: scb = (struct wds_scb *) malloc(sizeof(struct wds_scb),
! 562: M_TEMP, M_NOWAIT);
! 563: if (!scb) {
! 564: printf("%s: can't malloc scb\n",
! 565: sc->sc_dev.dv_xname);
! 566: goto out;
! 567: }
! 568: wds_init_scb(sc, scb);
! 569: sc->sc_numscbs++;
! 570: break;
! 571: }
! 572: if ((flags & SCSI_NOSLEEP) != 0)
! 573: goto out;
! 574: tsleep(&sc->sc_free_scb, PRIBIO, "wdsscb", 0);
! 575: }
! 576:
! 577: scb->flags |= SCB_ALLOC;
! 578:
! 579: #ifdef notyet
! 580: if (isadma_map((caddr_t)scb, SCB_PHYS_SIZE, scb->scb_phys,
! 581: mflags | ISADMA_MAP_CONTIG) == 1) {
! 582: hashnum = SCB_HASH(scb->scb_phys[0].addr);
! 583: scb->nexthash = sc->sc_scbhash[hashnum];
! 584: sc->sc_scbhash[hashnum] = ccb;
! 585: } else {
! 586: scb->scb_phys[0].addr = 0;
! 587: wds_free_scb(sc, scb);
! 588: scb = 0;
! 589: }
! 590: #else
! 591: if (needbuffer) {
! 592: scb->buf = wds_get_buf(sc, flags);
! 593: if (scb->buf == 0) {
! 594: wds_free_scb(sc, scb);
! 595: scb = 0;
! 596: }
! 597: }
! 598: #endif
! 599:
! 600:
! 601: out:
! 602: splx(s);
! 603: return (scb);
! 604: }
! 605:
! 606: struct wds_buf *
! 607: wds_get_buf(sc, flags)
! 608: struct wds_softc *sc;
! 609: int flags;
! 610: {
! 611: struct wds_buf *buf;
! 612: int s;
! 613:
! 614: s = splbio();
! 615:
! 616: for (;;) {
! 617: buf = TAILQ_FIRST(&wds_free_buffer);
! 618: if (buf) {
! 619: TAILQ_REMOVE(&wds_free_buffer, buf, chain);
! 620: break;
! 621: }
! 622: if ((flags & SCSI_NOSLEEP) != 0)
! 623: goto out;
! 624: tsleep(&wds_free_buffer, PRIBIO, "wdsbuf", 0);
! 625: }
! 626:
! 627: buf->busy = 1;
! 628:
! 629: out:
! 630: splx(s);
! 631: return (buf);
! 632: }
! 633:
! 634: struct wds_scb *
! 635: wds_scb_phys_kv(sc, scb_phys)
! 636: struct wds_softc *sc;
! 637: u_long scb_phys;
! 638: {
! 639: int hashnum = SCB_HASH(scb_phys);
! 640: struct wds_scb *scb = sc->sc_scbhash[hashnum];
! 641:
! 642: while (scb) {
! 643: if (scb->hashkey == scb_phys)
! 644: break;
! 645: /* XXX Check to see if it matches the sense command block. */
! 646: if (scb->hashkey == (scb_phys - sizeof(struct wds_cmd)))
! 647: break;
! 648: scb = scb->nexthash;
! 649: }
! 650: return scb;
! 651: }
! 652:
! 653: /*
! 654: * Queue a SCB to be sent to the controller, and send it if possible.
! 655: */
! 656: void
! 657: wds_queue_scb(sc, scb)
! 658: struct wds_softc *sc;
! 659: struct wds_scb *scb;
! 660: {
! 661:
! 662: TAILQ_INSERT_TAIL(&sc->sc_waiting_scb, scb, chain);
! 663: wds_start_scbs(sc);
! 664: }
! 665:
! 666: /*
! 667: * Garbage collect mailboxes that are no longer in use.
! 668: */
! 669: void
! 670: wds_collect_mbo(sc)
! 671: struct wds_softc *sc;
! 672: {
! 673: struct wds_mbx_out *wmbo; /* Mail Box Out pointer */
! 674: #ifdef WDSDIAG
! 675: struct wds_scb *scb;
! 676: #endif
! 677:
! 678: wmbo = wmbx->cmbo;
! 679:
! 680: while (sc->sc_mbofull > 0) {
! 681: if (wmbo->cmd != WDS_MBO_FREE)
! 682: break;
! 683:
! 684: #ifdef WDSDIAG
! 685: scb = wds_scb_phys_kv(sc, phystol(wmbo->scb_addr));
! 686: scb->flags &= ~SCB_SENDING;
! 687: #endif
! 688:
! 689: --sc->sc_mbofull;
! 690: wds_nextmbx(wmbo, wmbx, mbo);
! 691: }
! 692:
! 693: wmbx->cmbo = wmbo;
! 694: }
! 695:
! 696: /*
! 697: * Send as many SCBs as we have empty mailboxes for.
! 698: */
! 699: void
! 700: wds_start_scbs(sc)
! 701: struct wds_softc *sc;
! 702: {
! 703: struct wds_mbx_out *wmbo; /* Mail Box Out pointer */
! 704: struct wds_scb *scb;
! 705: u_char c;
! 706:
! 707: wmbo = wmbx->tmbo;
! 708:
! 709: while ((scb = TAILQ_FIRST(&sc->sc_waiting_scb)) != NULL) {
! 710: if (sc->sc_mbofull >= WDS_MBX_SIZE) {
! 711: wds_collect_mbo(sc);
! 712: if (sc->sc_mbofull >= WDS_MBX_SIZE) {
! 713: c = WDSC_IRQMFREE;
! 714: wds_cmd(sc, &c, sizeof c);
! 715: break;
! 716: }
! 717: }
! 718:
! 719: TAILQ_REMOVE(&sc->sc_waiting_scb, scb, chain);
! 720: #ifdef WDSDIAG
! 721: scb->flags |= SCB_SENDING;
! 722: #endif
! 723:
! 724: /* Link scb to mbo. */
! 725: #ifdef notyet
! 726: isadma_copytobuf((caddr_t)scb, SCB_PHYS_SIZE,
! 727: 1, scb->scb_phys);
! 728: ltophys(scb->scb_phys[0].addr, wmbo->scb_addr);
! 729: #else
! 730: if (scb->flags & SCB_SENSE)
! 731: ltophys(KVTOPHYS(&scb->sense), wmbo->scb_addr);
! 732: else
! 733: ltophys(KVTOPHYS(&scb->cmd), wmbo->scb_addr);
! 734: #endif
! 735: /* XXX What about aborts? */
! 736: wmbo->cmd = WDS_MBO_START;
! 737:
! 738: /* Tell the card to poll immediately. */
! 739: c = WDSC_MSTART(wmbo - wmbx->mbo);
! 740: wds_cmd(sc, &c, sizeof c);
! 741:
! 742: if ((scb->flags & SCB_POLLED) == 0) {
! 743: timeout_set(&scb->xs->stimeout, wds_timeout, scb);
! 744: timeout_add(&scb->xs->stimeout, (scb->timeout * hz) / 1000);
! 745: }
! 746:
! 747: ++sc->sc_mbofull;
! 748: wds_nextmbx(wmbo, wmbx, mbo);
! 749: }
! 750:
! 751: wmbx->tmbo = wmbo;
! 752: }
! 753:
! 754: /*
! 755: * Process the result of a SCSI command.
! 756: */
! 757: void
! 758: wds_done(sc, scb, stat)
! 759: struct wds_softc *sc;
! 760: struct wds_scb *scb;
! 761: u_int8_t stat;
! 762: {
! 763: struct scsi_xfer *xs = scb->xs;
! 764:
! 765: /* XXXXX */
! 766:
! 767: /* Don't release the SCB if it was an internal command. */
! 768: if (xs == 0) {
! 769: scb->flags |= SCB_DONE;
! 770: return;
! 771: }
! 772:
! 773: /* Sense handling. */
! 774: if (xs->error == XS_SENSE) {
! 775: bcopy(&scb->sense_data, &xs->sense, sizeof (struct scsi_sense_data));
! 776: } else {
! 777: if (xs->error == XS_NOERROR) {
! 778: /* If all went well, or an error is acceptable. */
! 779: if (stat == WDS_MBI_OK) {
! 780: /* OK, set the result */
! 781: xs->resid = 0;
! 782: } else {
! 783: /* Check the mailbox status. */
! 784: switch (stat) {
! 785: case WDS_MBI_OKERR:
! 786: /* SCSI error recorded in scb, counts as WDS_MBI_OK */
! 787: switch (scb->cmd.venderr) {
! 788: case 0x00:
! 789: printf("%s: Is this an error?\n", sc->sc_dev.dv_xname);
! 790: xs->error = XS_DRIVER_STUFFUP; /* Experiment */
! 791: break;
! 792: case 0x01:
! 793: /*printf("%s: OK, see SCSI error field.\n", sc->sc_dev.dv_xname);*/
! 794: if (scb->cmd.stat == SCSI_CHECK) {
! 795: /* Do sense. */
! 796: wds_sense (sc, scb);
! 797: return;
! 798: } else if (scb->cmd.stat == SCSI_BUSY) {
! 799: xs->error = XS_BUSY;
! 800: }
! 801: break;
! 802: case 0x40:
! 803: /*printf("%s: DMA underrun!\n", sc->sc_dev.dv_xname);*/
! 804: /* Hits this if the target returns fewer that datalen bytes (eg my CD-ROM,
! 805: which returns a short version string, or if DMA is turned off etc. */
! 806: xs->resid = 0;
! 807: break;
! 808: default:
! 809: printf("%s: VENDOR ERROR %02x, scsi %02x\n", sc->sc_dev.dv_xname, scb->cmd.venderr, scb->cmd.stat);
! 810: xs->error = XS_DRIVER_STUFFUP; /* Experiment */
! 811: break;
! 812: }
! 813: break;
! 814: case WDS_MBI_ETIME:
! 815: /*
! 816: * The documentation isn't clear on
! 817: * what conditions might generate this,
! 818: * but selection timeouts are the only
! 819: * one I can think of.
! 820: */
! 821: xs->error = XS_SELTIMEOUT;
! 822: break;
! 823: case WDS_MBI_ERESET:
! 824: case WDS_MBI_ETARCMD:
! 825: case WDS_MBI_ERESEL:
! 826: case WDS_MBI_ESEL:
! 827: case WDS_MBI_EABORT:
! 828: case WDS_MBI_ESRESET:
! 829: case WDS_MBI_EHRESET:
! 830: xs->error = XS_DRIVER_STUFFUP;
! 831: break;
! 832: }
! 833: }
! 834: } /* else sense */
! 835:
! 836: if (NEEDBUFFER(sc) && xs->datalen) {
! 837: if (xs->flags & SCSI_DATA_IN)
! 838: bcopy(scb->buf->data, xs->data, xs->datalen);
! 839: }
! 840: } /* XS_NOERROR */
! 841:
! 842: #ifdef notyet
! 843: if (scb->data_nseg) {
! 844: if (xs->flags & SCSI_DATA_IN)
! 845: isadma_copyfrombuf(xs->data, xs->datalen,
! 846: scb->data_nseg, scb->data_phys);
! 847: isadma_unmap(xs->data, xs->datalen,
! 848: scb->data_nseg, scb->data_phys);
! 849: }
! 850: #endif
! 851: wds_free_scb(sc, scb);
! 852: xs->flags |= ITSDONE;
! 853: scsi_done(xs);
! 854: }
! 855:
! 856: int
! 857: wds_find(ia, sc)
! 858: struct isa_attach_args *ia;
! 859: struct wds_softc *sc;
! 860: {
! 861: bus_space_tag_t iot = ia->ia_iot;
! 862: bus_space_handle_t ioh;
! 863: u_char c;
! 864: int i;
! 865:
! 866: /*
! 867: * Sending a command causes the CMDRDY bit to clear.
! 868: */
! 869: c = bus_space_read_1(iot, ioh, WDS_STAT);
! 870: for (i = 0; i < 4; i++)
! 871: if ((bus_space_read_1(iot, ioh, WDS_STAT) & WDSS_RDY) != 0) {
! 872: goto ready;
! 873: delay(10);
! 874: }
! 875: return (0);
! 876:
! 877: ready:
! 878: bus_space_write_1(iot, ioh, WDS_CMD, WDSC_NOOP);
! 879: if (bus_space_read_1(iot, ioh, WDS_STAT) & WDSS_RDY)
! 880: return (0);
! 881:
! 882: bus_space_write_1(iot, ioh, WDS_HCR, WDSH_SCSIRESET|WDSH_ASCRESET);
! 883: delay(10000);
! 884: bus_space_write_1(iot, ioh, WDS_HCR, 0x00);
! 885: delay(500000);
! 886: wds_wait(iot, ioh, WDS_STAT, WDSS_RDY, WDSS_RDY);
! 887: if (bus_space_read_1(iot, ioh, WDS_IRQSTAT) != 1)
! 888: if (bus_space_read_1(iot, ioh, WDS_IRQSTAT) != 7)
! 889: printf("%s: failed reset!!! %2x\n",
! 890: sc ? sc->sc_dev.dv_xname : "wds?",
! 891: bus_space_read_1(iot, ioh, WDS_IRQSTAT));
! 892:
! 893: if ((bus_space_read_1(iot, ioh, WDS_STAT) & (WDSS_RDY)) != WDSS_RDY) {
! 894: printf("%s: waiting for controller to become ready.",
! 895: sc ? sc->sc_dev.dv_xname : "wds?");
! 896: for (i = 0; i < 20; i++) {
! 897: if ((bus_space_read_1(iot, ioh, WDS_STAT) &
! 898: (WDSS_RDY)) == WDSS_RDY)
! 899: break;
! 900: printf(".");
! 901: delay(10000);
! 902: }
! 903: if ((bus_space_read_1(iot, ioh, WDS_STAT) & (WDSS_RDY)) !=
! 904: WDSS_RDY) {
! 905: printf(" failed\n");
! 906: return (0);
! 907: }
! 908: printf("\n");
! 909: }
! 910:
! 911: if (sc != NULL) {
! 912: /* XXX Can we do this better? */
! 913: /* who are we on the scsi bus? */
! 914: sc->sc_scsi_dev = 7;
! 915:
! 916: sc->sc_iot = iot;
! 917: sc->sc_ioh = ioh;
! 918: sc->sc_irq = ia->ia_irq;
! 919: sc->sc_drq = ia->ia_drq;
! 920: }
! 921:
! 922: return (1);
! 923: }
! 924:
! 925: /*
! 926: * Initialise the board and driver.
! 927: */
! 928: void
! 929: wds_init(sc)
! 930: struct wds_softc *sc;
! 931: {
! 932: bus_space_tag_t iot = sc->sc_iot;
! 933: bus_space_handle_t ioh = sc->sc_ioh;
! 934: struct wds_setup init;
! 935: u_char c;
! 936: int i;
! 937: #ifdef notyet
! 938: struct isadma_seg mbx_phys[1];
! 939: #endif
! 940:
! 941: /*
! 942: * Set up initial mail box for round-robin operation.
! 943: */
! 944: for (i = 0; i < WDS_MBX_SIZE; i++) {
! 945: wmbx->mbo[i].cmd = WDS_MBO_FREE;
! 946: wmbx->mbi[i].stat = WDS_MBI_FREE;
! 947: }
! 948: wmbx->cmbo = wmbx->tmbo = &wmbx->mbo[0];
! 949: wmbx->tmbi = &wmbx->mbi[0];
! 950: sc->sc_mbofull = 0;
! 951:
! 952: /* Clear the buffers. */
! 953: TAILQ_INIT(&wds_free_buffer);
! 954: for (i = 0; i < BUFCNT; i++) {
! 955: wds_buffer[i].busy = 0;
! 956: TAILQ_INSERT_HEAD(&wds_free_buffer, &wds_buffer[i], chain);
! 957: }
! 958:
! 959: init.opcode = WDSC_INIT;
! 960: init.scsi_id = sc->sc_scsi_dev;
! 961: /* Record scsi id of controller for use in scsi_attach */
! 962: sc->sc_scsi_dev = init.scsi_id;
! 963: init.buson_t = 48;
! 964: init.busoff_t = 24;
! 965: init.xx = 0;
! 966: #ifdef notyet
! 967: if (isadma_map((caddr_t)(wmbx), sizeof(struct wds_mbx),
! 968: mbx_phys, ISADMA_MAP_CONTIG) != 1)
! 969: panic("wds_init: cannot map mail box");
! 970: ltophys(mbx_phys[0].addr, init.mbaddr);
! 971: #else
! 972: ltophys(KVTOPHYS(wmbx), init.mbaddr);
! 973: #endif
! 974: init.nomb = init.nimb = WDS_MBX_SIZE;
! 975: wds_cmd(sc, (u_char *)&init, sizeof init);
! 976:
! 977: wds_wait(iot, ioh, WDS_STAT, WDSS_INIT, WDSS_INIT);
! 978:
! 979: c = WDSC_DISUNSOL;
! 980: wds_cmd(sc, &c, sizeof c);
! 981:
! 982: bus_space_write_1(iot, ioh, WDS_HCR, WDSH_DRQEN);
! 983: }
! 984:
! 985: /*
! 986: * Read the board's firmware revision information.
! 987: */
! 988: void
! 989: wds_inquire_setup_information(sc)
! 990: struct wds_softc *sc;
! 991: {
! 992: struct wds_scb *scb;
! 993: u_char *j;
! 994: int s;
! 995:
! 996: if ((scb = wds_get_scb(sc, SCSI_NOSLEEP, 0)) == NULL) {
! 997: printf("%s: no request slot available in getvers()!\n",
! 998: sc->sc_dev.dv_xname);
! 999: return;
! 1000: }
! 1001: scb->xs = NULL;
! 1002: scb->timeout = 40;
! 1003:
! 1004: bzero(&scb->cmd, sizeof scb->cmd);
! 1005: scb->cmd.write = 0x80;
! 1006: scb->cmd.opcode = WDSX_GETFIRMREV;
! 1007:
! 1008: /* Will poll card, await result. */
! 1009: bus_space_write_1(sc->sc_iot, sc->sc_ioh, WDS_HCR, WDSH_DRQEN);
! 1010: scb->flags |= SCB_POLLED;
! 1011:
! 1012: s = splbio();
! 1013: wds_queue_scb(sc, scb);
! 1014: splx(s);
! 1015:
! 1016: if (wds_ipoll(sc, scb, scb->timeout))
! 1017: goto out;
! 1018:
! 1019: /* Print the version number. */
! 1020: printf(": version %x.%02x ", scb->cmd.targ, scb->cmd.scb.opcode);
! 1021: sc->sc_revision = (scb->cmd.targ << 8) | scb->cmd.scb.opcode;
! 1022: /* Print out the version string. */
! 1023: j = 2 + &(scb->cmd.targ);
! 1024: while ((*j >= 32) && (*j < 128)) {
! 1025: printf("%c", *j);
! 1026: j++;
! 1027: }
! 1028:
! 1029: out:
! 1030: printf("\n");
! 1031: wds_free_scb(sc, scb);
! 1032: }
! 1033:
! 1034: void
! 1035: wdsminphys(bp)
! 1036: struct buf *bp;
! 1037: {
! 1038: if (bp->b_bcount > ((WDS_NSEG - 1) << PGSHIFT))
! 1039: bp->b_bcount = ((WDS_NSEG - 1) << PGSHIFT);
! 1040: minphys(bp);
! 1041: }
! 1042:
! 1043: /*
! 1044: * Send a SCSI command.
! 1045: */
! 1046: int
! 1047: wds_scsi_cmd(xs)
! 1048: struct scsi_xfer *xs;
! 1049: {
! 1050: struct scsi_link *sc_link = xs->sc_link;
! 1051: struct wds_softc *sc = sc_link->adapter_softc;
! 1052: bus_space_tag_t iot = sc->sc_iot;
! 1053: bus_space_handle_t ioh = sc->sc_ioh;
! 1054: struct wds_scb *scb;
! 1055: struct wds_scat_gath *sg;
! 1056: int seg;
! 1057: u_long thiskv, thisphys, nextphys;
! 1058: int bytes_this_seg, bytes_this_page, datalen, flags;
! 1059: #ifdef TFS
! 1060: struct iovec *iovp;
! 1061: #endif
! 1062: int s;
! 1063: #ifdef notyet
! 1064: int mflags;
! 1065: #endif
! 1066:
! 1067: if (xs->flags & SCSI_RESET) {
! 1068: /* XXX Fix me! */
! 1069: printf("%s: reset!\n", sc->sc_dev.dv_xname);
! 1070: wds_init(sc);
! 1071: return COMPLETE;
! 1072: }
! 1073:
! 1074: flags = xs->flags;
! 1075: #ifdef notyet
! 1076: if (flags & SCSI_NOSLEEP)
! 1077: mflags = ISADMA_MAP_BOUNCE;
! 1078: else
! 1079: mflags = ISADMA_MAP_BOUNCE | ISADMA_MAP_WAITOK;
! 1080: #endif
! 1081: if ((scb = wds_get_scb(sc, flags, NEEDBUFFER(sc))) == NULL) {
! 1082: return TRY_AGAIN_LATER;
! 1083: }
! 1084: scb->xs = xs;
! 1085: scb->timeout = xs->timeout;
! 1086:
! 1087: if (xs->flags & SCSI_DATA_UIO) {
! 1088: /* XXX Fix me! */
! 1089: /* Let's not worry about UIO. There isn't any code for the *
! 1090: * non-SG boards anyway! */
! 1091: printf("%s: UIO is untested and disabled!\n", sc->sc_dev.dv_xname);
! 1092: goto bad;
! 1093: }
! 1094:
! 1095: /* Zero out the command structure. */
! 1096: bzero(&scb->cmd, sizeof scb->cmd);
! 1097: bcopy(xs->cmd, &scb->cmd.scb, xs->cmdlen < 12 ? xs->cmdlen : 12);
! 1098:
! 1099: /* Set up some of the command fields. */
! 1100: scb->cmd.targ = (xs->sc_link->target << 5) | xs->sc_link->lun;
! 1101:
! 1102: /* NOTE: cmd.write may be OK as 0x40 (disable direction checking)
! 1103: * on boards other than the WD-7000V-ASE. Need this for the ASE:
! 1104: */
! 1105: scb->cmd.write = (xs->flags & SCSI_DATA_IN) ? 0x80 : 0x00;
! 1106:
! 1107: if (!NEEDBUFFER(sc) && xs->datalen) {
! 1108: sg = scb->scat_gath;
! 1109: seg = 0;
! 1110: #ifdef TFS
! 1111: if (flags & SCSI_DATA_UIO) {
! 1112: iovp = ((struct uio *)xs->data)->uio_iov;
! 1113: datalen = ((struct uio *)xs->data)->uio_iovcnt;
! 1114: xs->datalen = 0;
! 1115: while (datalen && seg < WDS_NSEG) {
! 1116: ltophys(iovp->iov_base, sg->seg_addr);
! 1117: ltophys(iovp->iov_len, sg->seg_len);
! 1118: xs->datalen += iovp->iov_len;
! 1119: SC_DEBUGN(sc_link, SDEV_DB4, ("UIO(0x%x@0x%x)",
! 1120: iovp->iov_len, iovp->iov_base));
! 1121: sg++;
! 1122: iovp++;
! 1123: seg++;
! 1124: datalen--;
! 1125: }
! 1126: } else
! 1127: #endif /* TFS */
! 1128: {
! 1129: /*
! 1130: * Set up the scatter-gather block.
! 1131: */
! 1132: SC_DEBUG(sc_link, SDEV_DB4,
! 1133: ("%d @0x%x:- ", xs->datalen, xs->data));
! 1134:
! 1135: #ifdef notyet
! 1136: scb->data_nseg = isadma_map(xs->data, xs->datalen,
! 1137: scb->data_phys, mflags);
! 1138: for (seg = 0; seg < scb->data_nseg; seg++) {
! 1139: ltophys(scb->data_phys[seg].addr,
! 1140: sg[seg].seg_addr);
! 1141: ltophys(scb->data_phys[seg].length,
! 1142: sg[seg].seg_len);
! 1143: }
! 1144: #else
! 1145: datalen = xs->datalen;
! 1146: thiskv = (int)xs->data;
! 1147: thisphys = KVTOPHYS(xs->data);
! 1148:
! 1149: while (datalen && seg < WDS_NSEG) {
! 1150: bytes_this_seg = 0;
! 1151:
! 1152: /* put in the base address */
! 1153: ltophys(thisphys, sg->seg_addr);
! 1154:
! 1155: SC_DEBUGN(sc_link, SDEV_DB4, ("0x%x", thisphys));
! 1156:
! 1157: /* do it at least once */
! 1158: nextphys = thisphys;
! 1159: while (datalen && thisphys == nextphys) {
! 1160: /*
! 1161: * This page is contiguous (physically)
! 1162: * with the last, just extend the
! 1163: * length
! 1164: */
! 1165: /* check it fits on the ISA bus */
! 1166: if (thisphys > 0xFFFFFF) {
! 1167: printf("%s: DMA beyond"
! 1168: " end of ISA\n",
! 1169: sc->sc_dev.dv_xname);
! 1170: goto bad;
! 1171: }
! 1172: /* how far to the end of the page */
! 1173: nextphys = (thisphys & ~PGOFSET) + NBPG;
! 1174: bytes_this_page = nextphys - thisphys;
! 1175: /**** or the data ****/
! 1176: bytes_this_page = min(bytes_this_page,
! 1177: datalen);
! 1178: bytes_this_seg += bytes_this_page;
! 1179: datalen -= bytes_this_page;
! 1180:
! 1181: /* get more ready for the next page */
! 1182: thiskv = (thiskv & ~PGOFSET) + NBPG;
! 1183: if (datalen)
! 1184: thisphys = KVTOPHYS(thiskv);
! 1185: }
! 1186: /*
! 1187: * next page isn't contiguous, finish the seg
! 1188: */
! 1189: SC_DEBUGN(sc_link, SDEV_DB4,
! 1190: ("(0x%x)", bytes_this_seg));
! 1191: ltophys(bytes_this_seg, sg->seg_len);
! 1192: sg++;
! 1193: seg++;
! 1194: #endif
! 1195: }
! 1196: }
! 1197: /* end of iov/kv decision */
! 1198: SC_DEBUGN(sc_link, SDEV_DB4, ("\n"));
! 1199: if (datalen) {
! 1200: /*
! 1201: * there's still data, must have run out of segs!
! 1202: */
! 1203: printf("%s: wds_scsi_cmd, more than %d dma segs\n",
! 1204: sc->sc_dev.dv_xname, WDS_NSEG);
! 1205: goto bad;
! 1206: }
! 1207: #ifdef notyet
! 1208: if (scb->data_nseg == 0) {
! 1209: printf("%s: wds_scsi_cmd, cannot map\n",
! 1210: sc->sc_dev.dv_xname);
! 1211: goto bad;
! 1212: } else if (flags & SCSI_DATA_OUT)
! 1213: isadma_copytobuf(xs->data, xs->datalen,
! 1214: scb->data_nseg, scb->data_phys);
! 1215: ltophys((unsigned)((struct wds_scb *)(scb->scb_phys[0].addr))->scat_gath,
! 1216: scb->data_addr);
! 1217: ltophys(scb->data_nseg * sizeof(struct wds_scat_gath),
! 1218: scb->data_length);
! 1219: #else
! 1220: scb->cmd.opcode = WDSX_SCSISG;
! 1221: ltophys(KVTOPHYS(scb->scat_gath), scb->cmd.data);
! 1222: ltophys(seg * sizeof(struct wds_scat_gath), scb->cmd.len);
! 1223: #endif
! 1224: } else if (xs->datalen > 0) {
! 1225: /* The board is an ASC or ASE. Do not use scatter/gather. */
! 1226: if (xs->datalen > BUFLEN) {
! 1227: printf("%s: wds_scsi_cmd, I/O too large for bounce buffer\n",
! 1228: sc->sc_dev.dv_xname);
! 1229: goto bad;
! 1230: }
! 1231: if (xs->flags & SCSI_DATA_OUT)
! 1232: bcopy(xs->data, scb->buf->data, xs->datalen);
! 1233: else
! 1234: bzero(scb->buf->data, xs->datalen);
! 1235: scb->cmd.opcode = WDSX_SCSICMD;
! 1236: ltophys(KVTOPHYS(scb->buf->data), scb->cmd.data);
! 1237: ltophys(xs->datalen, scb->cmd.len);
! 1238: } else {
! 1239: scb->cmd.opcode = WDSX_SCSICMD;
! 1240: ltophys(0, scb->cmd.data);
! 1241: ltophys(0, scb->cmd.len);
! 1242: }
! 1243:
! 1244: scb->cmd.stat = 0x00;
! 1245: scb->cmd.venderr = 0x00;
! 1246: ltophys(0, scb->cmd.link);
! 1247:
! 1248: /* XXX Do we really want to do this? */
! 1249: if (flags & SCSI_POLL) {
! 1250: /* Will poll card, await result. */
! 1251: bus_space_write_1(iot, ioh, WDS_HCR, WDSH_DRQEN);
! 1252: scb->flags |= SCB_POLLED;
! 1253: } else {
! 1254: /* Will send command, let interrupt routine handle result. */
! 1255: bus_space_write_1(iot, ioh, WDS_HCR, WDSH_IRQEN | WDSH_DRQEN);
! 1256: }
! 1257:
! 1258: s = splbio();
! 1259: wds_queue_scb(sc, scb);
! 1260:
! 1261: #ifdef notyet
! 1262: if (VOLATILE_XS(xs)) {
! 1263: while ((scb->xs->flags & ITSDONE) == 0) {
! 1264: tsleep(scb, PRIBIO, "wdswait", 0);
! 1265: }
! 1266: if (scb->data_nseg) {
! 1267: if (flags & SCSI_DATA_IN)
! 1268: isadma_copyfrombuf(xs->data, xs->datalen,
! 1269: scb->data_nseg, scb->data_phys);
! 1270: isadma_unmap(xs->data, xs->datalen,
! 1271: scb->data_nseg, scb->data_phys);
! 1272: }
! 1273: wds_free_scb(sc, scb);
! 1274: scsi_done(xs);
! 1275: splx(s);
! 1276: return COMPLETE;
! 1277: }
! 1278: #endif
! 1279: splx(s);
! 1280:
! 1281: if ((flags & SCSI_POLL) == 0)
! 1282: return SUCCESSFULLY_QUEUED;
! 1283:
! 1284: if (wds_poll(sc, xs, scb->timeout)) {
! 1285: wds_timeout(scb);
! 1286: if (wds_poll(sc, xs, scb->timeout))
! 1287: wds_timeout(scb);
! 1288: }
! 1289: return COMPLETE;
! 1290:
! 1291: bad:
! 1292: xs->error = XS_DRIVER_STUFFUP;
! 1293: wds_free_scb(sc, scb);
! 1294: return COMPLETE;
! 1295: }
! 1296:
! 1297: /*
! 1298: * Send a sense request.
! 1299: */
! 1300: void
! 1301: wds_sense(sc, scb)
! 1302: struct wds_softc *sc;
! 1303: struct wds_scb *scb;
! 1304: {
! 1305: struct scsi_xfer *xs = scb->xs;
! 1306: struct scsi_sense *ss = (void *)&scb->sense.scb;
! 1307: int s;
! 1308:
! 1309: /* XXXXX */
! 1310:
! 1311: /* Send sense request SCSI command. */
! 1312: xs->error = XS_SENSE;
! 1313: scb->flags |= SCB_SENSE;
! 1314:
! 1315: /* First, save the return values */
! 1316: if (NEEDBUFFER(sc) && xs->datalen) {
! 1317: if (xs->flags & SCSI_DATA_IN)
! 1318: bcopy(scb->buf->data, xs->data, xs->datalen);
! 1319: }
! 1320:
! 1321: /* Next, setup a request sense command block */
! 1322: bzero(ss, sizeof(*ss));
! 1323: ss->opcode = REQUEST_SENSE;
! 1324: ss->byte2 = xs->sc_link->lun << 5;
! 1325: ss->length = sizeof(struct scsi_sense_data);
! 1326:
! 1327: /* Set up some of the command fields. */
! 1328: scb->sense.targ = scb->cmd.targ;
! 1329: scb->sense.write = 0x80;
! 1330: scb->sense.opcode = WDSX_SCSICMD;
! 1331: ltophys(KVTOPHYS(&scb->sense_data), scb->sense.data);
! 1332: ltophys(sizeof(struct scsi_sense_data), scb->sense.len);
! 1333:
! 1334: s = splbio();
! 1335: wds_queue_scb(sc, scb);
! 1336: splx(s);
! 1337:
! 1338: /*
! 1339: * There's no reason for us to poll here. There are two cases:
! 1340: * 1) If it's a polling operation, then we're called from the interrupt
! 1341: * handler, and we return and continue polling.
! 1342: * 2) If it's an interrupt-driven operation, then it gets completed
! 1343: * later on when the REQUEST SENSE finishes.
! 1344: */
! 1345: }
! 1346:
! 1347: /*
! 1348: * Poll a particular unit, looking for a particular scb
! 1349: */
! 1350: int
! 1351: wds_poll(sc, xs, count)
! 1352: struct wds_softc *sc;
! 1353: struct scsi_xfer *xs;
! 1354: int count;
! 1355: {
! 1356: bus_space_tag_t iot = sc->sc_iot;
! 1357: bus_space_handle_t ioh = sc->sc_ioh;
! 1358:
! 1359: /* timeouts are in msec, so we loop in 1000 usec cycles */
! 1360: while (count) {
! 1361: /*
! 1362: * If we had interrupts enabled, would we
! 1363: * have got an interrupt?
! 1364: */
! 1365: if (bus_space_read_1(iot, ioh, WDS_STAT) & WDSS_IRQ)
! 1366: wdsintr(sc);
! 1367: if (xs->flags & ITSDONE)
! 1368: return 0;
! 1369: delay(1000); /* only happens in boot so ok */
! 1370: count--;
! 1371: }
! 1372: return 1;
! 1373: }
! 1374:
! 1375: /*
! 1376: * Poll a particular unit, looking for a particular scb
! 1377: */
! 1378: int
! 1379: wds_ipoll(sc, scb, count)
! 1380: struct wds_softc *sc;
! 1381: struct wds_scb *scb;
! 1382: int count;
! 1383: {
! 1384: bus_space_tag_t iot = sc->sc_iot;
! 1385: bus_space_handle_t ioh = sc->sc_ioh;
! 1386:
! 1387: /* timeouts are in msec, so we loop in 1000 usec cycles */
! 1388: while (count) {
! 1389: /*
! 1390: * If we had interrupts enabled, would we
! 1391: * have got an interrupt?
! 1392: */
! 1393: if (bus_space_read_1(iot, ioh, WDS_STAT) & WDSS_IRQ)
! 1394: wdsintr(sc);
! 1395: if (scb->flags & SCB_DONE)
! 1396: return 0;
! 1397: delay(1000); /* only happens in boot so ok */
! 1398: count--;
! 1399: }
! 1400: return 1;
! 1401: }
! 1402:
! 1403: void
! 1404: wds_timeout(arg)
! 1405: void *arg;
! 1406: {
! 1407: struct wds_scb *scb = arg;
! 1408: struct scsi_xfer *xs;
! 1409: struct scsi_link *sc_link;
! 1410: struct wds_softc *sc;
! 1411: int s;
! 1412:
! 1413: s = splbio();
! 1414: #ifdef notyet
! 1415: isadma_copyfrombuf((caddr_t)scb, SCB_PHYS_SIZE, 1, scb->scb_phys);
! 1416: #endif
! 1417: xs = scb->xs;
! 1418: sc_link = xs->sc_link;
! 1419: sc = sc_link->adapter_softc;
! 1420:
! 1421: sc_print_addr(sc_link);
! 1422: printf("timed out");
! 1423:
! 1424: #ifdef WDSDIAG
! 1425: /*
! 1426: * If The scb's mbx is not free, then the board has gone south?
! 1427: */
! 1428: wds_collect_mbo(sc);
! 1429: if (scb->flags & SCB_SENDING) {
! 1430: printf("%s: not taking commands!\n", sc->sc_dev.dv_xname);
! 1431: Debugger();
! 1432: }
! 1433: #endif
! 1434:
! 1435: /*
! 1436: * If it has been through before, then
! 1437: * a previous abort has failed, don't
! 1438: * try abort again
! 1439: */
! 1440: if (scb->flags & SCB_ABORT) {
! 1441: /* abort timed out */
! 1442: printf(" AGAIN\n");
! 1443: /* XXX Must reset! */
! 1444: } else {
! 1445: /* abort the operation that has timed out */
! 1446: printf("\n");
! 1447: scb->xs->error = XS_TIMEOUT;
! 1448: scb->timeout = WDS_ABORT_TIMEOUT;
! 1449: scb->flags |= SCB_ABORT;
! 1450: wds_queue_scb(sc, scb);
! 1451: }
! 1452:
! 1453: splx(s);
! 1454: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to wds.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa