root/dev/isa/wds.c

DEFINITIONS

1. wds_wait
2. wds_cmd
3. wdsprobe
4. wdsprint
5. wdsattach
6. wds_finish_scbs
7. wdsintr
8. wds_reset_scb
9. wds_free_scb
10. wds_free_buf
11. wds_init_scb
12. wds_get_scb
13. wds_get_buf
14. wds_scb_phys_kv
15. wds_queue_scb
16. wds_collect_mbo
17. wds_start_scbs
18. wds_done
19. wds_find
20. wds_init
21. wds_inquire_setup_information
22. wdsminphys
23. wds_scsi_cmd
24. VOLATILE_XS
25. wds_poll
26. wds_sense
27. wds_poll
28. wds_ipoll
29. wds_timeout

    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 $ */
    4 #undef  WDSDIAG
    5 #ifdef DDB
    6 #define integrate
    7 #else
    8 #define integrate       static inline
    9 #endif
   11 /*
   12  * XXX
   13  * sense data
   14  * aborts
   15  * resets
   16  */
   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  */
   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  */
   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>
   72 #include <machine/bus.h>
   73 #include <machine/intr.h>
   75 #include <scsi/scsi_all.h>
   76 #include <scsi/scsiconf.h>
   78 #include <dev/isa/isavar.h>
   79 #include <dev/isa/isadmavar.h>
   80 #include <dev/isa/wdsreg.h>
   82 #ifndef DDB
   83 #define Debugger() panic("should call debugger here (wds.c)")
   84 #endif /* ! DDB */
   86 #define WDS_MBX_SIZE    16
   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))
   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)++;
   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 };
  107 #define KVTOPHYS(x)     vtophys((vaddr_t)(x))
  109 struct wds_softc {
  110         struct device sc_dev;
  111         struct isadev sc_id;
  112         void *sc_ih;
bus_space_tag_t sc_iot;         /* bus identifier */
bus_space_handle_t sc_ioh;      /* io handle */
  116         int sc_irq, sc_drq;
  118         int sc_revision;
  120         struct wds_mbx sc_mbx;
  121 #define wmbx    (&sc->sc_mbx)
  122         struct wds_scb *sc_scbhash[SCB_HASH_SIZE];
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 };
  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)
  136 struct wds_buf {
u_char data[BUFLEN];
  138         int    busy;
TAILQ_ENTRY(wds_buf) chain;
  140 } wds_buffer[BUFCNT];
TAILQ_HEAD(, wds_buf) wds_free_buffer;
  144 #ifdef WDSDEBUG
  145 int wds_debug = WDSDEBUG;
  146 #endif
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);
integrate void wds_finish_scbs(struct wds_softc *);
  151 int     wdsintr(void *);
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 *);
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 *);
  174 struct scsi_adapter wds_switch = {
wds_scsi_cmd,
wdsminphys,
  177         0,
  178         0,
  179 };
  181 /* the below structure is so we have a default dev struct for our link struct */
  182 struct scsi_device wds_dev = {
NULL,                   /* Use default error handler */
NULL,                   /* have a queue, served by this */
NULL,                   /* have no async handler */
NULL,                   /* Use default 'done' routine */
  187 };
  189 int     wdsprobe(struct device *, void *, void *);
  190 void    wdsattach(struct device *, struct device *, void *);
  192 struct cfattach wds_ca = {
  193         sizeof(struct wds_softc), wdsprobe, wdsattach
  194 };
  196 struct cfdriver wds_cd = {
NULL, "wds", DV_DULL
  198 };
  200 #define WDS_ABORT_TIMEOUT       2000    /* time to wait for abort (mSec) */
integrate void
wds_wait(iot, ioh, port, mask, val)
bus_space_tag_t iot;
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 }
  214 /*
  215  * Write a command to the board's I/O ports.
  216  */
  217 int
wds_cmd(sc, ibuf, icnt)
  219         struct wds_softc *sc;
u_int8_t *ibuf;
  221         int icnt;
  222 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
u_int8_t c;
wds_wait(iot, ioh, WDS_STAT, WDSS_RDY, WDSS_RDY);
  229         while (icnt--) {
bus_space_write_1(iot, ioh, WDS_CMD, *ibuf++);
wds_wait(iot, ioh, WDS_STAT, WDSS_RDY, WDSS_RDY);
c = bus_space_read_1(iot, ioh, WDS_STAT);
  233                 if (c & WDSS_REJ)
  234                         return 1;
  235         }
  237         return 0;
  238 }
  240 /*
  241  * Check for the presence of a WD7000 SCSI controller.
  242  */
  243 int
wdsprobe(parent, match, aux)
  245         struct device *parent;
  246         void *match, *aux;
  247 {
  248         register struct isa_attach_args *ia = aux;
bus_space_tag_t iot = ia->ia_iot;
bus_space_handle_t ioh;
  251         int rv;
  253         if (bus_space_map(iot, ia->ia_iobase, WDS_IO_PORTS, 0, &ioh))
  254                 return (0);
  256         /* See if there is a unit at this location. */
rv = wds_find(ia, NULL);
bus_space_unmap(iot, ioh, WDS_IO_PORTS);
  261         if (rv) {
ia->ia_msize = 0;
ia->ia_iosize = WDS_IO_PORTS;
  264         }
  266         return (rv);
  267 }
  269 int
wdsprint(aux, name)
  271         void *aux;
  272         const char *name;
  273 {
  275         if (name != NULL)
printf("%s: scsibus ", name);
  277         return UNCONF;
  278 }
  280 /*
  281  * Attach all available units.
  282  */
  283 void
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;
bus_space_tag_t iot = ia->ia_iot;
bus_space_handle_t ioh;
  294         if (bus_space_map(iot, ia->ia_iobase, WDS_IO_PORTS, 0, &ioh)) {
printf("%s: can't map i/o space\n", sc->sc_dev.dv_xname);
  296                 return;
  297         }
  299         if (!wds_find(ia, sc))
panic("wdsattach: wds_find of %s failed", self->dv_xname);
wds_init(sc);
  303         if (sc->sc_drq != DRQUNK)
isadma_cascade(sc->sc_drq);
TAILQ_INIT(&sc->sc_free_scb);
TAILQ_INIT(&sc->sc_waiting_scb);
wds_inquire_setup_information(sc);
  310         /*
  311          * fill in the prototype scsi_link.
  312          */
  313 #ifdef notyet
sc->sc_link.channel = SCSI_CHANNEL_ONLY_ONE;
  315 #endif
sc->sc_link.adapter_softc = sc;
sc->sc_link.adapter_target = sc->sc_scsi_dev;
sc->sc_link.adapter = &wds_switch;
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.     */
sc->sc_link.openings = 1;
sc->sc_ih = isa_intr_establish(ia->ia_ic, sc->sc_irq, IST_EDGE,
IPL_BIO, wdsintr, sc, sc->sc_dev.dv_xname);
bzero(&saa, sizeof(saa));
saa.saa_sc_link = &sc->sc_link;
  331         /*
  332          * ask the adapter what subunits are present
  333          */
config_found(self, &saa, wdsprint);
  335 }
integrate void
wds_finish_scbs(sc)
  339         struct wds_softc *sc;
  340 {
  341         struct wds_mbx_in *wmbi;
  342         struct wds_scb *scb;
  343         int i;
wmbi = wmbx->tmbi;
  347         if (wmbi->stat == WDS_MBI_FREE) {
  348                 for (i = 0; i < WDS_MBX_SIZE; i++) {
  349                         if (wmbi->stat != WDS_MBI_FREE) {
printf("%s: mbi not in round-robin order\n",
sc->sc_dev.dv_xname);
  352                                 goto AGAIN;
  353                         }
wds_nextmbx(wmbi, wmbx, mbi);
  355                 }
  356 #ifdef WDSDIAGnot
printf("%s: mbi interrupt with no full mailboxes\n",
sc->sc_dev.dv_xname);
  359 #endif
  360                 return;
  361         }
AGAIN:
  364         do {
scb = wds_scb_phys_kv(sc, phystol(wmbi->scb_addr));
  366                 if (!scb) {
printf("%s: bad mbi scb pointer; skipping\n",
sc->sc_dev.dv_xname);
  369                         goto next;
  370                 }
  372 #ifdef WDSDEBUG
  373                 if (wds_debug) {
u_int8_t *cp = (u_int8_t *)&scb->cmd.scb;
printf("op=%x %x %x %x %x %x\n",
cp[0], cp[1], cp[2], cp[3], cp[4], cp[5]);
printf("stat %x for mbi addr = 0x%08x, ",
wmbi->stat, wmbi);
printf("scb addr = 0x%x\n", scb);
  380                 }
  381 #endif /* WDSDEBUG */
timeout_del(&scb->xs->stimeout);
  384 #ifdef notyet
isadma_copyfrombuf((caddr_t)scb, SCB_PHYS_SIZE,
  386                     1, scb->scb_phys);
  387 #endif
wds_done(sc, scb, wmbi->stat);
next:
wmbi->stat = WDS_MBI_FREE;
wds_nextmbx(wmbi, wmbx, mbi);
  393         } while (wmbi->stat != WDS_MBI_FREE);
wmbx->tmbi = wmbi;
  396 }
  398 /*
  399  * Process an interrupt.
  400  */
  401 int
wdsintr(arg)
  403         void *arg;
  404 {
  405         struct wds_softc *sc = arg;
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
u_char c;
  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;
  414         /* Get the interrupt status byte. */
c = bus_space_read_1(iot, ioh, WDS_IRQSTAT) & WDSI_MASK;
  417         /* Acknowledge (which resets) the interrupt. */
bus_space_write_1(iot, ioh, WDS_IRQACK, 0x00);
  420         switch (c) {
  421         case WDSI_MSVC:
wds_finish_scbs(sc);
  423                 break;
  425         case WDSI_MFREE:
wds_start_scbs(sc);
  427                 break;
  429         default:
printf("%s: unrecognized interrupt type %02x",
sc->sc_dev.dv_xname, c);
  432                 break;
  433         }
  435         return 1;
  436 }
integrate void
wds_reset_scb(sc, scb)
  440         struct wds_softc *sc;
  441         struct wds_scb *scb;
  442 {
scb->flags = 0;
  445 }
  447 /*
  448  * Free the command structure, the outgoing mailbox and the data buffer.
  449  */
  450 void
wds_free_scb(sc, scb)
  452         struct wds_softc *sc;
  453         struct wds_scb *scb;
  454 {
  455         int s;
  457         if (scb->buf != 0) {
wds_free_buf(sc, scb->buf);
scb->buf = 0;
  460         }
s = splbio();
  464 #ifdef notyet
  465         if (scb->scb_phys[0].addr)
isadma_unmap((caddr_t)scb, SCB_PHYS_SIZE, 1, scb->scb_phys);
  467 #endif
wds_reset_scb(sc, scb);
TAILQ_INSERT_HEAD(&sc->sc_free_scb, scb, chain);
  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)
wakeup(&sc->sc_free_scb);
splx(s);
  480 }
  482 void
wds_free_buf(sc, buf)
  484         struct wds_softc *sc;
  485         struct wds_buf *buf;
  486 {
  487         int s;
s = splbio();
buf->busy = 0;
TAILQ_INSERT_HEAD(&wds_free_buffer, buf, chain);
  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)
wakeup(&wds_free_buffer);
splx(s);
  502 }
integrate void
wds_init_scb(sc, scb)
  506         struct wds_softc *sc;
  507         struct wds_scb *scb;
  508 {
  509         int hashnum;
bzero(scb, sizeof(struct wds_scb));
  512         /*
  513          * put in the phystokv hash table
  514          * Never gets taken out.
  515          */
scb->hashkey = KVTOPHYS(scb);
hashnum = SCB_HASH(scb->hashkey);
scb->nexthash = sc->sc_scbhash[hashnum];
sc->sc_scbhash[hashnum] = scb;
wds_reset_scb(sc, scb);
  521 }
  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 *
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
s = splbio();
  543 #ifdef notyet
  544         if (flags & SCSI_NOSLEEP)
mflags = ISADMA_MAP_BOUNCE;
  546         else
mflags = ISADMA_MAP_BOUNCE | ISADMA_MAP_WAITOK;
  548 #endif
  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 (;;) {
scb = TAILQ_FIRST(&sc->sc_free_scb);
  556                 if (scb) {
TAILQ_REMOVE(&sc->sc_free_scb, scb, chain);
  558                         break;
  559                 }
  560                 if (sc->sc_numscbs < WDS_SCB_MAX) {
scb = (struct wds_scb *) malloc(sizeof(struct wds_scb),
M_TEMP, M_NOWAIT);
  563                         if (!scb) {
printf("%s: can't malloc scb\n",
sc->sc_dev.dv_xname);
  566                                 goto out;
  567                         }
wds_init_scb(sc, scb);
sc->sc_numscbs++;
  570                         break;
  571                 }
  572                 if ((flags & SCSI_NOSLEEP) != 0)
  573                         goto out;
tsleep(&sc->sc_free_scb, PRIBIO, "wdsscb", 0);
  575         }
scb->flags |= SCB_ALLOC;
  579 #ifdef notyet
  580         if (isadma_map((caddr_t)scb, SCB_PHYS_SIZE, scb->scb_phys,
mflags | ISADMA_MAP_CONTIG) == 1) {
hashnum = SCB_HASH(scb->scb_phys[0].addr);
scb->nexthash = sc->sc_scbhash[hashnum];
sc->sc_scbhash[hashnum] = ccb;
  585         } else {
scb->scb_phys[0].addr = 0;
wds_free_scb(sc, scb);
scb = 0;
  589         }
  590 #else
  591         if (needbuffer) {
scb->buf = wds_get_buf(sc, flags);
  593                 if (scb->buf == 0) {
wds_free_scb(sc, scb);
scb = 0;
  596                 }
  597         }
  598 #endif
out:
splx(s);
  603         return (scb);
  604 }
  606 struct wds_buf *
wds_get_buf(sc, flags)
  608         struct wds_softc *sc;
  609         int flags;
  610 {
  611         struct wds_buf *buf;
  612         int s;
s = splbio();
  616         for (;;) {
buf = TAILQ_FIRST(&wds_free_buffer);
  618                 if (buf) {
TAILQ_REMOVE(&wds_free_buffer, buf, chain);
  620                         break;
  621                 }
  622                 if ((flags & SCSI_NOSLEEP) != 0)
  623                         goto out;
tsleep(&wds_free_buffer, PRIBIO, "wdsbuf", 0);
  625         }
buf->busy = 1;
out:
splx(s);
  631         return (buf);
  632 }
  634 struct wds_scb *
wds_scb_phys_kv(sc, scb_phys)
  636         struct wds_softc *sc;
u_long scb_phys;
  638 {
  639         int hashnum = SCB_HASH(scb_phys);
  640         struct wds_scb *scb = sc->sc_scbhash[hashnum];
  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;
scb = scb->nexthash;
  649         }
  650         return scb;
  651 }
  653 /*
  654  * Queue a SCB to be sent to the controller, and send it if possible.
  655  */
  656 void
wds_queue_scb(sc, scb)
  658         struct wds_softc *sc;
  659         struct wds_scb *scb;
  660 {
TAILQ_INSERT_TAIL(&sc->sc_waiting_scb, scb, chain);
wds_start_scbs(sc);
  664 }
  666 /*
  667  * Garbage collect mailboxes that are no longer in use.
  668  */
  669 void
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
wmbo = wmbx->cmbo;
  680         while (sc->sc_mbofull > 0) {
  681                 if (wmbo->cmd != WDS_MBO_FREE)
  682                         break;
  684 #ifdef WDSDIAG
scb = wds_scb_phys_kv(sc, phystol(wmbo->scb_addr));
scb->flags &= ~SCB_SENDING;
  687 #endif
  689                 --sc->sc_mbofull;
wds_nextmbx(wmbo, wmbx, mbo);
  691         }
wmbx->cmbo = wmbo;
  694 }
  696 /*
  697  * Send as many SCBs as we have empty mailboxes for.
  698  */
  699 void
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;
u_char c;
wmbo = wmbx->tmbo;
  709         while ((scb = TAILQ_FIRST(&sc->sc_waiting_scb)) != NULL) {
  710                 if (sc->sc_mbofull >= WDS_MBX_SIZE) {
wds_collect_mbo(sc);
  712                         if (sc->sc_mbofull >= WDS_MBX_SIZE) {
c = WDSC_IRQMFREE;
wds_cmd(sc, &c, sizeof c);
  715                                 break;
  716                         }
  717                 }
TAILQ_REMOVE(&sc->sc_waiting_scb, scb, chain);
  720 #ifdef WDSDIAG
scb->flags |= SCB_SENDING;
  722 #endif
  724                 /* Link scb to mbo. */
  725 #ifdef notyet
isadma_copytobuf((caddr_t)scb, SCB_PHYS_SIZE,
  727                     1, scb->scb_phys);
ltophys(scb->scb_phys[0].addr, wmbo->scb_addr);
  729 #else
  730                 if (scb->flags & SCB_SENSE)
ltophys(KVTOPHYS(&scb->sense), wmbo->scb_addr);
  732                 else
ltophys(KVTOPHYS(&scb->cmd), wmbo->scb_addr);
  734 #endif
  735                 /* XXX What about aborts? */
wmbo->cmd = WDS_MBO_START;
  738                 /* Tell the card to poll immediately. */
c = WDSC_MSTART(wmbo - wmbx->mbo);
wds_cmd(sc, &c, sizeof c);
  742                 if ((scb->flags & SCB_POLLED) == 0) {
timeout_set(&scb->xs->stimeout, wds_timeout, scb);
timeout_add(&scb->xs->stimeout, (scb->timeout * hz) / 1000);
  745                 }
  747                 ++sc->sc_mbofull;
wds_nextmbx(wmbo, wmbx, mbo);
  749         }
wmbx->tmbo = wmbo;
  752 }
  754 /*
  755  * Process the result of a SCSI command.
  756  */
  757 void
wds_done(sc, scb, stat)
  759         struct wds_softc *sc;
  760         struct wds_scb *scb;
u_int8_t stat;
  762 {
  763         struct scsi_xfer *xs = scb->xs;
  765         /* XXXXX */
  767         /* Don't release the SCB if it was an internal command. */
  768         if (xs == 0) {
scb->flags |= SCB_DONE;
  770                 return;
  771         }
  773         /* Sense handling. */
  774         if (xs->error == XS_SENSE) {
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 */
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:
printf("%s: Is this an error?\n", sc->sc_dev.dv_xname);
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. */
wds_sense (sc, scb);
  797                                                         return;
  798                                                 } else if (scb->cmd.stat == SCSI_BUSY) {
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. */
xs->resid = 0;
  807                                                 break;
  808                                         default:
printf("%s: VENDOR ERROR %02x, scsi %02x\n", sc->sc_dev.dv_xname, scb->cmd.venderr, scb->cmd.stat);
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                                          */
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:
xs->error = XS_DRIVER_STUFFUP;
  831                                         break;
  832                                 }
  833                         }
  834                 } /* else sense */
  836                 if (NEEDBUFFER(sc) && xs->datalen) {
  837                         if (xs->flags & SCSI_DATA_IN)
bcopy(scb->buf->data, xs->data, xs->datalen);
  839                 }
  840         } /* XS_NOERROR */
  842 #ifdef notyet
  843         if (scb->data_nseg) {
  844                 if (xs->flags & SCSI_DATA_IN)
isadma_copyfrombuf(xs->data, xs->datalen,
scb->data_nseg, scb->data_phys);
isadma_unmap(xs->data, xs->datalen,
scb->data_nseg, scb->data_phys);
  849         }
  850 #endif
wds_free_scb(sc, scb);
xs->flags |= ITSDONE;
scsi_done(xs);
  854 }
  856 int
wds_find(ia, sc)
  858         struct isa_attach_args *ia;
  859         struct wds_softc *sc;
  860 {
bus_space_tag_t iot = ia->ia_iot;
bus_space_handle_t ioh;
u_char c;
  864         int i;
  866         /*
  867          * Sending a command causes the CMDRDY bit to clear.
  868          */
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;
delay(10);
  874         }
  875         return (0);
ready:
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);
bus_space_write_1(iot, ioh, WDS_HCR, WDSH_SCSIRESET|WDSH_ASCRESET);
delay(10000);
bus_space_write_1(iot, ioh, WDS_HCR, 0x00);
delay(500000);
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)
printf("%s: failed reset!!! %2x\n",
sc ? sc->sc_dev.dv_xname : "wds?",
bus_space_read_1(iot, ioh, WDS_IRQSTAT));
  893         if ((bus_space_read_1(iot, ioh, WDS_STAT) & (WDSS_RDY)) != WDSS_RDY) {
printf("%s: waiting for controller to become ready.",
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;
printf(".");
delay(10000);
  902                 }
  903                 if ((bus_space_read_1(iot, ioh, WDS_STAT) & (WDSS_RDY)) !=
WDSS_RDY) {
printf(" failed\n");
  906                         return (0);
  907                 }
printf("\n");
  909         }
  911         if (sc != NULL) {
  912                 /* XXX Can we do this better? */
  913                 /* who are we on the scsi bus? */
sc->sc_scsi_dev = 7;
sc->sc_iot = iot;
sc->sc_ioh = ioh;
sc->sc_irq = ia->ia_irq;
sc->sc_drq = ia->ia_drq;
  920         }
  922         return (1);
  923 }
  925 /*
  926  * Initialise the board and driver.
  927  */
  928 void
wds_init(sc)
  930         struct wds_softc *sc;
  931 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
  934         struct wds_setup init;
u_char c;
  936         int i;
  937 #ifdef notyet
  938         struct isadma_seg mbx_phys[1];
  939 #endif
  941         /*
  942          * Set up initial mail box for round-robin operation.
  943          */
  944         for (i = 0; i < WDS_MBX_SIZE; i++) {
wmbx->mbo[i].cmd = WDS_MBO_FREE;
wmbx->mbi[i].stat = WDS_MBI_FREE;
  947         }
wmbx->cmbo = wmbx->tmbo = &wmbx->mbo[0];
wmbx->tmbi = &wmbx->mbi[0];
sc->sc_mbofull = 0;
  952         /* Clear the buffers. */
TAILQ_INIT(&wds_free_buffer);
  954         for (i = 0; i < BUFCNT; i++) {
wds_buffer[i].busy = 0;
TAILQ_INSERT_HEAD(&wds_free_buffer, &wds_buffer[i], chain);
  957         }
init.opcode = WDSC_INIT;
init.scsi_id = sc->sc_scsi_dev;
  961         /* Record scsi id of controller for use in scsi_attach */
sc->sc_scsi_dev = init.scsi_id;
init.buson_t = 48;
init.busoff_t = 24;
init.xx = 0;
  966 #ifdef notyet
  967         if (isadma_map((caddr_t)(wmbx), sizeof(struct wds_mbx),
mbx_phys, ISADMA_MAP_CONTIG) != 1)
panic("wds_init: cannot map mail box");
ltophys(mbx_phys[0].addr, init.mbaddr);
  971 #else
ltophys(KVTOPHYS(wmbx), init.mbaddr);
  973 #endif
init.nomb = init.nimb = WDS_MBX_SIZE;
wds_cmd(sc, (u_char *)&init, sizeof init);
wds_wait(iot, ioh, WDS_STAT, WDSS_INIT, WDSS_INIT);
c = WDSC_DISUNSOL;
wds_cmd(sc, &c, sizeof c);
bus_space_write_1(iot, ioh, WDS_HCR, WDSH_DRQEN);
  983 }
  985 /*
  986  * Read the board's firmware revision information.
  987  */
  988 void
wds_inquire_setup_information(sc)
  990         struct wds_softc *sc;
  991 {
  992         struct wds_scb *scb;
u_char *j;
  994         int s;
  996         if ((scb = wds_get_scb(sc, SCSI_NOSLEEP, 0)) == NULL) {
printf("%s: no request slot available in getvers()!\n",
sc->sc_dev.dv_xname);
  999                 return;
 1000         }
scb->xs = NULL;
scb->timeout = 40;
bzero(&scb->cmd, sizeof scb->cmd);
scb->cmd.write = 0x80;
scb->cmd.opcode = WDSX_GETFIRMREV;
 1008         /* Will poll card, await result. */
bus_space_write_1(sc->sc_iot, sc->sc_ioh, WDS_HCR, WDSH_DRQEN);
scb->flags |= SCB_POLLED;
s = splbio();
wds_queue_scb(sc, scb);
splx(s);
 1016         if (wds_ipoll(sc, scb, scb->timeout))
 1017                 goto out;
 1019         /* Print the version number. */
printf(": version %x.%02x ", scb->cmd.targ, scb->cmd.scb.opcode);
sc->sc_revision = (scb->cmd.targ << 8) | scb->cmd.scb.opcode;
 1022         /* Print out the version string. */
j = 2 + &(scb->cmd.targ);
 1024         while ((*j >= 32) && (*j < 128)) {
printf("%c", *j);
j++;
 1027         }
out:
printf("\n");
wds_free_scb(sc, scb);
 1032 }
 1034 void
wdsminphys(bp)
 1036         struct buf *bp;
 1037 {
 1038         if (bp->b_bcount > ((WDS_NSEG - 1) << PGSHIFT))
bp->b_bcount = ((WDS_NSEG - 1) << PGSHIFT);
minphys(bp);
 1041 }
 1043 /*
 1044  * Send a SCSI command.
 1045  */
 1046 int
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;
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
 1054         struct wds_scb *scb;
 1055         struct wds_scat_gath *sg;
 1056         int seg;
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
 1067         if (xs->flags & SCSI_RESET) {
 1068                 /* XXX Fix me! */
printf("%s: reset!\n", sc->sc_dev.dv_xname);
wds_init(sc);
 1071                 return COMPLETE;
 1072         }
flags = xs->flags;
 1075 #ifdef notyet
 1076         if (flags & SCSI_NOSLEEP)
mflags = ISADMA_MAP_BOUNCE;
 1078         else
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         }
scb->xs = xs;
scb->timeout = xs->timeout;
 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! */
printf("%s: UIO is untested and disabled!\n", sc->sc_dev.dv_xname);
 1092                 goto bad;
 1093         }
 1095         /* Zero out the command structure. */
bzero(&scb->cmd, sizeof scb->cmd);
bcopy(xs->cmd, &scb->cmd.scb, xs->cmdlen < 12 ? xs->cmdlen : 12);
 1099         /* Set up some of the command fields. */
scb->cmd.targ = (xs->sc_link->target << 5) | xs->sc_link->lun;
 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          */
scb->cmd.write = (xs->flags & SCSI_DATA_IN) ? 0x80 : 0x00;
 1107         if (!NEEDBUFFER(sc) && xs->datalen) {
sg = scb->scat_gath;
seg = 0;
 1110 #ifdef TFS
 1111                 if (flags & SCSI_DATA_UIO) {
iovp = ((struct uio *)xs->data)->uio_iov;
datalen = ((struct uio *)xs->data)->uio_iovcnt;
xs->datalen = 0;
 1115                         while (datalen && seg < WDS_NSEG) {
ltophys(iovp->iov_base, sg->seg_addr);
ltophys(iovp->iov_len, sg->seg_len);
xs->datalen += iovp->iov_len;
SC_DEBUGN(sc_link, SDEV_DB4, ("UIO(0x%x@0x%x)",
iovp->iov_len, iovp->iov_base));
sg++;
iovp++;
seg++;
datalen--;
 1125                         }
 1126                 } else
 1127 #endif /* TFS */
 1128                 {
 1129                         /*
 1130                          * Set up the scatter-gather block.
 1131                          */
SC_DEBUG(sc_link, SDEV_DB4,
 1133                             ("%d @0x%x:- ", xs->datalen, xs->data));
 1135 #ifdef notyet
scb->data_nseg = isadma_map(xs->data, xs->datalen,
scb->data_phys, mflags);
 1138                         for (seg = 0; seg < scb->data_nseg; seg++) {
ltophys(scb->data_phys[seg].addr,
sg[seg].seg_addr);
ltophys(scb->data_phys[seg].length,
sg[seg].seg_len);
 1143                         }
 1144 #else
datalen = xs->datalen;
thiskv = (int)xs->data;
thisphys = KVTOPHYS(xs->data);
 1149                         while (datalen && seg < WDS_NSEG) {
bytes_this_seg = 0;
 1152                                 /* put in the base address */
ltophys(thisphys, sg->seg_addr);
SC_DEBUGN(sc_link, SDEV_DB4, ("0x%x", thisphys));
 1157                                 /* do it at least once */
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) {
printf("%s: DMA beyond"
 1168                                                         " end of ISA\n",
sc->sc_dev.dv_xname);
 1170                                                 goto bad;
 1171                                         }
 1172                                         /* how far to the end of the page */
nextphys = (thisphys & ~PGOFSET) + NBPG;
bytes_this_page = nextphys - thisphys;
 1175                                         /**** or the data ****/
bytes_this_page = min(bytes_this_page,
datalen);
bytes_this_seg += bytes_this_page;
datalen -= bytes_this_page;
 1181                                         /* get more ready for the next page */
thiskv = (thiskv & ~PGOFSET) + NBPG;
 1183                                         if (datalen)
thisphys = KVTOPHYS(thiskv);
 1185                                 }
 1186                                 /*
 1187                                  * next page isn't contiguous, finish the seg
 1188                                  */
SC_DEBUGN(sc_link, SDEV_DB4,
 1190                                     ("(0x%x)", bytes_this_seg));
ltophys(bytes_this_seg, sg->seg_len);
sg++;
seg++;
 1194 #endif
 1195                         }
 1196                 }
 1197                 /* end of iov/kv decision */
SC_DEBUGN(sc_link, SDEV_DB4, ("\n"));
 1199                 if (datalen) {
 1200                         /*
 1201                          * there's still data, must have run out of segs!
 1202                          */
printf("%s: wds_scsi_cmd, more than %d dma segs\n",
sc->sc_dev.dv_xname, WDS_NSEG);
 1205                         goto bad;
 1206                 }
 1207 #ifdef notyet
 1208                 if (scb->data_nseg == 0) {
printf("%s: wds_scsi_cmd, cannot map\n",
sc->sc_dev.dv_xname);
 1211                         goto bad;
 1212                 } else if (flags & SCSI_DATA_OUT)
isadma_copytobuf(xs->data, xs->datalen,
scb->data_nseg, scb->data_phys);
ltophys((unsigned)((struct wds_scb *)(scb->scb_phys[0].addr))->scat_gath,
scb->data_addr);
ltophys(scb->data_nseg * sizeof(struct wds_scat_gath),
scb->data_length);
 1219 #else
scb->cmd.opcode = WDSX_SCSISG;
ltophys(KVTOPHYS(scb->scat_gath), scb->cmd.data);
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) {
printf("%s: wds_scsi_cmd, I/O too large for bounce buffer\n",
sc->sc_dev.dv_xname);
 1229                         goto bad;
 1230                 }
 1231                 if (xs->flags & SCSI_DATA_OUT)
bcopy(xs->data, scb->buf->data, xs->datalen);
 1233                 else
bzero(scb->buf->data, xs->datalen);
scb->cmd.opcode = WDSX_SCSICMD;
ltophys(KVTOPHYS(scb->buf->data), scb->cmd.data);
ltophys(xs->datalen, scb->cmd.len);
 1238         } else {
scb->cmd.opcode = WDSX_SCSICMD;
ltophys(0, scb->cmd.data);
ltophys(0, scb->cmd.len);
 1242         }
scb->cmd.stat = 0x00;
scb->cmd.venderr = 0x00;
ltophys(0, scb->cmd.link);
 1248         /* XXX Do we really want to do this? */
 1249         if (flags & SCSI_POLL) {
 1250                 /* Will poll card, await result. */
bus_space_write_1(iot, ioh, WDS_HCR, WDSH_DRQEN);
scb->flags |= SCB_POLLED;
 1253         } else {
 1254                 /* Will send command, let interrupt routine handle result. */
bus_space_write_1(iot, ioh, WDS_HCR, WDSH_IRQEN | WDSH_DRQEN);
 1256         }
s = splbio();
wds_queue_scb(sc, scb);
 1261 #ifdef notyet
 1262         if (VOLATILE_XS(xs)) {
 1263                 while ((scb->xs->flags & ITSDONE) == 0) {
tsleep(scb, PRIBIO, "wdswait", 0);
 1265                 }
 1266                 if (scb->data_nseg) {
 1267                         if (flags & SCSI_DATA_IN)
isadma_copyfrombuf(xs->data, xs->datalen,
scb->data_nseg, scb->data_phys);
isadma_unmap(xs->data, xs->datalen,
scb->data_nseg, scb->data_phys);
 1272                 }
wds_free_scb(sc, scb);
scsi_done(xs);
splx(s);
 1276                 return COMPLETE;
 1277         }
 1278 #endif
splx(s);
 1281         if ((flags & SCSI_POLL) == 0)
 1282                 return SUCCESSFULLY_QUEUED;
 1284         if (wds_poll(sc, xs, scb->timeout)) {
wds_timeout(scb);
 1286                 if (wds_poll(sc, xs, scb->timeout))
wds_timeout(scb);
 1288         }
 1289         return COMPLETE;
bad:
xs->error = XS_DRIVER_STUFFUP;
wds_free_scb(sc, scb);
 1294         return COMPLETE;
 1295 }
 1297 /*
 1298  * Send a sense request.
 1299  */
 1300 void
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;
 1309         /* XXXXX */
 1311         /* Send sense request SCSI command. */
xs->error = XS_SENSE;
scb->flags |= SCB_SENSE;
 1315         /* First, save the return values */
 1316         if (NEEDBUFFER(sc) && xs->datalen) {
 1317                 if (xs->flags & SCSI_DATA_IN)
bcopy(scb->buf->data, xs->data, xs->datalen);
 1319         }
 1321         /* Next, setup a request sense command block */
bzero(ss, sizeof(*ss));
ss->opcode = REQUEST_SENSE;
ss->byte2 = xs->sc_link->lun << 5;
ss->length = sizeof(struct scsi_sense_data);
 1327         /* Set up some of the command fields. */
scb->sense.targ = scb->cmd.targ;
scb->sense.write = 0x80;
scb->sense.opcode = WDSX_SCSICMD;
ltophys(KVTOPHYS(&scb->sense_data), scb->sense.data);
ltophys(sizeof(struct scsi_sense_data), scb->sense.len);
s = splbio();
wds_queue_scb(sc, scb);
splx(s);
 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 }
 1347 /*
 1348  * Poll a particular unit, looking for a particular scb
 1349  */
 1350 int
wds_poll(sc, xs, count)
 1352         struct wds_softc *sc;
 1353         struct scsi_xfer *xs;
 1354         int count;
 1355 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
 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)
wdsintr(sc);
 1367                 if (xs->flags & ITSDONE)
 1368                         return 0;
delay(1000);    /* only happens in boot so ok */
count--;
 1371         }
 1372         return 1;
 1373 }
 1375 /*
 1376  * Poll a particular unit, looking for a particular scb
 1377  */
 1378 int
wds_ipoll(sc, scb, count)
 1380         struct wds_softc *sc;
 1381         struct wds_scb *scb;
 1382         int count;
 1383 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
 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)
wdsintr(sc);
 1395                 if (scb->flags & SCB_DONE)
 1396                         return 0;
delay(1000);    /* only happens in boot so ok */
count--;
 1399         }
 1400         return 1;
 1401 }
 1403 void
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;
s = splbio();
 1414 #ifdef notyet
isadma_copyfrombuf((caddr_t)scb, SCB_PHYS_SIZE, 1, scb->scb_phys);
 1416 #endif
xs = scb->xs;
sc_link = xs->sc_link;
sc = sc_link->adapter_softc;
sc_print_addr(sc_link);
printf("timed out");
 1424 #ifdef WDSDIAG
 1425         /*
 1426          * If The scb's mbx is not free, then the board has gone south?
 1427          */
wds_collect_mbo(sc);
 1429         if (scb->flags & SCB_SENDING) {
printf("%s: not taking commands!\n", sc->sc_dev.dv_xname);
Debugger();
 1432         }
 1433 #endif
 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 */
printf(" AGAIN\n");
 1443                 /* XXX Must reset! */
 1444         } else {
 1445                 /* abort the operation that has timed out */
printf("\n");
scb->xs->error = XS_TIMEOUT;
scb->timeout = WDS_ABORT_TIMEOUT;
scb->flags |= SCB_ABORT;
wds_queue_scb(sc, scb);
 1451         }
splx(s);
 1454 }