The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/nsp/nsp.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NecBSD: nsp.c,v 1.21.12.6 2001/06/29 06:27:52 honda Exp $      */
    2 /*      $NetBSD$        */
    3 
    4 #define NSP_DEBUG
    5 #define NSP_STATICS
    6 #define NSP_IO_CONTROL_FLAGS \
    7         (NSP_READ_SUSPEND_IO | NSP_WRITE_SUSPEND_IO | \
    8          NSP_READ_FIFO_INTERRUPTS | NSP_WRITE_FIFO_INTERRUPTS | \
    9          NSP_USE_MEMIO | NSP_WAIT_FOR_SELECT)
   10 
   11 /*-
   12  *  Copyright (c) 1998, 1999, 2000, 2001
   13  *      NetBSD/pc98 porting staff. All rights reserved.
   14  *
   15  *  Copyright (c) 1998, 1999, 2000, 2001
   16  *      Naofumi HONDA. All rights reserved.
   17  * 
   18  *  Redistribution and use in source and binary forms, with or without
   19  *  modification, are permitted provided that the following conditions
   20  *  are met:
   21  *  1. Redistributions of source code must retain the above copyright
   22  *     notice, this list of conditions and the following disclaimer.
   23  *  2. Redistributions in binary form must reproduce the above copyright
   24  *     notice, this list of conditions and the following disclaimer in the
   25  *     documentation and/or other materials provided with the distribution.
   26  *  3. The name of the author may not be used to endorse or promote products
   27  *     derived from this software without specific prior written permission.
   28  * 
   29  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   30  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   31  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   32  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   33  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   34  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   35  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   37  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   38  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   39  * POSSIBILITY OF SUCH DAMAGE.
   40  */
   41 
   42 #include <sys/cdefs.h>
   43 __FBSDID("$FreeBSD: releng/7.3/sys/dev/nsp/nsp.c 190087 2009-03-19 17:06:04Z rdivacky $");
   44 
   45 #include <sys/param.h>
   46 #include <sys/systm.h>
   47 #include <sys/kernel.h>
   48 #if defined(__FreeBSD__) && __FreeBSD_version > 500001
   49 #include <sys/bio.h>
   50 #endif  /* __ FreeBSD__ */
   51 #include <sys/buf.h>
   52 #include <sys/queue.h>
   53 #include <sys/malloc.h>
   54 #include <sys/errno.h>
   55 
   56 #ifdef __NetBSD__
   57 #include <sys/device.h>
   58 #include <machine/bus.h>
   59 #include <machine/intr.h>
   60 
   61 #include <dev/scsipi/scsi_all.h>
   62 #include <dev/scsipi/scsipi_all.h>
   63 #include <dev/scsipi/scsiconf.h>
   64 #include <dev/scsipi/scsi_disk.h>
   65 
   66 #include <machine/dvcfg.h>
   67 #include <machine/physio_proc.h>
   68 
   69 #include <i386/Cbus/dev/scsi_low.h>
   70 #include <i386/Cbus/dev/nspreg.h>
   71 #include <i386/Cbus/dev/nspvar.h>
   72 #endif /* __NetBSD__ */
   73 
   74 #ifdef __FreeBSD__
   75 #include <machine/cpu.h>
   76 #include <machine/bus.h>
   77 
   78 #include <compat/netbsd/dvcfg.h>
   79 #include <compat/netbsd/physio_proc.h>
   80 
   81 #include <cam/scsi/scsi_low.h>
   82 #include <dev/nsp/nspreg.h>
   83 #include <dev/nsp/nspvar.h>
   84 #endif /* __FreeBSD__ */
   85 
   86 /***************************************************
   87  * USER SETTINGS
   88  ***************************************************/
   89 /* DEVICE CONFIGURATION FLAGS (MINOR)
   90  *
   91  * 0x01   DISCONECT OFF
   92  * 0x02   PARITY LINE OFF
   93  * 0x04   IDENTIFY MSG OFF ( = single lun)
   94  * 0x08   SYNC TRANSFER OFF
   95  */
   96 
   97 /***************************************************
   98  * PARAMS
   99  ***************************************************/
  100 #define NSP_NTARGETS    8
  101 #define NSP_NLUNS       8
  102 
  103 #define NSP_MAX_DATA_SIZE       (64 * 1024)
  104 #define NSP_SELTIMEOUT          (200)
  105 #define NSP_DELAY_MAX           (2 * 1000 * 1000)
  106 #define NSP_DELAY_INTERVAL      (1)
  107 #define NSP_TIMER_1MS           (1000 / 51)
  108 
  109 /***************************************************
  110  * DEBUG
  111  ***************************************************/
  112 #ifdef  NSP_DEBUG
  113 int nsp_debug;
  114 #endif  /* NSP_DEBUG */
  115 
  116 #ifdef  NSP_STATICS
  117 struct nsp_statics {
  118         int arbit_conflict_1;
  119         int arbit_conflict_2;
  120         int device_data_write;
  121         int device_busy;
  122         int disconnect;
  123         int reselect;
  124         int data_phase_bypass;
  125 } nsp_statics;
  126 #endif  /* NSP_STATICS */
  127 
  128 /***************************************************
  129  * IO control
  130  ***************************************************/
  131 #define NSP_READ_SUSPEND_IO             0x0001
  132 #define NSP_WRITE_SUSPEND_IO            0x0002
  133 #define NSP_USE_MEMIO                   0x0004
  134 #define NSP_READ_FIFO_INTERRUPTS        0x0010
  135 #define NSP_WRITE_FIFO_INTERRUPTS       0x0020
  136 #define NSP_WAIT_FOR_SELECT             0x0100
  137 
  138 u_int nsp_io_control = NSP_IO_CONTROL_FLAGS;
  139 int nsp_read_suspend_bytes = DEV_BSIZE;
  140 int nsp_write_suspend_bytes = DEV_BSIZE;
  141 int nsp_read_interrupt_bytes = 4096;
  142 int nsp_write_interrupt_bytes = 4096;
  143 
  144 /***************************************************
  145  * DEVICE STRUCTURE
  146  ***************************************************/
  147 extern struct cfdriver nsp_cd;
  148 
  149 /**************************************************************
  150  * DECLARE
  151  **************************************************************/
  152 #define NSP_FIFO_ON     1
  153 #define NSP_FIFO_OFF    0
  154 static void nsp_pio_read(struct nsp_softc *, int);
  155 static void nsp_pio_write(struct nsp_softc *, int);
  156 static int nsp_xfer(struct nsp_softc *, u_int8_t *, int, int, int);
  157 static int nsp_msg(struct nsp_softc *, struct targ_info *, u_int);
  158 static int nsp_reselected(struct nsp_softc *);
  159 static int nsp_disconnected(struct nsp_softc *, struct targ_info *);
  160 static void nsp_pdma_end(struct nsp_softc *, struct targ_info *);
  161 static void nsphw_init(struct nsp_softc *);
  162 static int nsp_target_nexus_establish(struct nsp_softc *);
  163 static int nsp_lun_nexus_establish(struct nsp_softc *);
  164 static int nsp_ccb_nexus_establish(struct nsp_softc *);
  165 static int nsp_world_start(struct nsp_softc *, int);
  166 static int nsphw_start_selection(struct nsp_softc *sc, struct slccb *);
  167 static void nsphw_bus_reset(struct nsp_softc *);
  168 static void nsphw_attention(struct nsp_softc *);
  169 static u_int nsp_fifo_count(struct nsp_softc *);
  170 static u_int nsp_request_count(struct nsp_softc *);
  171 static int nsp_negate_signal(struct nsp_softc *, u_int8_t, u_char *);
  172 static int nsp_expect_signal(struct nsp_softc *, u_int8_t, u_int8_t);
  173 static void nsp_start_timer(struct nsp_softc *, int);
  174 static void nsp_setup_fifo(struct nsp_softc *, int, int, int);
  175 static int nsp_targ_init(struct nsp_softc *, struct targ_info *, int);
  176 static void nsphw_selection_done_and_expect_msgout(struct nsp_softc *);
  177 static void nsp_data_padding(struct nsp_softc *, int, u_int);
  178 static int nsp_timeout(struct nsp_softc *);
  179 static int nsp_read_fifo(struct nsp_softc *, int);
  180 static int nsp_write_fifo(struct nsp_softc *, int);
  181 static int nsp_phase_match(struct nsp_softc *, u_int8_t, u_int8_t);
  182 static int nsp_wait_interrupt(struct nsp_softc *);
  183 
  184 struct scsi_low_funcs nspfuncs = {
  185         SC_LOW_INIT_T nsp_world_start,
  186         SC_LOW_BUSRST_T nsphw_bus_reset,
  187         SC_LOW_TARG_INIT_T nsp_targ_init,
  188         SC_LOW_LUN_INIT_T NULL,
  189 
  190         SC_LOW_SELECT_T nsphw_start_selection,
  191         SC_LOW_NEXUS_T nsp_lun_nexus_establish,
  192         SC_LOW_NEXUS_T nsp_ccb_nexus_establish,
  193 
  194         SC_LOW_ATTEN_T nsphw_attention,
  195         SC_LOW_MSG_T nsp_msg,
  196 
  197         SC_LOW_TIMEOUT_T nsp_timeout,
  198         SC_LOW_POLL_T nspintr,
  199 
  200         NULL,
  201 };
  202 
  203 /****************************************************
  204  * hwfuncs
  205  ****************************************************/
  206 static __inline u_int8_t nsp_cr_read_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs);
  207 static __inline void nsp_cr_write_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs, u_int8_t va);
  208 
  209 static __inline u_int8_t
  210 nsp_cr_read_1(bst, bsh, ofs)
  211         bus_space_tag_t bst;
  212         bus_space_handle_t bsh;
  213         bus_addr_t ofs;
  214 {
  215         
  216         bus_space_write_1(bst, bsh, nsp_idxr, ofs);
  217         return bus_space_read_1(bst, bsh, nsp_datar);
  218 }
  219 
  220 static __inline void 
  221 nsp_cr_write_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs,
  222     u_int8_t va)
  223 {
  224 
  225         bus_space_write_1(bst, bsh, nsp_idxr, ofs);
  226         bus_space_write_1(bst, bsh, nsp_datar, va);
  227 }
  228         
  229 static int
  230 nsp_expect_signal(struct nsp_softc *sc, u_int8_t curphase, u_int8_t mask)
  231 {
  232         struct scsi_low_softc *slp = &sc->sc_sclow;
  233         bus_space_tag_t bst = sc->sc_iot;
  234         bus_space_handle_t bsh = sc->sc_ioh;
  235         int wc;
  236         u_int8_t ph, isrc;
  237 
  238         for (wc = 0; wc < NSP_DELAY_MAX / NSP_DELAY_INTERVAL; wc ++)
  239         {
  240                 ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
  241                 if (ph == (u_int8_t) -1)
  242                         return -1;
  243 
  244                 isrc = bus_space_read_1(bst, bsh, nsp_irqsr);
  245                 if (isrc & IRQSR_SCSI)
  246                         return 0;
  247 
  248                 if ((ph & mask) != 0 && (ph & SCBUSMON_PHMASK) == curphase)
  249                         return 1;
  250 
  251                 SCSI_LOW_DELAY(NSP_DELAY_INTERVAL);
  252         }
  253 
  254         printf("%s: nsp_expect_signal timeout\n", slp->sl_xname);
  255         return -1;
  256 }
  257 
  258 static void
  259 nsphw_init(sc)
  260         struct nsp_softc *sc;
  261 {
  262         bus_space_tag_t bst = sc->sc_iot;
  263         bus_space_handle_t bsh = sc->sc_ioh;
  264 
  265         /* block all interrupts */
  266         bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_ALLMASK);
  267 
  268         /* setup SCSI interface */
  269         bus_space_write_1(bst, bsh, nsp_ifselr, IFSELR_IFSEL);
  270 
  271         nsp_cr_write_1(bst, bsh, NSPR_SCIENR, 0);
  272 
  273         nsp_cr_write_1(bst, bsh, NSPR_XFERMR, XFERMR_IO8);
  274         nsp_cr_write_1(bst, bsh, NSPR_CLKDIVR, sc->sc_iclkdiv);
  275 
  276         nsp_cr_write_1(bst, bsh, NSPR_SCIENR, sc->sc_icr);
  277         nsp_cr_write_1(bst, bsh, NSPR_PARITYR, sc->sc_parr);
  278         nsp_cr_write_1(bst, bsh, NSPR_PTCLRR,
  279                        PTCLRR_ACK | PTCLRR_REQ | PTCLRR_HOST | PTCLRR_RSS);
  280 
  281         /* setup fifo asic */
  282         bus_space_write_1(bst, bsh, nsp_ifselr, IFSELR_REGSEL);
  283         nsp_cr_write_1(bst, bsh, NSPR_TERMPWRC, 0);
  284         if ((nsp_cr_read_1(bst, bsh, NSPR_OCR) & OCR_TERMPWRS) == 0)
  285                 nsp_cr_write_1(bst, bsh, NSPR_TERMPWRC, TERMPWRC_POWON);
  286 
  287         nsp_cr_write_1(bst, bsh, NSPR_XFERMR, XFERMR_IO8);
  288         nsp_cr_write_1(bst, bsh, NSPR_CLKDIVR, sc->sc_clkdiv);
  289         nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0);
  290         nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0);
  291 
  292         nsp_cr_write_1(bst, bsh, NSPR_SYNCR, 0);
  293         nsp_cr_write_1(bst, bsh, NSPR_ACKWIDTH, 0);
  294 
  295         /* enable interrupts and ack them */
  296         nsp_cr_write_1(bst, bsh, NSPR_SCIENR, sc->sc_icr);
  297         bus_space_write_1(bst, bsh, nsp_irqcr, IRQSR_MASK);
  298 
  299         nsp_setup_fifo(sc, NSP_FIFO_OFF, SCSI_LOW_READ, 0);
  300 }
  301 
  302 /****************************************************
  303  * scsi low interface
  304  ****************************************************/
  305 static void
  306 nsphw_attention(sc)
  307         struct nsp_softc *sc;
  308 {
  309         bus_space_tag_t bst = sc->sc_iot;
  310         bus_space_handle_t bsh = sc->sc_ioh;
  311         u_int8_t cr;
  312 
  313         cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR)/*  & ~SCBUSCR_ACK */;
  314         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr | SCBUSCR_ATN);
  315         SCSI_LOW_DELAY(10);
  316 }
  317 
  318 static void
  319 nsphw_bus_reset(sc)
  320         struct nsp_softc *sc;
  321 {
  322         bus_space_tag_t bst = sc->sc_iot;
  323         bus_space_handle_t bsh = sc->sc_ioh;
  324         int i;
  325 
  326         bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_ALLMASK);
  327 
  328         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, SCBUSCR_RST);
  329         SCSI_LOW_DELAY(100 * 1000);     /* 100ms */
  330         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 0);
  331         for (i = 0; i < 5; i ++)
  332                 (void) nsp_cr_read_1(bst, bsh, NSPR_IRQPHS);
  333 
  334         bus_space_write_1(bst, bsh, nsp_irqcr, IRQSR_MASK);
  335 }
  336 
  337 static void
  338 nsphw_selection_done_and_expect_msgout(sc)
  339         struct nsp_softc *sc;
  340 {
  341         struct scsi_low_softc *slp = &sc->sc_sclow;
  342         bus_space_tag_t bst = sc->sc_iot;
  343         bus_space_handle_t bsh = sc->sc_ioh;
  344 
  345         /* clear ack counter */
  346         sc->sc_cnt = 0;
  347         nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_PT | PTCLRR_ACK |
  348                         PTCLRR_REQ | PTCLRR_HOST);
  349 
  350         /* deassert sel and assert atten */
  351         sc->sc_seltout = 0;
  352         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, sc->sc_busc);
  353         SCSI_LOW_DELAY(1);
  354         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 
  355                         sc->sc_busc | SCBUSCR_ADIR | SCBUSCR_ACKEN);
  356         SCSI_LOW_ASSERT_ATN(slp);
  357 }
  358 
  359 static int
  360 nsphw_start_selection(sc, cb)
  361         struct nsp_softc *sc;
  362         struct slccb *cb;
  363 {
  364         struct scsi_low_softc *slp = &sc->sc_sclow;
  365         bus_space_tag_t bst = sc->sc_iot;
  366         bus_space_handle_t bsh = sc->sc_ioh;
  367         struct targ_info *ti = cb->ti;
  368         register u_int8_t arbs, ph;
  369         int s, wc;
  370 
  371         wc = sc->sc_tmaxcnt = cb->ccb_tcmax * 1000 * 1000;
  372         sc->sc_dataout_timeout = 0;
  373 
  374         /* check bus free */
  375         s = splhigh();
  376         ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
  377         if (ph != SCBUSMON_FREE)
  378         {
  379                 splx(s);
  380 #ifdef  NSP_STATICS
  381                 nsp_statics.arbit_conflict_1 ++;
  382 #endif  /* NSP_STATICS */
  383                 return SCSI_LOW_START_FAIL;
  384         }
  385 
  386         /* start arbitration */
  387         nsp_cr_write_1(bst, bsh, NSPR_ARBITS, ARBITS_EXEC);
  388         splx(s);
  389 
  390         SCSI_LOW_SETUP_PHASE(ti, PH_ARBSTART);
  391         do 
  392         {
  393                 /* XXX: what a stupid chip! */
  394                 arbs = nsp_cr_read_1(bst, bsh, NSPR_ARBITS);
  395                 SCSI_LOW_DELAY(1);
  396         } 
  397         while ((arbs & (ARBITS_WIN | ARBITS_FAIL)) == 0 && wc -- > 0);
  398 
  399         if ((arbs & ARBITS_WIN) == 0)
  400         {
  401                 nsp_cr_write_1(bst, bsh, NSPR_ARBITS, ARBITS_CLR);
  402 #ifdef  NSP_STATICS
  403                 nsp_statics.arbit_conflict_2 ++;
  404 #endif  /* NSP_STATICS */
  405                 return SCSI_LOW_START_FAIL;
  406         }
  407 
  408         /* assert select line */
  409         SCSI_LOW_SETUP_PHASE(ti, PH_SELSTART);
  410         scsi_low_arbit_win(slp);
  411 
  412         s = splhigh();
  413         SCSI_LOW_DELAY(3);
  414         nsp_cr_write_1(bst, bsh, NSPR_DATA,
  415                        sc->sc_idbit | (1 << ti->ti_id));
  416         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR,
  417                         SCBUSCR_SEL | SCBUSCR_BSY | sc->sc_busc);
  418         SCSI_LOW_DELAY(3);
  419         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, SCBUSCR_SEL |
  420                         SCBUSCR_BSY | SCBUSCR_DOUT | sc->sc_busc);
  421         nsp_cr_write_1(bst, bsh, NSPR_ARBITS, ARBITS_CLR);
  422         SCSI_LOW_DELAY(3);
  423         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR,
  424                        SCBUSCR_SEL | SCBUSCR_DOUT | sc->sc_busc);
  425         SCSI_LOW_DELAY(1);
  426 
  427         if ((nsp_io_control & NSP_WAIT_FOR_SELECT) != 0)
  428         {
  429 #define NSP_FIRST_SEL_WAIT      300
  430 #define NSP_SEL_CHECK_INTERVAL  10
  431 
  432                 /* wait for a selection response */
  433                 for (wc = 0; wc < NSP_FIRST_SEL_WAIT / NSP_SEL_CHECK_INTERVAL;
  434                      wc ++)
  435                 {
  436                         ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
  437                         if ((ph & SCBUSMON_BSY) == 0)
  438                         {
  439                                 SCSI_LOW_DELAY(NSP_SEL_CHECK_INTERVAL);
  440                                 continue;
  441                         }
  442 
  443                         SCSI_LOW_DELAY(1);
  444                         ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
  445                         if ((ph & SCBUSMON_BSY) != 0)
  446                         {
  447                                 nsphw_selection_done_and_expect_msgout(sc);
  448                                 splx(s);
  449 
  450                                 SCSI_LOW_SETUP_PHASE(ti, PH_SELECTED);
  451                                 return SCSI_LOW_START_OK;
  452                         }
  453                 }
  454         }
  455         splx(s);
  456 
  457         /* check a selection timeout */
  458         nsp_start_timer(sc, NSP_TIMER_1MS);
  459         sc->sc_seltout = 1;
  460         return SCSI_LOW_START_OK;
  461 }
  462 
  463 static int
  464 nsp_world_start(sc, fdone)
  465         struct nsp_softc *sc;
  466         int fdone;
  467 {
  468         struct scsi_low_softc *slp = &sc->sc_sclow;
  469 
  470         sc->sc_cnt = 0;
  471         sc->sc_seltout = 0;
  472 
  473         if ((slp->sl_cfgflags & CFG_NOATTEN) == 0)
  474                 sc->sc_busc = SCBUSCR_ATN;
  475         else
  476                 sc->sc_busc = 0;
  477 
  478         if ((slp->sl_cfgflags & CFG_NOPARITY) == 0)
  479                 sc->sc_parr = PARITYR_ENABLE | PARITYR_CLEAR;
  480         else
  481                 sc->sc_parr = 0;
  482 
  483         sc->sc_icr = (SCIENR_SCCHG | SCIENR_RESEL | SCIENR_RST);
  484 
  485         nsphw_init(sc);
  486         scsi_low_bus_reset(slp);
  487 
  488         SOFT_INTR_REQUIRED(slp);
  489         return 0;
  490 }
  491 
  492 struct ncp_synch_data {
  493         u_int min_period;
  494         u_int max_period;
  495         u_int chip_period;
  496         u_int ack_width;
  497 };
  498 
  499 static struct ncp_synch_data ncp_sync_data_40M[] = {
  500         {0x0c,0x0c,0x1,0},      /* 20MB  50ns*/
  501         {0x19,0x19,0x3,1},      /* 10MB  100ns*/ 
  502         {0x1a,0x25,0x5,2},      /* 7.5MB 150ns*/ 
  503         {0x26,0x32,0x7,3},      /* 5MB   200ns*/
  504         {0x0, 0, 0, 0}
  505 };
  506 
  507 static struct ncp_synch_data ncp_sync_data_20M[] = {
  508         {0x19,0x19,0x1,0},      /* 10MB  100ns*/ 
  509         {0x1a,0x25,0x2,0},      /* 7.5MB 150ns*/ 
  510         {0x26,0x32,0x3,1},      /* 5MB   200ns*/
  511         {0x0, 0, 0, 0}
  512 };
  513 
  514 static int
  515 nsp_msg(sc, ti, msg)
  516         struct nsp_softc *sc;
  517         struct targ_info *ti;
  518         u_int msg;
  519 {
  520         bus_space_tag_t bst = sc->sc_iot;
  521         bus_space_handle_t bsh = sc->sc_ioh;
  522         struct ncp_synch_data *sdp;
  523         struct nsp_targ_info *nti = (void *) ti;
  524         u_int period, offset;
  525         int i, error;
  526 
  527         if ((msg & SCSI_LOW_MSG_WIDE) != 0)
  528         {
  529                 if (ti->ti_width != SCSI_LOW_BUS_WIDTH_8)
  530                 {
  531                         ti->ti_width = SCSI_LOW_BUS_WIDTH_8;
  532                         return EINVAL;
  533                 }
  534                 return 0;
  535         }
  536 
  537         if ((msg & SCSI_LOW_MSG_SYNCH) == 0)
  538                 return 0;
  539 
  540         period = ti->ti_maxsynch.period;
  541         offset = ti->ti_maxsynch.offset;
  542         if (sc->sc_iclkdiv == CLKDIVR_20M)
  543                 sdp = &ncp_sync_data_20M[0];
  544         else
  545                 sdp = &ncp_sync_data_40M[0];
  546 
  547         for (i = 0; sdp->max_period != 0; i ++, sdp ++)
  548         {
  549                 if (period >= sdp->min_period && period <= sdp->max_period)
  550                         break;
  551         }
  552 
  553         if (period != 0 && sdp->max_period == 0)
  554         {
  555                 /*
  556                  * NO proper period/offset found,
  557                  * Retry neg with the target.
  558                  */
  559                 ti->ti_maxsynch.period = 0;
  560                 ti->ti_maxsynch.offset = 0;
  561                 nti->nti_reg_syncr = 0;
  562                 nti->nti_reg_ackwidth = 0;
  563                 error = EINVAL;
  564         }
  565         else
  566         {
  567                 nti->nti_reg_syncr = (sdp->chip_period << SYNCR_PERS) |
  568                                       (offset & SYNCR_OFFM);
  569                 nti->nti_reg_ackwidth = sdp->ack_width;
  570                 error = 0;
  571         }
  572 
  573         nsp_cr_write_1(bst, bsh, NSPR_SYNCR, nti->nti_reg_syncr);
  574         nsp_cr_write_1(bst, bsh, NSPR_ACKWIDTH, nti->nti_reg_ackwidth);
  575         return error;
  576 }
  577 
  578 static int
  579 nsp_targ_init(sc, ti, action)
  580         struct nsp_softc *sc;
  581         struct targ_info *ti;
  582         int action;
  583 {
  584         struct nsp_targ_info *nti = (void *) ti;
  585 
  586         if (action == SCSI_LOW_INFO_ALLOC || action == SCSI_LOW_INFO_REVOKE)
  587         {
  588                 ti->ti_width = SCSI_LOW_BUS_WIDTH_8;
  589                 ti->ti_maxsynch.period = 100 / 4;
  590                 ti->ti_maxsynch.offset = 15;
  591                 nti->nti_reg_syncr = 0;
  592                 nti->nti_reg_ackwidth = 0;
  593         }
  594         return 0;
  595 }       
  596 
  597 static void
  598 nsp_start_timer(sc, time)
  599         struct nsp_softc *sc;
  600         int time;
  601 {
  602         bus_space_tag_t bst = sc->sc_iot;
  603         bus_space_handle_t bsh = sc->sc_ioh;
  604 
  605         sc->sc_timer = time;
  606         nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, time);
  607 }
  608 
  609 /**************************************************************
  610  * General probe attach
  611  **************************************************************/
  612 int
  613 nspprobesubr(iot, ioh, dvcfg)
  614         bus_space_tag_t iot;
  615         bus_space_handle_t ioh;
  616         u_int dvcfg;
  617 {
  618         u_int8_t regv;
  619 
  620         regv = bus_space_read_1(iot, ioh, nsp_fifosr);
  621         if (regv < 0x11 || regv >= 0x20)
  622                 return 0;
  623         return 1;
  624 }
  625 
  626 int
  627 nspprint(aux, name)
  628         void *aux;
  629         const char *name;
  630 {
  631 
  632         if (name != NULL)
  633                 printf("%s: scsibus ", name);
  634         return UNCONF;
  635 }
  636 
  637 void
  638 nspattachsubr(sc)
  639         struct nsp_softc *sc;
  640 {
  641         struct scsi_low_softc *slp = &sc->sc_sclow;
  642 
  643         printf("\n");
  644 
  645         sc->sc_idbit = (1 << slp->sl_hostid);
  646         slp->sl_flags |= HW_READ_PADDING;
  647         slp->sl_funcs = &nspfuncs;
  648         sc->sc_tmaxcnt = SCSI_LOW_MIN_TOUT * 1000 * 1000; /* default */
  649 
  650         (void) scsi_low_attach(slp, 0, NSP_NTARGETS, NSP_NLUNS,
  651                                sizeof(struct nsp_targ_info), 0);
  652 }
  653 
  654 /**************************************************************
  655  * PDMA functions
  656  **************************************************************/
  657 static u_int
  658 nsp_fifo_count(sc)
  659         struct nsp_softc *sc;
  660 {
  661         bus_space_tag_t bst = sc->sc_iot;
  662         bus_space_handle_t bsh = sc->sc_ioh;
  663         u_int count;
  664 
  665         nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_RSS_ACK | PTCLRR_PT);
  666         count = bus_space_read_1(bst, bsh, nsp_datar);
  667         count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 8);
  668         count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 16);
  669         return count;
  670 }
  671 
  672 static u_int
  673 nsp_request_count(sc)
  674         struct nsp_softc *sc;
  675 {
  676         bus_space_tag_t bst = sc->sc_iot;
  677         bus_space_handle_t bsh = sc->sc_ioh;
  678         u_int count;
  679 
  680         nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_RSS_REQ | PTCLRR_PT);
  681         count = bus_space_read_1(bst, bsh, nsp_datar);
  682         count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 8);
  683         count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 16);
  684         return count;
  685 }
  686 
  687 static void
  688 nsp_setup_fifo(sc, on, direction, datalen)
  689         struct nsp_softc *sc;
  690         int on;
  691         int direction;
  692         int datalen;
  693 {
  694         u_int8_t xfermode;
  695 
  696         sc->sc_suspendio = 0;
  697         if (on == NSP_FIFO_OFF)
  698         {
  699                 xfermode = XFERMR_IO8;
  700                 goto out;
  701         }
  702 
  703         /* check if suspend io OK ? */
  704         if (datalen > 0)
  705         {
  706                 if (direction == SCSI_LOW_READ)
  707                 {
  708                         if ((nsp_io_control & NSP_READ_SUSPEND_IO) != 0 &&
  709                             (datalen % nsp_read_suspend_bytes) == 0)
  710                                 sc->sc_suspendio = nsp_read_suspend_bytes;
  711                 }
  712                 else
  713                 {
  714                         if ((nsp_io_control & NSP_WRITE_SUSPEND_IO) != 0 &&
  715                             (datalen % nsp_write_suspend_bytes) == 0)
  716                                 sc->sc_suspendio = nsp_write_suspend_bytes;
  717                 }
  718         }
  719 
  720         /* determine a transfer type */
  721         if (datalen < DEV_BSIZE || (datalen & 3) != 0)
  722         {
  723                 if (sc->sc_memh != 0 &&
  724                     (nsp_io_control & NSP_USE_MEMIO) != 0)
  725                         xfermode = XFERMR_XEN | XFERMR_MEM8;
  726                 else
  727                         xfermode = XFERMR_XEN | XFERMR_IO8;
  728         }
  729         else
  730         {
  731                 if (sc->sc_memh != 0 &&
  732                     (nsp_io_control & NSP_USE_MEMIO) != 0)
  733                         xfermode = XFERMR_XEN | XFERMR_MEM32;
  734                 else
  735                         xfermode = XFERMR_XEN | XFERMR_IO32;
  736 
  737                 if (sc->sc_suspendio > 0)
  738                         xfermode |= XFERMR_FIFOEN;
  739         }
  740 
  741 out:
  742         sc->sc_xfermr = xfermode;
  743         nsp_cr_write_1(sc->sc_iot, sc->sc_ioh, NSPR_XFERMR, sc->sc_xfermr);
  744 }
  745 
  746 static void
  747 nsp_pdma_end(sc, ti)
  748         struct nsp_softc *sc;
  749         struct targ_info *ti;
  750 {
  751         struct scsi_low_softc *slp = &sc->sc_sclow;
  752         struct slccb *cb = slp->sl_Qnexus;
  753         u_int len = 0, cnt;
  754 
  755         sc->sc_dataout_timeout = 0;
  756         slp->sl_flags &= ~HW_PDMASTART;
  757         nsp_setup_fifo(sc, NSP_FIFO_OFF, SCSI_LOW_READ, 0);
  758         if ((sc->sc_icr & SCIENR_FIFO) != 0)
  759         {
  760                 sc->sc_icr &= ~SCIENR_FIFO;
  761                 nsp_cr_write_1(sc->sc_iot, sc->sc_ioh, NSPR_SCIENR, sc->sc_icr);
  762         }
  763 
  764         if (cb == NULL)
  765         {
  766                 slp->sl_error |= PDMAERR;
  767                 return;
  768         }
  769 
  770         if (ti->ti_phase == PH_DATA)
  771         {
  772                 cnt = nsp_fifo_count(sc);
  773                 if (slp->sl_scp.scp_direction  == SCSI_LOW_WRITE)
  774                 {
  775                         len = sc->sc_cnt - cnt;
  776                         if (sc->sc_cnt >= cnt &&
  777                             slp->sl_scp.scp_datalen + len <= 
  778                             cb->ccb_scp.scp_datalen)
  779                         {
  780                                 slp->sl_scp.scp_data -= len;
  781                                 slp->sl_scp.scp_datalen += len;
  782                         }
  783                         else
  784                         {
  785                                 slp->sl_error |= PDMAERR;
  786                                 printf("%s len %x >= datalen %x\n",
  787                                         slp->sl_xname,
  788                                         len, slp->sl_scp.scp_datalen);
  789                         }
  790                 }
  791                 else if (slp->sl_scp.scp_direction == SCSI_LOW_READ)
  792                 {
  793                         if (sc->sc_cnt != cnt ||
  794                             sc->sc_cnt > cb->ccb_scp.scp_datalen)
  795                         {
  796                                 slp->sl_error |= PDMAERR;
  797                                 printf("%s: data read count error %x != %x (%x)\n",
  798                                         slp->sl_xname, sc->sc_cnt, cnt,
  799                                         cb->ccb_scp.scp_datalen);
  800                         }
  801                 }
  802                 sc->sc_cnt = cnt;
  803                 scsi_low_data_finish(slp);
  804         }
  805         else
  806         {
  807 
  808                 printf("%s data phase miss\n", slp->sl_xname);
  809                 slp->sl_error |= PDMAERR;
  810         }
  811 }
  812 
  813 #define RFIFO_CRIT      64
  814 #define WFIFO_CRIT      32
  815 
  816 static void
  817 nsp_data_padding(sc, direction, count)
  818         struct nsp_softc *sc;
  819         int direction;
  820         u_int count;
  821 {
  822         bus_space_tag_t bst = sc->sc_iot;
  823         bus_space_handle_t bsh = sc->sc_ioh;
  824 
  825         if (count > NSP_MAX_DATA_SIZE)
  826                 count = NSP_MAX_DATA_SIZE;
  827 
  828         nsp_cr_write_1(bst, bsh, NSPR_XFERMR, XFERMR_XEN | XFERMR_IO8);
  829         if (direction == SCSI_LOW_READ)
  830         {
  831                 while (count -- > 0)
  832                         (void) bus_space_read_1(bst, bsh, nsp_fifodr);
  833         }
  834         else
  835         {
  836                 while (count -- > 0)
  837                         (void) bus_space_write_1(bst, bsh, nsp_fifodr, 0);
  838         }
  839         nsp_cr_write_1(bst, bsh, NSPR_XFERMR, sc->sc_xfermr);
  840 }
  841 
  842 static int
  843 nsp_read_fifo(sc, suspendio)
  844         struct nsp_softc *sc;
  845         int suspendio;
  846 {
  847         struct scsi_low_softc *slp = &sc->sc_sclow;
  848         bus_space_tag_t bst = sc->sc_iot;
  849         bus_space_handle_t bsh = sc->sc_ioh;
  850         u_int res;
  851 
  852         res = nsp_fifo_count(sc);
  853         if (res == sc->sc_cnt)
  854                 return 0;
  855 
  856 #ifdef  NSP_DEBUG
  857         if (res < sc->sc_cnt || res == (u_int) -1)
  858         {
  859                 printf("%s: strange fifo ack count 0x%x < 0x%x\n", 
  860                         slp->sl_xname, res, sc->sc_cnt);
  861                 return 0;
  862         }
  863 #endif  /* NSP_DEBUG */
  864 
  865         res = res - sc->sc_cnt;
  866         if (res > slp->sl_scp.scp_datalen)
  867         {
  868                 if ((slp->sl_error & PDMAERR) == 0)
  869                 {
  870                         printf("%s: data overrun 0x%x > 0x%x\n",
  871                                 slp->sl_xname, res, slp->sl_scp.scp_datalen);
  872                 }
  873 
  874                 slp->sl_error |= PDMAERR;
  875                 slp->sl_scp.scp_datalen = 0;
  876 
  877                 if ((slp->sl_flags & HW_READ_PADDING) == 0)
  878                 {
  879                         printf("%s: read padding required\n", slp->sl_xname);
  880                         return 0;
  881                 }
  882 
  883                 nsp_data_padding(sc, SCSI_LOW_READ, res);
  884                 sc->sc_cnt += res;
  885                 return 1;       /* padding start */
  886         }
  887 
  888         if (suspendio > 0 && slp->sl_scp.scp_datalen >= suspendio)
  889                 res = suspendio;
  890 
  891         if ((sc->sc_xfermr & (XFERMR_MEM32 | XFERMR_MEM8)) != 0)
  892         {
  893                 if ((sc->sc_xfermr & XFERMR_MEM32) != 0)
  894                 {
  895                         res &= ~3;
  896                         bus_space_read_region_4(sc->sc_memt, sc->sc_memh, 0, 
  897                                 (u_int32_t *) slp->sl_scp.scp_data, res >> 2);
  898                 }
  899                 else
  900                 {
  901                         bus_space_read_region_1(sc->sc_memt, sc->sc_memh, 0, 
  902                                 (u_int8_t *) slp->sl_scp.scp_data, res);
  903                 }
  904         }
  905         else
  906         {
  907                 if ((sc->sc_xfermr & XFERMR_IO32) != 0)
  908                 {
  909                         res &= ~3;
  910                         bus_space_read_multi_4(bst, bsh, nsp_fifodr,
  911                                 (u_int32_t *) slp->sl_scp.scp_data, res >> 2);
  912                 }
  913                 else 
  914                 {
  915                         bus_space_read_multi_1(bst, bsh, nsp_fifodr,
  916                                 (u_int8_t *) slp->sl_scp.scp_data, res);
  917                 }
  918         }
  919 
  920         if (nsp_cr_read_1(bst, bsh, NSPR_PARITYR) & PARITYR_PE)
  921         {
  922                 nsp_cr_write_1(bst, bsh, NSPR_PARITYR, 
  923                                PARITYR_ENABLE | PARITYR_CLEAR);
  924                 scsi_low_assert_msg(slp, slp->sl_Tnexus, SCSI_LOW_MSG_ERROR, 1);
  925         }
  926 
  927         slp->sl_scp.scp_data += res;
  928         slp->sl_scp.scp_datalen -= res;
  929         sc->sc_cnt += res;
  930         return 0;
  931 }
  932 
  933 static int
  934 nsp_write_fifo(sc, suspendio)
  935         struct nsp_softc *sc;
  936         int suspendio;
  937 {
  938         struct scsi_low_softc *slp = &sc->sc_sclow;
  939         bus_space_tag_t bst = sc->sc_iot;
  940         bus_space_handle_t bsh = sc->sc_ioh;
  941         u_int res;
  942         register u_int8_t stat;
  943 
  944         if (suspendio > 0)
  945         {
  946 #ifdef  NSP_DEBUG
  947                 if ((slp->sl_scp.scp_datalen % WFIFO_CRIT) != 0)
  948                 {
  949                         printf("%s: strange write length 0x%x\n",
  950                                 slp->sl_xname, slp->sl_scp.scp_datalen);
  951                 }
  952 #endif  /* NSP_DEBUG */
  953                 res = slp->sl_scp.scp_datalen % suspendio;
  954                 if (res == 0)
  955                 {
  956                         res = suspendio;
  957                 }
  958         }
  959         else
  960         {
  961                 res = WFIFO_CRIT;
  962         }
  963 
  964         if (res > slp->sl_scp.scp_datalen)
  965                 res = slp->sl_scp.scp_datalen;
  966 
  967         /* XXX: reconfirm! */
  968         stat = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON) & SCBUSMON_PHMASK;
  969         if (stat != PHASE_DATAOUT)
  970                 return 0;
  971 
  972         if ((sc->sc_xfermr & (XFERMR_MEM32 | XFERMR_MEM8)) != 0)
  973         {
  974                 if ((sc->sc_xfermr & XFERMR_MEM32) != 0)
  975                 {
  976                         bus_space_write_region_4(sc->sc_memt, sc->sc_memh, 0,
  977                                 (u_int32_t *) slp->sl_scp.scp_data, res >> 2);
  978                 }
  979                 else
  980                 {
  981                         bus_space_write_region_1(sc->sc_memt, sc->sc_memh, 0,
  982                                 (u_int8_t *) slp->sl_scp.scp_data, res);
  983                 }
  984         }
  985         else
  986         {
  987                 if ((sc->sc_xfermr & XFERMR_IO32) != 0)
  988                 {
  989                         bus_space_write_multi_4(bst, bsh, nsp_fifodr,
  990                                 (u_int32_t *) slp->sl_scp.scp_data, res >> 2);
  991                 }
  992                 else
  993                 {
  994                         bus_space_write_multi_1(bst, bsh, nsp_fifodr,
  995                                 (u_int8_t *) slp->sl_scp.scp_data, res);
  996                 }
  997         }
  998 
  999         slp->sl_scp.scp_datalen -= res;
 1000         slp->sl_scp.scp_data += res;
 1001         sc->sc_cnt += res;
 1002         return 0;
 1003 }
 1004 
 1005 static int
 1006 nsp_wait_interrupt(sc)
 1007         struct nsp_softc *sc;
 1008 {
 1009         bus_space_tag_t bst = sc->sc_iot;
 1010         bus_space_handle_t bsh = sc->sc_ioh;
 1011         int tout;
 1012         register u_int8_t isrc;
 1013 
 1014         for (tout = 0; tout < DEV_BSIZE / 10; tout ++)
 1015         {
 1016                 isrc = bus_space_read_1(bst, bsh, nsp_irqsr);
 1017                 if ((isrc & (IRQSR_SCSI | IRQSR_FIFO)) != 0)
 1018                 {
 1019                         if ((isrc & IRQSR_FIFO) != 0)
 1020                         {
 1021                                 bus_space_write_1(bst, bsh,
 1022                                         nsp_irqcr, IRQCR_FIFOCL);
 1023                         }
 1024                         return 1;
 1025                 }
 1026                 SCSI_LOW_DELAY(1);
 1027         }
 1028         return 0;
 1029 }
 1030 
 1031 static void
 1032 nsp_pio_read(sc, suspendio)
 1033         struct nsp_softc *sc;
 1034         int suspendio;
 1035 {
 1036         struct scsi_low_softc *slp = &sc->sc_sclow;
 1037         bus_space_tag_t bst = sc->sc_iot;
 1038         bus_space_handle_t bsh = sc->sc_ioh;
 1039         int tout, padding, datalen;
 1040         register u_int8_t stat, fstat;
 1041 
 1042         padding = 0;
 1043         tout = sc->sc_tmaxcnt;
 1044         slp->sl_flags |= HW_PDMASTART;
 1045         datalen = slp->sl_scp.scp_datalen;
 1046 
 1047 ReadLoop:
 1048         while (1)
 1049         {
 1050                 stat = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
 1051                 if (stat == (u_int8_t) -1)
 1052                         return;
 1053 
 1054                 /* out of data phase */
 1055                 if ((stat & SCBUSMON_PHMASK) != PHASE_DATAIN)
 1056                 {
 1057                         nsp_read_fifo(sc, 0);
 1058                         return;
 1059                 }
 1060 
 1061                 /* data phase */
 1062                 fstat = bus_space_read_1(bst, bsh, nsp_fifosr);
 1063                 if ((fstat & FIFOSR_FULLEMP) != 0)
 1064                 {
 1065                         if ((sc->sc_icr & SCIENR_FIFO) != 0)
 1066                         {
 1067                                 bus_space_write_1(bst, bsh, nsp_irqcr, 
 1068                                                   IRQCR_FIFOCL);
 1069                         }
 1070 
 1071                         if (suspendio > 0)
 1072                         {
 1073                                 padding |= nsp_read_fifo(sc, suspendio);
 1074                         }
 1075                         else
 1076                         {
 1077                                 padding |= nsp_read_fifo(sc, 0);
 1078                         }
 1079 
 1080                         if ((sc->sc_icr & SCIENR_FIFO) != 0)
 1081                                 break;
 1082                 }
 1083                 else
 1084                 {
 1085                         if (padding == 0 && slp->sl_scp.scp_datalen <= 0)
 1086                                 return;
 1087 
 1088                         if ((sc->sc_icr & SCIENR_FIFO) != 0)
 1089                                 break;
 1090 
 1091                         SCSI_LOW_DELAY(1);
 1092                 }
 1093 
 1094                 if ((-- tout) <= 0)
 1095                 {
 1096                         printf("%s: nsp_pio_read: timeout\n", slp->sl_xname);
 1097                         return;
 1098                 }
 1099         }
 1100 
 1101 
 1102         if (slp->sl_scp.scp_datalen > 0 &&
 1103             slp->sl_scp.scp_datalen > datalen - nsp_read_interrupt_bytes)
 1104         {
 1105                 if (nsp_wait_interrupt(sc) != 0)
 1106                         goto ReadLoop;
 1107         }
 1108 }
 1109 
 1110 static void
 1111 nsp_pio_write(sc, suspendio)
 1112         struct nsp_softc *sc;
 1113         int suspendio;
 1114 {
 1115         struct scsi_low_softc *slp = &sc->sc_sclow;
 1116         bus_space_tag_t bst = sc->sc_iot;
 1117         bus_space_handle_t bsh = sc->sc_ioh;
 1118         u_int rcount, acount;
 1119         int tout, datalen;
 1120         register u_int8_t stat, fstat;
 1121 
 1122         tout = sc->sc_tmaxcnt;
 1123         slp->sl_flags |= HW_PDMASTART;
 1124         datalen = slp->sl_scp.scp_datalen;
 1125 
 1126 WriteLoop:
 1127         while (1)
 1128         {
 1129                 stat = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON) & SCBUSMON_PHMASK;
 1130                 if (stat != PHASE_DATAOUT)
 1131                         return;
 1132 
 1133                 if (slp->sl_scp.scp_datalen <= 0)
 1134                 {
 1135                         if (sc->sc_dataout_timeout == 0)
 1136                                 sc->sc_dataout_timeout = SCSI_LOW_TIMEOUT_HZ;
 1137                         return;
 1138                 }
 1139 
 1140                 fstat = bus_space_read_1(bst, bsh, nsp_fifosr);
 1141                 if ((fstat & FIFOSR_FULLEMP) != 0)
 1142                 {
 1143                         if ((sc->sc_icr & SCIENR_FIFO) != 0)
 1144                         {
 1145                                 bus_space_write_1(bst, bsh, nsp_irqcr,
 1146                                                   IRQCR_FIFOCL);
 1147                         }
 1148 
 1149                         if (suspendio > 0)
 1150                         {
 1151                                 /* XXX:IMPORTANT:
 1152                                  * To avoid timeout of pcmcia bus
 1153                                  * (not scsi bus!), we should check
 1154                                  * the scsi device sends us request
 1155                                  * signals, which means the scsi device
 1156                                  * is ready to recieve data without
 1157                                  * heavy delays. 
 1158                                  */
 1159                                 if ((slp->sl_scp.scp_datalen % suspendio) == 0)
 1160                                 {
 1161                                         /* Step I:
 1162                                          * fill the nsp fifo, and waiting for
 1163                                          * the fifo empty.
 1164                                          */
 1165                                         nsp_write_fifo(sc, 0);
 1166                                 }
 1167                                 else
 1168                                 {
 1169                                         /* Step II:
 1170                                          * check the request singals.
 1171                                          */
 1172                                         acount = nsp_fifo_count(sc);
 1173                                         rcount = nsp_request_count(sc);
 1174                                         if (rcount <= acount)
 1175                                         {
 1176                                                 nsp_write_fifo(sc, 0);
 1177 #ifdef  NSP_STATICS
 1178                                                 nsp_statics.device_busy ++;
 1179 #endif  /* NSP_STATICS */
 1180                                         }
 1181                                         else
 1182                                         {
 1183                                                 nsp_write_fifo(sc, suspendio);
 1184 #ifdef  NSP_STATICS
 1185                                                 nsp_statics.device_data_write ++;
 1186 #endif  /* NSP_STATICS */
 1187                                         }
 1188                                 }
 1189                         }
 1190                         else
 1191                         {
 1192                                 nsp_write_fifo(sc, 0);
 1193                         }
 1194 
 1195                         if ((sc->sc_icr & SCIENR_FIFO) != 0)
 1196                                 break;
 1197                 }
 1198                 else
 1199                 {
 1200                         if ((sc->sc_icr & SCIENR_FIFO) != 0)
 1201                                 break;
 1202 
 1203                         SCSI_LOW_DELAY(1);
 1204                 }
 1205 
 1206                 if ((-- tout) <= 0)
 1207                 {
 1208                         printf("%s: nsp_pio_write: timeout\n", slp->sl_xname);
 1209                         return;
 1210                 }
 1211         }
 1212 
 1213         if (slp->sl_scp.scp_datalen > 0 &&
 1214             slp->sl_scp.scp_datalen > datalen - nsp_write_interrupt_bytes)
 1215         {
 1216                 if (nsp_wait_interrupt(sc) != 0)
 1217                         goto WriteLoop;
 1218         }
 1219 }
 1220 
 1221 static int
 1222 nsp_negate_signal(struct nsp_softc *sc, u_int8_t mask, u_char *s)
 1223 {
 1224         struct scsi_low_softc *slp = &sc->sc_sclow;
 1225         bus_space_tag_t bst = sc->sc_iot;
 1226         bus_space_handle_t bsh = sc->sc_ioh;
 1227         int wc;
 1228         u_int8_t regv;
 1229 
 1230         for (wc = 0; wc < NSP_DELAY_MAX / NSP_DELAY_INTERVAL; wc ++)
 1231         {
 1232                 regv = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
 1233                 if (regv == (u_int8_t) -1)
 1234                         return -1;
 1235                 if ((regv & mask) == 0)
 1236                         return 1;
 1237                 SCSI_LOW_DELAY(NSP_DELAY_INTERVAL);
 1238         }
 1239 
 1240         printf("%s: %s nsp_negate_signal timeout\n", slp->sl_xname, s);
 1241         return -1;
 1242 }
 1243 
 1244 static int
 1245 nsp_xfer(sc, buf, len, phase, clear_atn)
 1246         struct nsp_softc *sc;
 1247         u_int8_t *buf;
 1248         int len;
 1249         int phase;
 1250         int clear_atn;
 1251 {
 1252         bus_space_tag_t bst = sc->sc_iot;
 1253         bus_space_handle_t bsh = sc->sc_ioh;
 1254         int ptr, rv;
 1255 
 1256         for (ptr = 0; len > 0; len --, ptr ++)
 1257         {
 1258                 rv = nsp_expect_signal(sc, phase, SCBUSMON_REQ);
 1259                 if (rv <= 0)
 1260                         goto out;
 1261 
 1262                 if (len == 1 && clear_atn != 0)
 1263                 {
 1264                         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR,
 1265                                        SCBUSCR_ADIR | SCBUSCR_ACKEN);
 1266                         SCSI_LOW_DEASSERT_ATN(&sc->sc_sclow);
 1267                 }
 1268 
 1269                 if (phase & SCBUSMON_IO)
 1270                 {
 1271                         buf[ptr] = nsp_cr_read_1(bst, bsh, NSPR_DATAACK);
 1272                 }
 1273                 else
 1274                 {
 1275                         nsp_cr_write_1(bst, bsh, NSPR_DATAACK, buf[ptr]);
 1276                 }
 1277                 nsp_negate_signal(sc, SCBUSMON_ACK, "xfer<ACK>");
 1278         }
 1279 
 1280 out:
 1281         return len;
 1282 }
 1283 
 1284 /**************************************************************
 1285  * disconnect & reselect (HW low)
 1286  **************************************************************/
 1287 static int
 1288 nsp_reselected(sc)
 1289         struct nsp_softc *sc;
 1290 {
 1291         struct scsi_low_softc *slp = &sc->sc_sclow;
 1292         bus_space_tag_t bst = sc->sc_iot;
 1293         bus_space_handle_t bsh = sc->sc_ioh;
 1294         struct targ_info *ti;
 1295         u_int sid;
 1296         u_int8_t cr;
 1297 
 1298         sid = (u_int) nsp_cr_read_1(bst, bsh, NSPR_RESELR);
 1299         sid &= ~sc->sc_idbit;
 1300         sid = ffs(sid) - 1;
 1301         if ((ti = scsi_low_reselected(slp, sid)) == NULL)
 1302                 return EJUSTRETURN;
 1303 
 1304         nsp_negate_signal(sc, SCBUSMON_SEL, "reselect<SEL>");
 1305 
 1306         cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR);
 1307         cr &= ~(SCBUSCR_BSY | SCBUSCR_ATN);
 1308         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
 1309         cr |= SCBUSCR_ADIR | SCBUSCR_ACKEN;
 1310         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
 1311 
 1312 #ifdef  NSP_STATICS
 1313         nsp_statics.reselect ++;
 1314 #endif  /* NSP_STATCIS */
 1315         return EJUSTRETURN;
 1316 }
 1317 
 1318 static int
 1319 nsp_disconnected(sc, ti)
 1320         struct nsp_softc *sc;
 1321         struct targ_info *ti;
 1322 {
 1323         struct scsi_low_softc *slp = &sc->sc_sclow;
 1324         bus_space_tag_t bst = sc->sc_iot;
 1325         bus_space_handle_t bsh = sc->sc_ioh;
 1326 
 1327         nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_PT | PTCLRR_ACK |
 1328                         PTCLRR_REQ | PTCLRR_HOST);
 1329         if ((sc->sc_icr & SCIENR_FIFO) != 0)
 1330         {
 1331                 sc->sc_icr &= ~SCIENR_FIFO;
 1332                 nsp_cr_write_1(bst, bsh, NSPR_SCIENR, sc->sc_icr);
 1333         }
 1334         sc->sc_cnt = 0;
 1335         sc->sc_dataout_timeout = 0;
 1336 #ifdef  NSP_STATICS
 1337         nsp_statics.disconnect ++;
 1338 #endif  /* NSP_STATICS */
 1339         scsi_low_disconnected(slp, ti);
 1340         return 1;
 1341 }
 1342 
 1343 /**************************************************************
 1344  * SEQUENCER
 1345  **************************************************************/
 1346 static void nsp_error(struct nsp_softc *, u_char *, u_int8_t, u_int8_t, u_int8_t);
 1347 
 1348 static void
 1349 nsp_error(struct nsp_softc * sc, u_char *s, u_int8_t isrc, u_int8_t ph,
 1350     u_int8_t irqphs)
 1351 {
 1352         struct scsi_low_softc *slp = &sc->sc_sclow;
 1353 
 1354         printf("%s: %s\n", slp->sl_xname, s);
 1355         printf("%s: isrc 0x%x scmon 0x%x irqphs 0x%x\n",
 1356                slp->sl_xname, (u_int) isrc, (u_int) ph, (u_int) irqphs);
 1357 }
 1358 
 1359 static int
 1360 nsp_target_nexus_establish(sc)
 1361         struct nsp_softc *sc;
 1362 {
 1363         struct scsi_low_softc *slp = &sc->sc_sclow;
 1364         bus_space_tag_t bst = sc->sc_iot;
 1365         bus_space_handle_t bsh = sc->sc_ioh;
 1366         struct targ_info *ti = slp->sl_Tnexus;
 1367         struct nsp_targ_info *nti = (void *) ti;
 1368 
 1369         /* setup synch transfer registers */
 1370         nsp_cr_write_1(bst, bsh, NSPR_SYNCR, nti->nti_reg_syncr);
 1371         nsp_cr_write_1(bst, bsh, NSPR_ACKWIDTH, nti->nti_reg_ackwidth);
 1372 
 1373         /* setup pdma fifo (minimum) */
 1374         nsp_setup_fifo(sc, NSP_FIFO_ON, SCSI_LOW_READ, 0);
 1375         return 0;
 1376 }
 1377 
 1378 static int
 1379 nsp_lun_nexus_establish(sc)
 1380         struct nsp_softc *sc;
 1381 {
 1382 
 1383         return 0;
 1384 }
 1385 
 1386 static int
 1387 nsp_ccb_nexus_establish(sc)
 1388         struct nsp_softc *sc;
 1389 {
 1390         struct scsi_low_softc *slp = &sc->sc_sclow;
 1391         struct slccb *cb = slp->sl_Qnexus;
 1392 
 1393         sc->sc_tmaxcnt = cb->ccb_tcmax * 1000 * 1000;
 1394 
 1395         /* setup pdma fifo */
 1396         nsp_setup_fifo(sc, NSP_FIFO_ON, 
 1397                        slp->sl_scp.scp_direction, slp->sl_scp.scp_datalen);
 1398 
 1399         if (slp->sl_scp.scp_direction == SCSI_LOW_READ)
 1400         {
 1401                 if (sc->sc_suspendio > 0 &&
 1402                     (nsp_io_control & NSP_READ_FIFO_INTERRUPTS) != 0)
 1403                 {
 1404                         sc->sc_icr |= SCIENR_FIFO;
 1405                         nsp_cr_write_1(sc->sc_iot, sc->sc_ioh,
 1406                                        NSPR_SCIENR, sc->sc_icr);
 1407                 }
 1408         }
 1409         else 
 1410         {
 1411                 if (sc->sc_suspendio > 0 &&
 1412                     (nsp_io_control & NSP_WRITE_FIFO_INTERRUPTS) != 0)
 1413                 {
 1414                         sc->sc_icr |= SCIENR_FIFO;
 1415                         nsp_cr_write_1(sc->sc_iot, sc->sc_ioh,
 1416                                        NSPR_SCIENR, sc->sc_icr);
 1417                 }
 1418         }
 1419         return 0;
 1420 }
 1421 
 1422 static int
 1423 nsp_phase_match(struct nsp_softc *sc, u_int8_t phase, u_int8_t stat)
 1424 {
 1425         struct scsi_low_softc *slp = &sc->sc_sclow;
 1426 
 1427         if ((stat & SCBUSMON_PHMASK) != phase)
 1428         {
 1429                 printf("%s: phase mismatch 0x%x != 0x%x\n",
 1430                         slp->sl_xname, (u_int) phase, (u_int) stat);
 1431                 return EINVAL;
 1432         }
 1433 
 1434         if ((stat & SCBUSMON_REQ) == 0)
 1435                 return EINVAL;
 1436 
 1437         return 0;
 1438 }
 1439 
 1440 int
 1441 nspintr(arg)
 1442         void *arg;
 1443 {
 1444         struct nsp_softc *sc = arg;
 1445         struct scsi_low_softc *slp = &sc->sc_sclow;
 1446         bus_space_tag_t bst = sc->sc_iot;
 1447         bus_space_handle_t bsh = sc->sc_ioh;
 1448         struct targ_info *ti;
 1449         struct physio_proc *pp;
 1450         struct buf *bp;
 1451         u_int derror, flags;
 1452         int len, rv;
 1453         u_int8_t isrc, ph, irqphs, cr, regv;
 1454 
 1455         /*******************************************
 1456          * interrupt check
 1457          *******************************************/
 1458         if (slp->sl_flags & HW_INACTIVE)
 1459                 return 0;
 1460 
 1461         bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_IRQDIS);
 1462         isrc = bus_space_read_1(bst, bsh, nsp_irqsr);
 1463         if (isrc == (u_int8_t) -1 || (isrc & IRQSR_MASK) == 0)
 1464         {
 1465                 bus_space_write_1(bst, bsh, nsp_irqcr, 0);
 1466                 return 0;
 1467         }
 1468 
 1469         /* XXX: IMPORTANT
 1470          * Do not read an irqphs register if no scsi phase interrupt.
 1471          * Unless, you should lose a scsi phase interrupt.
 1472          */
 1473         ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
 1474         if ((isrc & IRQSR_SCSI) != 0)
 1475         {
 1476                 irqphs = nsp_cr_read_1(bst, bsh, NSPR_IRQPHS);
 1477         }
 1478         else
 1479                 irqphs = 0;
 1480 
 1481         /*
 1482          * timer interrupt handler (scsi vs timer interrupts)
 1483          */
 1484         if (sc->sc_timer != 0)
 1485         {
 1486                 nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0);
 1487                 nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0);
 1488                 sc->sc_timer = 0;
 1489         }
 1490         
 1491         /* check a timer interrupt */
 1492         regv = 0;
 1493         if ((isrc & IRQSR_TIMER) != 0)
 1494         {
 1495                 if ((isrc & IRQSR_MASK) == IRQSR_TIMER && sc->sc_seltout == 0)
 1496                 {
 1497                         bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_TIMERCL);
 1498                         return 1;
 1499                 }
 1500                 regv |= IRQCR_TIMERCL;
 1501         }
 1502 
 1503         /* check a fifo interrupt */
 1504         if ((isrc & IRQSR_FIFO) != 0)
 1505         {
 1506                 regv |= IRQCR_FIFOCL;
 1507         }
 1508 
 1509         /* OK. enable all interrupts */
 1510         bus_space_write_1(bst, bsh, nsp_irqcr, regv);
 1511 
 1512         /*******************************************
 1513          * debug section
 1514          *******************************************/
 1515 #ifdef  NSP_DEBUG
 1516         if (nsp_debug)
 1517         {
 1518                 nsp_error(sc, "current status", isrc, ph, irqphs);
 1519                 scsi_low_print(slp, NULL);
 1520 #ifdef  KDB
 1521                 if (nsp_debug > 1)
 1522                         SCSI_LOW_DEBUGGER("nsp");
 1523 #endif  /* KDB */
 1524         }
 1525 #endif  /* NSP_DEBUG */
 1526 
 1527         /*******************************************
 1528          * Parse hardware SCSI irq reasons register
 1529          *******************************************/
 1530         if ((isrc & IRQSR_SCSI) != 0)
 1531         {
 1532                 if ((irqphs & IRQPHS_RST) != 0)
 1533                 {
 1534                         scsi_low_restart(slp, SCSI_LOW_RESTART_SOFT, 
 1535                                          "bus reset (power off?)");
 1536                         return 1;
 1537                 }
 1538 
 1539                 if ((irqphs & IRQPHS_RSEL) != 0)
 1540                 {
 1541                         bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_RESCL);
 1542                         if (nsp_reselected(sc) == EJUSTRETURN)
 1543                                 return 1;
 1544                 }
 1545 
 1546                 if ((irqphs & (IRQPHS_PCHG | IRQPHS_LBF)) == 0)
 1547                         return 1; 
 1548         }
 1549 
 1550         /*******************************************
 1551          * nexus check
 1552          *******************************************/
 1553         if ((ti = slp->sl_Tnexus) == NULL)
 1554         {
 1555                 /* unknown scsi phase changes */
 1556                 nsp_error(sc, "unknown scsi phase changes", isrc, ph, irqphs);
 1557                 return 0;
 1558         }
 1559 
 1560         /*******************************************
 1561          * aribitration & selection
 1562          *******************************************/
 1563         switch (ti->ti_phase)
 1564         {
 1565         case PH_SELSTART:
 1566                 if ((ph & SCBUSMON_BSY) == 0)
 1567                 {
 1568                         if (sc->sc_seltout >= NSP_SELTIMEOUT)
 1569                         {
 1570                                 sc->sc_seltout = 0;
 1571                                 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 0);
 1572                                 return nsp_disconnected(sc, ti);
 1573                         }
 1574                         sc->sc_seltout ++;
 1575                         nsp_start_timer(sc, NSP_TIMER_1MS);
 1576                         return 1;
 1577                 }
 1578 
 1579                 SCSI_LOW_SETUP_PHASE(ti, PH_SELECTED);
 1580                 nsphw_selection_done_and_expect_msgout(sc);
 1581                 return 1;
 1582 
 1583         case PH_SELECTED:
 1584                 if ((isrc & IRQSR_SCSI) == 0)
 1585                         return 1;
 1586 
 1587                 nsp_target_nexus_establish(sc);
 1588                 break;
 1589 
 1590         case PH_RESEL:
 1591                 if ((isrc & IRQSR_SCSI) == 0)
 1592                         return 1;
 1593 
 1594                 nsp_target_nexus_establish(sc);
 1595                 if ((ph & SCBUSMON_PHMASK) != PHASE_MSGIN)
 1596                 {
 1597                         printf("%s: unexpected phase after reselect\n",
 1598                                slp->sl_xname);
 1599                         slp->sl_error |= FATALIO;
 1600                         scsi_low_assert_msg(slp, ti, SCSI_LOW_MSG_ABORT, 1);
 1601                         return 1;
 1602                 }
 1603                 break;
 1604 
 1605         case PH_DATA:
 1606                 if ((isrc & IRQSR_SCSI) != 0)
 1607                         break;
 1608                 if ((isrc & IRQSR_FIFO) != 0)
 1609                 {
 1610                         if (NSP_IS_PHASE_DATA(ph) == 0)
 1611                                 return 1;
 1612                         irqphs = (ph & IRQPHS_PHMASK);
 1613                         break;
 1614                 }
 1615                 return 1;
 1616 
 1617         default:
 1618                 if ((isrc & IRQSR_SCSI) == 0)
 1619                         return 1;
 1620                 break;
 1621         }
 1622 
 1623         /*******************************************
 1624          * data phase control 
 1625          *******************************************/
 1626         if (slp->sl_flags & HW_PDMASTART)
 1627         {
 1628                 if ((isrc & IRQSR_SCSI) != 0 &&
 1629                      NSP_IS_IRQPHS_DATA(irqphs) == 0)
 1630                 {
 1631                         if (slp->sl_scp.scp_direction == SCSI_LOW_READ)
 1632                                 nsp_pio_read(sc, 0);
 1633                         nsp_pdma_end(sc, ti);
 1634                 }
 1635         }
 1636 
 1637         /*******************************************
 1638          * scsi seq
 1639          *******************************************/
 1640         if (slp->sl_msgphase != 0 && (irqphs & IRQPHS_LBF) != 0)
 1641                 return nsp_disconnected(sc, ti);
 1642 
 1643         /* check unexpected bus free state */
 1644         if (ph == 0)
 1645         {
 1646                 nsp_error(sc, "unexpected bus free", isrc, ph, irqphs);
 1647                 return nsp_disconnected(sc, ti);
 1648         }
 1649                 
 1650         /* check normal scsi phase */
 1651         switch (irqphs & IRQPHS_PHMASK)
 1652         {
 1653         case IRQPHS_CMD:
 1654                 if (nsp_phase_match(sc, PHASE_CMD, ph) != 0)
 1655                         return 1;
 1656 
 1657                 SCSI_LOW_SETUP_PHASE(ti, PH_CMD);
 1658                 if (scsi_low_cmd(slp, ti) != 0)
 1659                 {
 1660                         scsi_low_attention(slp);
 1661                 }
 1662 
 1663                 nsp_cr_write_1(bst, bsh, NSPR_CMDCR, CMDCR_PTCLR);
 1664                 for (len = 0; len < slp->sl_scp.scp_cmdlen; len ++)
 1665                         nsp_cr_write_1(bst, bsh, NSPR_CMDDR,
 1666                                        slp->sl_scp.scp_cmd[len]);
 1667 
 1668                 nsp_cr_write_1(bst, bsh, NSPR_CMDCR, CMDCR_PTCLR | CMDCR_EXEC);
 1669                 break;
 1670 
 1671         case IRQPHS_DATAOUT:
 1672                 SCSI_LOW_SETUP_PHASE(ti, PH_DATA);
 1673                 if (scsi_low_data(slp, ti, &bp, SCSI_LOW_WRITE) != 0)
 1674                 {
 1675                         scsi_low_attention(slp);
 1676                 }
 1677         
 1678                 pp = physio_proc_enter(bp);
 1679                 nsp_pio_write(sc, sc->sc_suspendio);
 1680                 physio_proc_leave(pp);
 1681                 break;
 1682 
 1683         case IRQPHS_DATAIN:
 1684                 SCSI_LOW_SETUP_PHASE(ti, PH_DATA);
 1685                 if (scsi_low_data(slp, ti, &bp, SCSI_LOW_READ) != 0)
 1686                 {
 1687                         scsi_low_attention(slp);
 1688                 }
 1689 
 1690                 pp = physio_proc_enter(bp);
 1691                 nsp_pio_read(sc, sc->sc_suspendio);
 1692                 physio_proc_leave(pp);
 1693                 break;
 1694 
 1695         case IRQPHS_STATUS:
 1696                 if (nsp_phase_match(sc, PHASE_STATUS, ph) != 0)
 1697                         return 1;
 1698 
 1699                 SCSI_LOW_SETUP_PHASE(ti, PH_STAT);
 1700                 regv = nsp_cr_read_1(bst, bsh, NSPR_DATA);
 1701                 if (nsp_cr_read_1(bst, bsh, NSPR_PARITYR) & PARITYR_PE)
 1702                 {
 1703                         nsp_cr_write_1(bst, bsh, NSPR_PARITYR, 
 1704                                        PARITYR_ENABLE | PARITYR_CLEAR);
 1705                         derror = SCSI_LOW_DATA_PE;
 1706                 }
 1707                 else
 1708                         derror = 0;
 1709 
 1710                 /* assert ACK */
 1711                 cr = SCBUSCR_ACK | nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR);
 1712                 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
 1713 
 1714                 if (scsi_low_statusin(slp, ti, derror | regv) != 0)
 1715                 {
 1716                         scsi_low_attention(slp);
 1717                 }
 1718 
 1719                 /* check REQ nagated */
 1720                 nsp_negate_signal(sc, SCBUSMON_REQ, "statin<REQ>");
 1721 
 1722                 /* deassert ACK */
 1723                 cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR) & (~SCBUSCR_ACK);
 1724                 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
 1725                 break;
 1726 
 1727         case IRQPHS_MSGOUT:
 1728                 if (nsp_phase_match(sc, PHASE_MSGOUT, ph) != 0)
 1729                         return 1;
 1730 
 1731 #ifdef  NSP_MSGOUT_SERIALIZE
 1732                 /*
 1733                  * XXX: NSP QUIRK
 1734                  * NSP invoke interrupts only in the case of scsi phase changes,
 1735                  * therefore we should poll the scsi phase here to catch 
 1736                  * the next "msg out" if exists (no scsi phase changes).
 1737                  */
 1738                 rv = len = 16;
 1739                 do {
 1740                         SCSI_LOW_SETUP_PHASE(ti, PH_MSGOUT);
 1741                         flags = (ti->ti_ophase != ti->ti_phase) ? 
 1742                                         SCSI_LOW_MSGOUT_INIT : 0;
 1743                         len = scsi_low_msgout(slp, ti, flags);
 1744 
 1745                         if (len > 1 && slp->sl_atten == 0)
 1746                         {
 1747                                 scsi_low_attention(slp);
 1748                         }
 1749 
 1750                         if (nsp_xfer(sc, ti->ti_msgoutstr, len, PHASE_MSGOUT,
 1751                                      slp->sl_clear_atten) != 0)
 1752                         {
 1753                                 slp->sl_error |= FATALIO;
 1754                                 nsp_error(sc, "MSGOUT: xfer short",
 1755                                                     isrc, ph, irqphs);
 1756                         }
 1757 
 1758                         /* catch a next signal */
 1759                         rv = nsp_expect_signal(sc, PHASE_MSGOUT, SCBUSMON_REQ);
 1760                 }
 1761                 while (rv > 0 && len -- > 0);
 1762 
 1763 #else   /* !NSP_MSGOUT_SERIALIZE */
 1764                 SCSI_LOW_SETUP_PHASE(ti, PH_MSGOUT);
 1765                 flags = SCSI_LOW_MSGOUT_UNIFY;
 1766                 if (ti->ti_ophase != ti->ti_phase)
 1767                         flags |= SCSI_LOW_MSGOUT_INIT;
 1768                 len = scsi_low_msgout(slp, ti, flags);
 1769 
 1770                 if (len > 1 && slp->sl_atten == 0)
 1771                 {
 1772                         scsi_low_attention(slp);
 1773                 }
 1774 
 1775                 if (nsp_xfer(sc, ti->ti_msgoutstr, len, PHASE_MSGOUT,
 1776                              slp->sl_clear_atten) != 0)
 1777                 {
 1778                         nsp_error(sc, "MSGOUT: xfer short", isrc, ph, irqphs);
 1779                 }
 1780 
 1781 #endif  /* !NSP_MSGOUT_SERIALIZE */
 1782                 break;
 1783 
 1784         case IRQPHS_MSGIN:
 1785                 if (nsp_phase_match(sc, PHASE_MSGIN, ph) != 0)
 1786                         return 1;
 1787 
 1788                 /*
 1789                  * XXX: NSP QUIRK
 1790                  * NSP invoke interrupts only in the case of scsi phase changes,
 1791                  * therefore we should poll the scsi phase here to catch 
 1792                  * the next "msg in" if exists (no scsi phase changes).
 1793                  */
 1794                 rv = len = 16;
 1795                 do {
 1796                         SCSI_LOW_SETUP_PHASE(ti, PH_MSGIN);
 1797 
 1798                         /* read a data */
 1799                         regv = nsp_cr_read_1(bst, bsh, NSPR_DATA);
 1800                         if (nsp_cr_read_1(bst, bsh, NSPR_PARITYR) & PARITYR_PE)
 1801                         {
 1802                                 nsp_cr_write_1(bst, bsh,
 1803                                                NSPR_PARITYR, 
 1804                                                PARITYR_ENABLE | PARITYR_CLEAR);
 1805                                 derror = SCSI_LOW_DATA_PE;
 1806                         }
 1807                         else
 1808                         {
 1809                                 derror = 0;
 1810                         }
 1811 
 1812                         /* assert ack */
 1813                         cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR) | SCBUSCR_ACK;
 1814                         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
 1815 
 1816                         if (scsi_low_msgin(slp, ti, regv | derror) == 0)
 1817                         {
 1818                                 if (scsi_low_is_msgout_continue(ti, 0) != 0)
 1819                                 {
 1820                                         scsi_low_attention(slp);
 1821                                 }
 1822                         }
 1823 
 1824                         /* check REQ nagated */
 1825                         nsp_negate_signal(sc, SCBUSMON_REQ, "msgin<REQ>");
 1826 
 1827                         /* deassert ack */
 1828                         cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR) & (~SCBUSCR_ACK);
 1829                         nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
 1830 
 1831                         /* catch a next signal */
 1832                         rv = nsp_expect_signal(sc, PHASE_MSGIN, SCBUSMON_REQ);
 1833                 } 
 1834                 while (rv > 0 && len -- > 0);
 1835                 break;
 1836 
 1837         default:
 1838                 slp->sl_error |= FATALIO;
 1839                 nsp_error(sc, "unknown scsi phase", isrc, ph, irqphs);
 1840                 break;
 1841         }
 1842 
 1843         return 1;
 1844 
 1845 #if     0
 1846 timerout:
 1847         nsp_start_timer(sc, NSP_TIMER_1MS);
 1848         return 0;
 1849 #endif
 1850 }
 1851 
 1852 static int
 1853 nsp_timeout(sc)
 1854         struct nsp_softc *sc;
 1855 {
 1856         struct scsi_low_softc *slp = &sc->sc_sclow;
 1857         bus_space_tag_t iot = sc->sc_iot;
 1858         bus_space_handle_t ioh = sc->sc_ioh;
 1859         int tout;
 1860         u_int8_t ph, regv;
 1861 
 1862         if (slp->sl_Tnexus == NULL)
 1863                 return 0;
 1864 
 1865         ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON);
 1866         switch (ph & SCBUSMON_PHMASK)
 1867         {
 1868         case PHASE_DATAOUT:
 1869                 if (sc->sc_dataout_timeout == 0)
 1870                         break;
 1871 
 1872                 /* check a fifo empty */
 1873                 regv = bus_space_read_1(iot, ioh, nsp_fifosr);
 1874                 if ((regv & FIFOSR_FULLEMP) == 0)
 1875                         break;
 1876                 bus_space_write_1(iot, ioh, nsp_irqcr, IRQCR_FIFOCL);
 1877 
 1878                 /* check still requested */
 1879                 ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON);
 1880                 if ((ph & SCBUSMON_REQ) == 0)
 1881                         break;
 1882                 /* check timeout */
 1883                 if ((-- sc->sc_dataout_timeout) > 0)
 1884                         break;  
 1885 
 1886                 slp->sl_error |= PDMAERR;
 1887                 if ((slp->sl_flags & HW_WRITE_PADDING) == 0)
 1888                 {
 1889                         printf("%s: write padding required\n", slp->sl_xname);
 1890                         break;
 1891                 }
 1892 
 1893                 tout = NSP_DELAY_MAX;
 1894                 while (tout -- > 0)
 1895                 {
 1896                         ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON);
 1897                         if ((ph & SCBUSMON_PHMASK) != PHASE_DATAOUT)
 1898                                 break;
 1899                         regv = bus_space_read_1(iot, ioh, nsp_fifosr);
 1900                         if ((regv & FIFOSR_FULLEMP) == 0)
 1901                         {
 1902                                 SCSI_LOW_DELAY(1);
 1903                                 continue;
 1904                         }
 1905 
 1906                         bus_space_write_1(iot, ioh, nsp_irqcr, IRQCR_FIFOCL);
 1907                         nsp_data_padding(sc, SCSI_LOW_WRITE, 32);
 1908                 }
 1909                 ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON);
 1910                 if ((ph & SCBUSMON_PHMASK) == PHASE_DATAOUT)
 1911                         sc->sc_dataout_timeout = SCSI_LOW_TIMEOUT_HZ;
 1912                 break;
 1913 
 1914         default:
 1915                 break;
 1916         }
 1917         return 0;
 1918 }

Cache object: 456d4eeb65615bd9813195dbd6f749fe


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.