drivers/scsi/aic7xxx/aic79xx.seq

   1 /*
   2  * Adaptec U320 device driver firmware for Linux and FreeBSD.
   3  *
   4  * Copyright (c) 1994-2001 Justin T. Gibbs.
   5  * Copyright (c) 2000-2002 Adaptec Inc.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions, and the following disclaimer,
  13  *    without modification.
  14  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  15  *    substantially similar to the "NO WARRANTY" disclaimer below
  16  *    ("Disclaimer") and any redistribution must be conditioned upon
  17  *    including a substantially similar Disclaimer requirement for further
  18  *    binary redistribution.
  19  * 3. Neither the names of the above-listed copyright holders nor the names
  20  *    of any contributors may be used to endorse or promote products derived
  21  *    from this software without specific prior written permission.
  22  *
  23  * Alternatively, this software may be distributed under the terms of the
  24  * GNU General Public License ("GPL") version 2 as published by the Free
  25  * Software Foundation.
  26  *
  27  * NO WARRANTY
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  29  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  30  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  31  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  32  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  36  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  37  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGES.
  39  *
  40  * $FreeBSD$
  41  */
  42
  43 VERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#119 $"
  44 PATCH_ARG_LIST = "struct ahd_softc *ahd"
  45 PREFIX = "ahd_"
  46
  47 #include "aic79xx.reg"
  48 #include "scsi_message.h"
  49
  50 restart:
  51 if ((ahd->bugs & AHD_INTCOLLISION_BUG) != 0) {
  52         test    SEQINTCODE, 0xFF jz idle_loop;
  53         SET_SEQINTCODE(NO_SEQINT)
  54 }
  55
  56 idle_loop:
  57
  58         if ((ahd->bugs & AHD_INTCOLLISION_BUG) != 0) {
  59                 /*
  60                  * Convert ERROR status into a sequencer
  61                  * interrupt to handle the case of an
  62                  * interrupt collision on the hardware
  63                  * setting of HWERR.
  64                  */
  65                 test    ERROR, 0xFF jz no_error_set;
  66                 SET_SEQINTCODE(SAW_HWERR)
  67 no_error_set:
  68         }
  69         SET_MODE(M_SCSI, M_SCSI)
  70         test    SCSISEQ0, ENSELO|ENARBO jnz idle_loop_checkbus;
  71         test    SEQ_FLAGS2, SELECTOUT_QFROZEN jz check_waiting_list;
  72         /*
  73          * If the kernel has caught up with us, thaw the queue.
  74          */
  75         mov     A, KERNEL_QFREEZE_COUNT;
  76         cmp     QFREEZE_COUNT, A jne check_frozen_completions;
  77         mov     A, KERNEL_QFREEZE_COUNT[1];
  78         cmp     QFREEZE_COUNT[1], A jne check_frozen_completions;
  79         and     SEQ_FLAGS2, ~SELECTOUT_QFROZEN;
  80         jmp     check_waiting_list;
  81 check_frozen_completions:
  82         test    SSTAT0, SELDO|SELINGO jnz idle_loop_checkbus;
  83 BEGIN_CRITICAL;
  84         /*
  85          * If we have completions stalled waiting for the qfreeze
  86          * to take effect, move them over to the complete_scb list
  87          * now that no selections are pending.
  88          */
  89         cmp     COMPLETE_ON_QFREEZE_HEAD[1],SCB_LIST_NULL je idle_loop_checkbus;
  90         /*
  91          * Find the end of the qfreeze list.  The first element has
  92          * to be treated specially.
  93          */
  94         bmov    SCBPTR, COMPLETE_ON_QFREEZE_HEAD, 2;
  95         cmp     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL je join_lists;
  96         /*
  97          * Now the normal loop.
  98          */
  99         bmov    SCBPTR, SCB_NEXT_COMPLETE, 2;
 100         cmp     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL jne . - 1;
 101 join_lists:
 102         bmov    SCB_NEXT_COMPLETE, COMPLETE_SCB_HEAD, 2;
 103         bmov    COMPLETE_SCB_HEAD, COMPLETE_ON_QFREEZE_HEAD, 2;
 104         mvi     COMPLETE_ON_QFREEZE_HEAD[1], SCB_LIST_NULL;
 105         jmp     idle_loop_checkbus;
 106 check_waiting_list:
 107         cmp     WAITING_TID_HEAD[1], SCB_LIST_NULL je idle_loop_checkbus;
 108         /*
 109          * ENSELO is cleared by a SELDO, so we must test for SELDO
 110          * one last time.
 111          */
 112         test    SSTAT0, SELDO jnz select_out;
 113 END_CRITICAL;
 114         call    start_selection;
 115 idle_loop_checkbus:
 116 BEGIN_CRITICAL;
 117         test    SSTAT0, SELDO jnz select_out;
 118 END_CRITICAL;
 119         test    SSTAT0, SELDI jnz select_in;
 120         test    SCSIPHASE, ~DATA_PHASE_MASK jz idle_loop_check_nonpackreq;
 121         test    SCSISIGO, ATNO jz idle_loop_check_nonpackreq;
 122         call    unexpected_nonpkt_phase_find_ctxt;
 123 idle_loop_check_nonpackreq:
 124         test    SSTAT2, NONPACKREQ jz . + 2;
 125         call    unexpected_nonpkt_phase_find_ctxt;
 126         if ((ahd->bugs & AHD_FAINT_LED_BUG) != 0) {
 127                 /*
 128                  * On Rev A. hardware, the busy LED is only
 129                  * turned on automaically during selections
 130                  * and re-selections.  Make the LED status
 131                  * more useful by forcing it to be on so
 132                  * long as one of our data FIFOs is active.
 133                  */
 134                 and     A, FIFO0FREE|FIFO1FREE, DFFSTAT;
 135                 cmp     A, FIFO0FREE|FIFO1FREE jne . + 3;
 136                 and     SBLKCTL, ~DIAGLEDEN|DIAGLEDON;
 137                 jmp     . + 2;
 138                 or      SBLKCTL, DIAGLEDEN|DIAGLEDON;
 139         }
 140         call    idle_loop_gsfifo_in_scsi_mode;
 141         call    idle_loop_service_fifos;
 142         call    idle_loop_cchan;
 143         jmp     idle_loop;
 144
 145 idle_loop_gsfifo:
 146         SET_MODE(M_SCSI, M_SCSI)
 147 BEGIN_CRITICAL;
 148 idle_loop_gsfifo_in_scsi_mode:
 149         test    LQISTAT2, LQIGSAVAIL jz return;
 150         /*
 151          * We have received good status for this transaction.  There may
 152          * still be data in our FIFOs draining to the host.  Complete
 153          * the SCB only if all data has transferred to the host.
 154          */
 155 good_status_IU_done:
 156         bmov    SCBPTR, GSFIFO, 2;
 157         clr     SCB_SCSI_STATUS;
 158         /*
 159          * If a command completed before an attempted task management
 160          * function completed, notify the host after disabling any
 161          * pending select-outs.
 162          */
 163         test    SCB_TASK_MANAGEMENT, 0xFF jz gsfifo_complete_normally;
 164         test    SSTAT0, SELDO|SELINGO jnz . + 2;
 165         and     SCSISEQ0, ~ENSELO;
 166         SET_SEQINTCODE(TASKMGMT_CMD_CMPLT_OKAY)
 167 gsfifo_complete_normally:
 168         or      SCB_CONTROL, STATUS_RCVD;
 169
 170         /*
 171          * Since this status did not consume a FIFO, we have to
 172          * be a bit more dilligent in how we check for FIFOs pertaining
 173          * to this transaction.  There are two states that a FIFO still
 174          * transferring data may be in.
 175          *
 176          * 1) Configured and draining to the host, with a FIFO handler.
 177          * 2) Pending cfg4data, fifo not empty.
 178          *
 179          * Case 1 can be detected by noticing a non-zero FIFO active
 180          * count in the SCB.  In this case, we allow the routine servicing
 181          * the FIFO to complete the SCB.
 182          *
 183          * Case 2 implies either a pending or yet to occur save data
 184          * pointers for this same context in the other FIFO.  So, if
 185          * we detect case 1, we will properly defer the post of the SCB
 186          * and achieve the desired result.  The pending cfg4data will
 187          * notice that status has been received and complete the SCB.
 188          */
 189         test    SCB_FIFO_USE_COUNT, 0xFF jnz idle_loop_gsfifo_in_scsi_mode;
 190         call    complete;
 191 END_CRITICAL;
 192         jmp     idle_loop_gsfifo_in_scsi_mode;
 193
 194 idle_loop_service_fifos:
 195         SET_MODE(M_DFF0, M_DFF0)
 196 BEGIN_CRITICAL;
 197         test    LONGJMP_ADDR[1], INVALID_ADDR jnz idle_loop_next_fifo;
 198         call    longjmp;
 199 END_CRITICAL;
 200 idle_loop_next_fifo:
 201         SET_MODE(M_DFF1, M_DFF1)
 202 BEGIN_CRITICAL;
 203         test    LONGJMP_ADDR[1], INVALID_ADDR jz longjmp;
 204 END_CRITICAL;
 205 return:
 206         ret;
 207
 208 idle_loop_cchan:
 209         SET_MODE(M_CCHAN, M_CCHAN)
 210         test    QOFF_CTLSTA, HS_MAILBOX_ACT jz  hs_mailbox_empty;
 211         or      QOFF_CTLSTA, HS_MAILBOX_ACT;
 212         mov     LOCAL_HS_MAILBOX, HS_MAILBOX;
 213 hs_mailbox_empty:
 214 BEGIN_CRITICAL;
 215         test    CCSCBCTL, CCARREN|CCSCBEN jz scbdma_idle;
 216         test    CCSCBCTL, CCSCBDIR jnz fetch_new_scb_inprog;
 217         test    CCSCBCTL, CCSCBDONE jz return;
 218         /* FALLTHROUGH */
 219 scbdma_tohost_done:
 220         test    CCSCBCTL, CCARREN jz fill_qoutfifo_dmadone;
 221         /*
 222          * An SCB has been succesfully uploaded to the host.
 223          * If the SCB was uploaded for some reason other than
 224          * bad SCSI status (currently only for underruns), we
 225          * queue the SCB for normal completion.  Otherwise, we
 226          * wait until any select-out activity has halted, and
 227          * then queue the completion.
 228          */
 229         and     CCSCBCTL, ~(CCARREN|CCSCBEN);
 230         bmov    COMPLETE_DMA_SCB_HEAD, SCB_NEXT_COMPLETE, 2;
 231         cmp     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL jne . + 2;
 232         mvi     COMPLETE_DMA_SCB_TAIL[1], SCB_LIST_NULL;
 233         test    SCB_SCSI_STATUS, 0xff jz scbdma_queue_completion;
 234         bmov    SCB_NEXT_COMPLETE, COMPLETE_ON_QFREEZE_HEAD, 2;
 235         bmov    COMPLETE_ON_QFREEZE_HEAD, SCBPTR, 2 ret;
 236 scbdma_queue_completion:
 237         bmov    SCB_NEXT_COMPLETE, COMPLETE_SCB_HEAD, 2;
 238         bmov    COMPLETE_SCB_HEAD, SCBPTR, 2 ret;
 239 fill_qoutfifo_dmadone:
 240         and     CCSCBCTL, ~(CCARREN|CCSCBEN);
 241         call    qoutfifo_updated;
 242         mvi     COMPLETE_SCB_DMAINPROG_HEAD[1], SCB_LIST_NULL;
 243         bmov    QOUTFIFO_NEXT_ADDR, SCBHADDR, 4;
 244         test    QOFF_CTLSTA, SDSCB_ROLLOVR jz return;
 245         bmov    QOUTFIFO_NEXT_ADDR, SHARED_DATA_ADDR, 4;
 246         xor     QOUTFIFO_ENTRY_VALID_TAG, QOUTFIFO_ENTRY_VALID_TOGGLE ret;
 247 END_CRITICAL;
 248
 249 qoutfifo_updated:
 250         /*
 251          * If there are more commands waiting to be dma'ed
 252          * to the host, always coalesce.  Otherwise honor the
 253          * host's wishes.
 254          */
 255         cmp     COMPLETE_DMA_SCB_HEAD[1], SCB_LIST_NULL jne coalesce_by_count;
 256         cmp     COMPLETE_SCB_HEAD[1], SCB_LIST_NULL jne coalesce_by_count;
 257         test    LOCAL_HS_MAILBOX, ENINT_COALESCE jz issue_cmdcmplt;
 258
 259         /*
 260          * If we have relatively few commands outstanding, don't
 261          * bother waiting for another command to complete.
 262          */
 263         test    CMDS_PENDING[1], 0xFF jnz coalesce_by_count;
 264         /* Add -1 so that jnc means <= not just < */
 265         add     A, -1, INT_COALESCING_MINCMDS;
 266         add     NONE, A, CMDS_PENDING;
 267         jnc     issue_cmdcmplt;
 268
 269         /*
 270          * If coalescing, only coalesce up to the limit
 271          * provided by the host driver.
 272          */
 273 coalesce_by_count:
 274         mov     A, INT_COALESCING_MAXCMDS;
 275         add     NONE, A, INT_COALESCING_CMDCOUNT;
 276         jc      issue_cmdcmplt;
 277         /*
 278          * If the timer is not currently active,
 279          * fire it up.
 280          */
 281         test    INTCTL, SWTMINTMASK jz return;
 282         bmov    SWTIMER, INT_COALESCING_TIMER, 2;
 283         mvi     CLRSEQINTSTAT, CLRSEQ_SWTMRTO;
 284         or      INTCTL, SWTMINTEN|SWTIMER_START;
 285         and     INTCTL, ~SWTMINTMASK ret;
 286
 287 issue_cmdcmplt:
 288         mvi     INTSTAT, CMDCMPLT;
 289         clr     INT_COALESCING_CMDCOUNT;
 290         or      INTCTL, SWTMINTMASK ret;
 291
 292 BEGIN_CRITICAL;
 293 fetch_new_scb_inprog:
 294         test    CCSCBCTL, ARRDONE jz return;
 295 fetch_new_scb_done:
 296         and     CCSCBCTL, ~(CCARREN|CCSCBEN);
 297         bmov    REG0, SCBPTR, 2;
 298         clr     A;
 299         add     CMDS_PENDING, 1;
 300         adc     CMDS_PENDING[1], A;
 301         if ((ahd->bugs & AHD_PKT_LUN_BUG) != 0) {
 302                 /*
 303                  * "Short Luns" are not placed into outgoing LQ
 304                  * packets in the correct byte order.  Use a full
 305                  * sized lun field instead and fill it with the
 306                  * one byte of lun information we support.
 307                  */
 308                 mov     SCB_PKT_LUN[6], SCB_LUN;
 309         }
 310         /*
 311          * The FIFO use count field is shared with the
 312          * tag set by the host so that our SCB dma engine
 313          * knows the correct location to store the SCB.
 314          * Set it to zero before processing the SCB.
 315          */
 316         clr     SCB_FIFO_USE_COUNT;
 317         /* Update the next SCB address to download. */
 318         bmov    NEXT_QUEUED_SCB_ADDR, SCB_NEXT_SCB_BUSADDR, 4;
 319         mvi     SCB_NEXT[1], SCB_LIST_NULL;
 320         mvi     SCB_NEXT2[1], SCB_LIST_NULL;
 321         /* Increment our position in the QINFIFO. */
 322         mov     NONE, SNSCB_QOFF;
 323         /*
 324          * SCBs that want to send messages are always
 325          * queued independently.  This ensures that they
 326          * are at the head of the SCB list to select out
 327          * to a target and we will see the MK_MESSAGE flag.
 328          */
 329         test    SCB_CONTROL, MK_MESSAGE jnz first_new_target_scb;
 330         shr     SINDEX, 3, SCB_SCSIID;
 331         and     SINDEX, ~0x1;
 332         mvi     SINDEX[1], (WAITING_SCB_TAILS >> 8);
 333         bmov    DINDEX, SINDEX, 2;
 334         bmov    SCBPTR, SINDIR, 2;
 335         bmov    DINDIR, REG0, 2;
 336         cmp     SCBPTR[1], SCB_LIST_NULL je first_new_target_scb;
 337         bmov    SCB_NEXT, REG0, 2 ret;
 338 first_new_target_scb:
 339         cmp     WAITING_TID_HEAD[1], SCB_LIST_NULL je first_new_scb;
 340         bmov    SCBPTR, WAITING_TID_TAIL, 2;
 341         bmov    SCB_NEXT2, REG0, 2;
 342         bmov    WAITING_TID_TAIL, REG0, 2 ret;
 343 first_new_scb:
 344         bmov    WAITING_TID_HEAD, REG0, 2;
 345         bmov    WAITING_TID_TAIL, REG0, 2 ret;
 346 END_CRITICAL;
 347
 348 scbdma_idle:
 349         /*
 350          * Give precedence to downloading new SCBs to execute
 351          * unless select-outs are currently frozen.
 352          */
 353         test    SEQ_FLAGS2, SELECTOUT_QFROZEN jnz . + 2;
 354 BEGIN_CRITICAL;
 355         test    QOFF_CTLSTA, NEW_SCB_AVAIL jnz fetch_new_scb;
 356         cmp     COMPLETE_DMA_SCB_HEAD[1], SCB_LIST_NULL jne dma_complete_scb;
 357         cmp     COMPLETE_SCB_HEAD[1], SCB_LIST_NULL je return;
 358         /* FALLTHROUGH */
 359 fill_qoutfifo:
 360         /*
 361          * Keep track of the SCBs we are dmaing just
 362          * in case the DMA fails or is aborted.
 363          */
 364         bmov    COMPLETE_SCB_DMAINPROG_HEAD, COMPLETE_SCB_HEAD, 2;
 365         mvi     CCSCBCTL, CCSCBRESET;
 366         bmov    SCBHADDR, QOUTFIFO_NEXT_ADDR, 4;
 367         mov     A, QOUTFIFO_NEXT_ADDR;
 368         bmov    SCBPTR, COMPLETE_SCB_HEAD, 2;
 369 fill_qoutfifo_loop:
 370         bmov    CCSCBRAM, SCBPTR, 2;
 371         mov     CCSCBRAM, SCB_SGPTR[0];
 372         mov     CCSCBRAM, QOUTFIFO_ENTRY_VALID_TAG;
 373         mov     NONE, SDSCB_QOFF;
 374         inc     INT_COALESCING_CMDCOUNT;
 375         add     CMDS_PENDING, -1;
 376         adc     CMDS_PENDING[1], -1;
 377         cmp     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL je fill_qoutfifo_done;
 378         cmp     CCSCBADDR, CCSCBADDR_MAX je fill_qoutfifo_done;
 379         test    QOFF_CTLSTA, SDSCB_ROLLOVR jnz fill_qoutfifo_done;
 380         /*
 381          * Don't cross an ADB or Cachline boundary when DMA'ing
 382          * completion entries.  In PCI mode, at least in 32/33
 383          * configurations, the SCB DMA engine may lose its place
 384          * in the data-stream should the target force a retry on
 385          * something other than an 8byte aligned boundary. In
 386          * PCI-X mode, we do this to avoid split transactions since
 387          * many chipsets seem to be unable to format proper split
 388          * completions to continue the data transfer.
 389          */
 390         add     SINDEX, A, CCSCBADDR;
 391         test    SINDEX, CACHELINE_MASK jz fill_qoutfifo_done;
 392         bmov    SCBPTR, SCB_NEXT_COMPLETE, 2;
 393         jmp     fill_qoutfifo_loop;
 394 fill_qoutfifo_done:
 395         mov     SCBHCNT, CCSCBADDR;
 396         mvi     CCSCBCTL, CCSCBEN|CCSCBRESET;
 397         bmov    COMPLETE_SCB_HEAD, SCB_NEXT_COMPLETE, 2;
 398         mvi     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL ret;
 399
 400 fetch_new_scb:
 401         bmov    SCBHADDR, NEXT_QUEUED_SCB_ADDR, 4;
 402         mvi     CCARREN|CCSCBEN|CCSCBDIR|CCSCBRESET jmp dma_scb;
 403 dma_complete_scb:
 404         bmov    SCBPTR, COMPLETE_DMA_SCB_HEAD, 2;
 405         bmov    SCBHADDR, SCB_BUSADDR, 4;
 406         mvi     CCARREN|CCSCBEN|CCSCBRESET jmp dma_scb;
 407
 408 /*
 409  * Either post or fetch an SCB from host memory.  The caller
 410  * is responsible for polling for transfer completion.
 411  *
 412  * Prerequisits: Mode == M_CCHAN
 413  *               SINDEX contains CCSCBCTL flags
 414  *               SCBHADDR set to Host SCB address
 415  *               SCBPTR set to SCB src location on "push" operations
 416  */
 417 SET_SRC_MODE    M_CCHAN;
 418 SET_DST_MODE    M_CCHAN;
 419 dma_scb:
 420         mvi     SCBHCNT, SCB_TRANSFER_SIZE;
 421         mov     CCSCBCTL, SINDEX ret;
 422
 423 setjmp:
 424         /*
 425          * At least on the A, a return in the same
 426          * instruction as the bmov results in a return
 427          * to the caller, not to the new address at the
 428          * top of the stack.  Since we want the latter
 429          * (we use setjmp to register a handler from an
 430          * interrupt context but not invoke that handler
 431          * until we return to our idle loop), use a
 432          * separate ret instruction.
 433          */
 434         bmov    LONGJMP_ADDR, STACK, 2;
 435         ret;
 436 setjmp_inline:
 437         bmov    LONGJMP_ADDR, STACK, 2;
 438 longjmp:
 439         bmov    STACK, LONGJMP_ADDR, 2 ret;
 440 END_CRITICAL;
 441
 442 /*************************** Chip Bug Work Arounds ****************************/
 443 /*
 444  * Must disable interrupts when setting the mode pointer
 445  * register as an interrupt occurring mid update will
 446  * fail to store the new mode value for restoration on
 447  * an iret.
 448  */
 449 if ((ahd->bugs & AHD_SET_MODE_BUG) != 0) {
 450 set_mode_work_around:
 451         mvi     SEQINTCTL, INTVEC1DSL;
 452         mov     MODE_PTR, SINDEX;
 453         clr     SEQINTCTL ret;
 454 }
 455
 456
 457 if ((ahd->bugs & AHD_INTCOLLISION_BUG) != 0) {
 458 set_seqint_work_around:
 459         mov     SEQINTCODE, SINDEX;
 460         mvi     SEQINTCODE, NO_SEQINT ret;
 461 }
 462
 463 /************************ Packetized LongJmp Routines *************************/
 464 SET_SRC_MODE    M_SCSI;
 465 SET_DST_MODE    M_SCSI;
 466 start_selection:
 467 BEGIN_CRITICAL;
 468         if ((ahd->bugs & AHD_SENT_SCB_UPDATE_BUG) != 0) {
 469                 /*
 470                  * Razor #494
 471                  * Rev A hardware fails to update LAST/CURR/NEXTSCB
 472                  * correctly after a packetized selection in several
 473                  * situations:
 474                  *
 475                  * 1) If only one command existed in the queue, the
 476                  *    LAST/CURR/NEXTSCB are unchanged.
 477                  *
 478                  * 2) In a non QAS, protocol allowed phase change,
 479                  *    the queue is shifted 1 too far.  LASTSCB is
 480                  *    the last SCB that was correctly processed.
 481                  *
 482                  * 3) In the QAS case, if the full list of commands
 483                  *    was successfully sent, NEXTSCB is NULL and neither
 484                  *    CURRSCB nor LASTSCB can be trusted.  We must
 485                  *    manually walk the list counting MAXCMDCNT elements
 486                  *    to find the last SCB that was sent correctly.
 487                  *
 488                  * To simplify the workaround for this bug in SELDO
 489                  * handling, we initialize LASTSCB prior to enabling
 490                  * selection so we can rely on it even for case #1 above.
 491                  */
 492                 bmov    LASTSCB, WAITING_TID_HEAD, 2;
 493         }
 494         bmov    CURRSCB, WAITING_TID_HEAD, 2;
 495         bmov    SCBPTR, WAITING_TID_HEAD, 2;
 496         shr     SELOID, 4, SCB_SCSIID;
 497         /*
 498          * If we want to send a message to the device, ensure
 499          * we are selecting with atn irregardless of our packetized
 500          * agreement.  Since SPI4 only allows target reset or PPR
 501          * messages if this is a packetized connection, the change
 502          * to our negotiation table entry for this selection will
 503          * be cleared when the message is acted on.
 504          */
 505         test    SCB_CONTROL, MK_MESSAGE jz . + 3;
 506         mov     NEGOADDR, SELOID;
 507         or      NEGCONOPTS, ENAUTOATNO;
 508         or      SCSISEQ0, ENSELO ret;
 509 END_CRITICAL;
 510
 511 /*
 512  * Allocate a FIFO for a non-packetized transaction.
 513  * In RevA hardware, both FIFOs must be free before we
 514  * can allocate a FIFO for a non-packetized transaction.
 515  */
 516 allocate_fifo_loop:
 517         /*
 518          * Do whatever work is required to free a FIFO.
 519          */
 520         call    idle_loop_service_fifos;
 521         SET_MODE(M_SCSI, M_SCSI)
 522 allocate_fifo:
 523         if ((ahd->bugs & AHD_NONPACKFIFO_BUG) != 0) {
 524                 and     A, FIFO0FREE|FIFO1FREE, DFFSTAT;
 525                 cmp     A, FIFO0FREE|FIFO1FREE jne allocate_fifo_loop;
 526         } else {
 527                 test    DFFSTAT, FIFO1FREE jnz allocate_fifo1;
 528                 test    DFFSTAT, FIFO0FREE jz allocate_fifo_loop;
 529                 mvi     DFFSTAT, B_CURRFIFO_0;
 530                 SET_MODE(M_DFF0, M_DFF0)
 531                 bmov    SCBPTR, ALLOCFIFO_SCBPTR, 2 ret;
 532         }
 533 SET_SRC_MODE    M_SCSI;
 534 SET_DST_MODE    M_SCSI;
 535 allocate_fifo1:
 536         mvi     DFFSTAT, CURRFIFO_1;
 537         SET_MODE(M_DFF1, M_DFF1)
 538         bmov    SCBPTR, ALLOCFIFO_SCBPTR, 2 ret;
 539
 540 /*
 541  * We have been reselected as an initiator
 542  * or selected as a target.
 543  */
 544 SET_SRC_MODE    M_SCSI;
 545 SET_DST_MODE    M_SCSI;
 546 select_in:
 547         if ((ahd->bugs & AHD_FAINT_LED_BUG) != 0) {
 548                 /*
 549                  * On Rev A. hardware, the busy LED is only
 550                  * turned on automaically during selections
 551                  * and re-selections.  Make the LED status
 552                  * more useful by forcing it to be on from
 553                  * the point of selection until our idle
 554                  * loop determines that neither of our FIFOs
 555                  * are busy.  This handles the non-packetized
 556                  * case nicely as we will not return to the
 557                  * idle loop until the busfree at the end of
 558                  * each transaction.
 559                  */
 560                 or      SBLKCTL, DIAGLEDEN|DIAGLEDON;
 561         }
 562         if ((ahd->bugs & AHD_BUSFREEREV_BUG) != 0) {
 563                 /*
 564                  * Test to ensure that the bus has not
 565                  * already gone free prior to clearing
 566                  * any stale busfree status.  This avoids
 567                  * a window whereby a busfree just after
 568                  * a selection could be missed.
 569                  */
 570                 test    SCSISIGI, BSYI jz . + 2;
 571                 mvi     CLRSINT1,CLRBUSFREE;
 572                 or      SIMODE1, ENBUSFREE;
 573         }
 574         or      SXFRCTL0, SPIOEN;
 575         and     SAVED_SCSIID, SELID_MASK, SELID;
 576         and     A, OID, IOWNID;
 577         or      SAVED_SCSIID, A;
 578         mvi     CLRSINT0, CLRSELDI;
 579         jmp     ITloop;
 580
 581 /*
 582  * We have successfully selected out.
 583  *
 584  * Clear SELDO.
 585  * Dequeue all SCBs sent from the waiting queue
 586  * Requeue all SCBs *not* sent to the tail of the waiting queue
 587  * Take Razor #494 into account for above.
 588  *
 589  * In Packetized Mode:
 590  *      Return to the idle loop.  Our interrupt handler will take
 591  *      care of any incoming L_Qs.
 592  *
 593  * In Non-Packetize Mode:
 594  *      Continue to our normal state machine.
 595  */
 596 SET_SRC_MODE    M_SCSI;
 597 SET_DST_MODE    M_SCSI;
 598 select_out:
 599 BEGIN_CRITICAL;
 600         if ((ahd->bugs & AHD_FAINT_LED_BUG) != 0) {
 601                 /*
 602                  * On Rev A. hardware, the busy LED is only
 603                  * turned on automaically during selections
 604                  * and re-selections.  Make the LED status
 605                  * more useful by forcing it to be on from
 606                  * the point of re-selection until our idle
 607                  * loop determines that neither of our FIFOs
 608                  * are busy.  This handles the non-packetized
 609                  * case nicely as we will not return to the
 610                  * idle loop until the busfree at the end of
 611                  * each transaction.
 612                  */
 613                 or      SBLKCTL, DIAGLEDEN|DIAGLEDON;
 614         }
 615         /* Clear out all SCBs that have been successfully sent. */
 616         if ((ahd->bugs & AHD_SENT_SCB_UPDATE_BUG) != 0) {
 617                 /*
 618                  * For packetized, the LQO manager clears ENSELO on
 619                  * the assertion of SELDO.  If we are non-packetized,
 620                  * LASTSCB and CURRSCB are accurate.
 621                  */
 622                 test    SCSISEQ0, ENSELO jnz use_lastscb;
 623
 624                 /*
 625                  * The update is correct for LQOSTAT1 errors.  All
 626                  * but LQOBUSFREE are handled by kernel interrupts.
 627                  * If we see LQOBUSFREE, return to the idle loop.
 628                  * Once we are out of the select_out critical section,
 629                  * the kernel will cleanup the LQOBUSFREE and we will
 630                  * eventually restart the selection if appropriate.
 631                  */
 632                 test    LQOSTAT1, LQOBUSFREE jnz idle_loop;
 633
 634                 /*
 635                  * On a phase change oustside of packet boundaries,
 636                  * LASTSCB points to the currently active SCB context
 637                  * on the bus.
 638                  */
 639                 test    LQOSTAT2, LQOPHACHGOUTPKT jnz use_lastscb;
 640
 641                 /*
 642                  * If the hardware has traversed the whole list, NEXTSCB
 643                  * will be NULL, CURRSCB and LASTSCB cannot be trusted,
 644                  * but MAXCMDCNT is accurate.  If we stop part way through
 645                  * the list or only had one command to issue, NEXTSCB[1] is
 646                  * not NULL and LASTSCB is the last command to go out.
 647                  */
 648                 cmp     NEXTSCB[1], SCB_LIST_NULL jne use_lastscb;
 649
 650                 /*
 651                  * Brute force walk.
 652                  */
 653                 bmov    SCBPTR, WAITING_TID_HEAD, 2;
 654                 mvi     SEQINTCTL, INTVEC1DSL;
 655                 mvi     MODE_PTR, MK_MODE(M_CFG, M_CFG);
 656                 mov     A, MAXCMDCNT;
 657                 mvi     MODE_PTR, MK_MODE(M_SCSI, M_SCSI);
 658                 clr     SEQINTCTL;
 659 find_lastscb_loop:
 660                 dec     A;
 661                 test    A, 0xFF jz found_last_sent_scb;
 662                 bmov    SCBPTR, SCB_NEXT, 2;
 663                 jmp     find_lastscb_loop;
 664 use_lastscb:
 665                 bmov    SCBPTR, LASTSCB, 2;
 666 found_last_sent_scb:
 667                 bmov    CURRSCB, SCBPTR, 2;
 668 curscb_ww_done:
 669         } else {
 670                 bmov    SCBPTR, CURRSCB, 2;
 671         }
 672
 673         /*
 674          * Requeue any SCBs not sent, to the tail of the waiting Q.
 675          */
 676         cmp     SCB_NEXT[1], SCB_LIST_NULL je select_out_list_done;
 677
 678         /*
 679          * We know that neither the per-TID list nor the list of
 680          * TIDs is empty.  Use this knowledge to our advantage.
 681          */
 682         bmov    REG0, SCB_NEXT, 2;
 683         bmov    SCBPTR, WAITING_TID_TAIL, 2;
 684         bmov    SCB_NEXT2, REG0, 2;
 685         bmov    WAITING_TID_TAIL, REG0, 2;
 686         jmp     select_out_inc_tid_q;
 687
 688 select_out_list_done:
 689         /*
 690          * The whole list made it.  Just clear our TID's tail pointer
 691          * unless we were queued independently due to our need to
 692          * send a message.
 693          */
 694         test    SCB_CONTROL, MK_MESSAGE jnz select_out_inc_tid_q;
 695         shr     DINDEX, 3, SCB_SCSIID;
 696         or      DINDEX, 1;      /* Want only the second byte */
 697         mvi     DINDEX[1], ((WAITING_SCB_TAILS) >> 8);
 698         mvi     DINDIR, SCB_LIST_NULL;
 699 select_out_inc_tid_q:
 700         bmov    SCBPTR, WAITING_TID_HEAD, 2;
 701         bmov    WAITING_TID_HEAD, SCB_NEXT2, 2;
 702         cmp     WAITING_TID_HEAD[1], SCB_LIST_NULL jne . + 2;
 703         mvi     WAITING_TID_TAIL[1], SCB_LIST_NULL;
 704         bmov    SCBPTR, CURRSCB, 2;
 705         mvi     CLRSINT0, CLRSELDO;
 706         test    LQOSTAT2, LQOPHACHGOUTPKT jnz unexpected_nonpkt_phase;
 707         test    LQOSTAT1, LQOPHACHGINPKT jnz unexpected_nonpkt_phase;
 708
 709         /*
 710          * If this is a packetized connection, return to our
 711          * idle_loop and let our interrupt handler deal with
 712          * any connection setup/teardown issues.  The only
 713          * exceptions are the case of MK_MESSAGE and task management
 714          * SCBs.
 715          */
 716         if ((ahd->bugs & AHD_LQO_ATNO_BUG) != 0) {
 717                 /*
 718                  * In the A, the LQO manager transitions to LQOSTOP0 even if
 719                  * we have selected out with ATN asserted and the target
 720                  * REQs in a non-packet phase.
 721                  */
 722                 test    SCB_CONTROL, MK_MESSAGE jz select_out_no_message;
 723                 test    SCSISIGO, ATNO jnz select_out_non_packetized;
 724 select_out_no_message:
 725         }
 726         test    LQOSTAT2, LQOSTOP0 jz select_out_non_packetized;
 727         test    SCB_TASK_MANAGEMENT, 0xFF jz idle_loop;
 728         SET_SEQINTCODE(TASKMGMT_FUNC_COMPLETE)
 729         jmp     idle_loop;
 730
 731 select_out_non_packetized:
 732         /* Non packetized request. */
 733         and     SCSISEQ0, ~ENSELO;
 734         if ((ahd->bugs & AHD_BUSFREEREV_BUG) != 0) {
 735                 /*
 736                  * Test to ensure that the bus has not
 737                  * already gone free prior to clearing
 738                  * any stale busfree status.  This avoids
 739                  * a window whereby a busfree just after
 740                  * a selection could be missed.
 741                  */
 742                 test    SCSISIGI, BSYI jz . + 2;
 743                 mvi     CLRSINT1,CLRBUSFREE;
 744                 or      SIMODE1, ENBUSFREE;
 745         }
 746         mov     SAVED_SCSIID, SCB_SCSIID;
 747         mov     SAVED_LUN, SCB_LUN;
 748         mvi     SEQ_FLAGS, NO_CDB_SENT;
 749 END_CRITICAL;
 750         or      SXFRCTL0, SPIOEN;
 751
 752         /*
 753          * As soon as we get a successful selection, the target
 754          * should go into the message out phase since we have ATN
 755          * asserted.
 756          */
 757         mvi     MSG_OUT, MSG_IDENTIFYFLAG;
 758
 759         /*
 760          * Main loop for information transfer phases.  Wait for the
 761          * target to assert REQ before checking MSG, C/D and I/O for
 762          * the bus phase.
 763          */
 764 mesgin_phasemis:
 765 ITloop:
 766         call    phase_lock;
 767
 768         mov     A, LASTPHASE;
 769
 770         test    A, ~P_DATAIN_DT jz p_data;
 771         cmp     A,P_COMMAND     je p_command;
 772         cmp     A,P_MESGOUT     je p_mesgout;
 773         cmp     A,P_STATUS      je p_status;
 774         cmp     A,P_MESGIN      je p_mesgin;
 775
 776         SET_SEQINTCODE(BAD_PHASE)
 777         jmp     ITloop;                 /* Try reading the bus again. */
 778
 779 /*
 780  * Command phase.  Set up the DMA registers and let 'er rip.
 781  */
 782 p_command:
 783         test    SEQ_FLAGS, NOT_IDENTIFIED jz p_command_okay;
 784         SET_SEQINTCODE(PROTO_VIOLATION)
 785 p_command_okay:
 786         test    MODE_PTR, ~(MK_MODE(M_DFF1, M_DFF1))
 787                 jnz p_command_allocate_fifo;
 788         /*
 789          * Command retry.  Free our current FIFO and
 790          * re-allocate a FIFO so transfer state is
 791          * reset.
 792          */
 793 SET_SRC_MODE    M_DFF1;
 794 SET_DST_MODE    M_DFF1;
 795         mvi     DFFSXFRCTL, RSTCHN|CLRSHCNT;
 796         SET_MODE(M_SCSI, M_SCSI)
 797 p_command_allocate_fifo:
 798         bmov    ALLOCFIFO_SCBPTR, SCBPTR, 2;
 799         call    allocate_fifo;
 800 SET_SRC_MODE    M_DFF1;
 801 SET_DST_MODE    M_DFF1;
 802         add     NONE, -17, SCB_CDB_LEN;
 803         jnc     p_command_embedded;
 804 p_command_from_host:
 805         bmov    HADDR[0], SCB_HOST_CDB_PTR, 9;
 806         mvi     SG_CACHE_PRE, LAST_SEG;
 807         mvi     DFCNTRL, (PRELOADEN|SCSIEN|HDMAEN);
 808         jmp     p_command_xfer;
 809 p_command_embedded:
 810         bmov    SHCNT[0], SCB_CDB_LEN,  1;
 811         bmov    DFDAT, SCB_CDB_STORE, 16;
 812         mvi     DFCNTRL, SCSIEN;
 813 p_command_xfer:
 814         and     SEQ_FLAGS, ~NO_CDB_SENT;
 815         if ((ahd->features & AHD_FAST_CDB_DELIVERY) != 0) {
 816                 /*
 817                  * To speed up CDB delivery in Rev B, all CDB acks
 818                  * are "released" to the output sync as soon as the
 819                  * command phase starts.  There is only one problem
 820                  * with this approach.  If the target changes phase
 821                  * before all data are sent, we have left over acks
 822                  * that can go out on the bus in a data phase.  Due
 823                  * to other chip contraints, this only happens if
 824                  * the target goes to data-in, but if the acks go
 825                  * out before we can test SDONE, we'll think that
 826                  * the transfer has completed successfully.  Work
 827                  * around this by taking advantage of the 400ns or
 828                  * 800ns dead time between command phase and the REQ
 829                  * of the new phase.  If the transfer has completed
 830                  * successfully, SCSIEN should fall *long* before we
 831                  * see a phase change.  We thus treat any phasemiss
 832                  * that occurs before SCSIEN falls as an incomplete
 833                  * transfer.
 834                  */
 835                 test    SSTAT1, PHASEMIS jnz p_command_xfer_failed;
 836                 test    DFCNTRL, SCSIEN jnz . - 1;
 837         } else {
 838                 test    DFCNTRL, SCSIEN jnz .;
 839         }
 840         /*
 841          * DMA Channel automatically disabled.
 842          * Don't allow a data phase if the command
 843          * was not fully transferred.
 844          */
 845         test    SSTAT2, SDONE jnz ITloop;
 846 p_command_xfer_failed:
 847         or      SEQ_FLAGS, NO_CDB_SENT;
 848         jmp     ITloop;
 849
 850
 851 /*
 852  * Status phase.  Wait for the data byte to appear, then read it
 853  * and store it into the SCB.
 854  */
 855 SET_SRC_MODE    M_SCSI;
 856 SET_DST_MODE    M_SCSI;
 857 p_status:
 858         test    SEQ_FLAGS,NOT_IDENTIFIED jnz mesgin_proto_violation;
 859 p_status_okay:
 860         mov     SCB_SCSI_STATUS, SCSIDAT;
 861         or      SCB_CONTROL, STATUS_RCVD;
 862         jmp     ITloop;
 863
 864 /*
 865  * Message out phase.  If MSG_OUT is MSG_IDENTIFYFLAG, build a full
 866  * indentify message sequence and send it to the target.  The host may
 867  * override this behavior by setting the MK_MESSAGE bit in the SCB
 868  * control byte.  This will cause us to interrupt the host and allow
 869  * it to handle the message phase completely on its own.  If the bit
 870  * associated with this target is set, we will also interrupt the host,
 871  * thereby allowing it to send a message on the next selection regardless
 872  * of the transaction being sent.
 873  *
 874  * If MSG_OUT is == HOST_MSG, also interrupt the host and take a message.
 875  * This is done to allow the host to send messages outside of an identify
 876  * sequence while protecting the seqencer from testing the MK_MESSAGE bit
 877  * on an SCB that might not be for the current nexus. (For example, a
 878  * BDR message in responce to a bad reselection would leave us pointed to
 879  * an SCB that doesn't have anything to do with the current target).
 880  *
 881  * Otherwise, treat MSG_OUT as a 1 byte message to send (abort, abort tag,
 882  * bus device reset).
 883  *
 884  * When there are no messages to send, MSG_OUT should be set to MSG_NOOP,
 885  * in case the target decides to put us in this phase for some strange
 886  * reason.
 887  */
 888 p_mesgout_retry:
 889         /* Turn on ATN for the retry */
 890         mvi     SCSISIGO, ATNO;
 891 p_mesgout:
 892         mov     SINDEX, MSG_OUT;
 893         cmp     SINDEX, MSG_IDENTIFYFLAG jne p_mesgout_from_host;
 894         test    SCB_CONTROL,MK_MESSAGE  jnz host_message_loop;
 895 p_mesgout_identify:
 896         or      SINDEX, MSG_IDENTIFYFLAG|DISCENB, SCB_LUN;
 897         test    SCB_CONTROL, DISCENB jnz . + 2;
 898         and     SINDEX, ~DISCENB;
 899 /*
 900  * Send a tag message if TAG_ENB is set in the SCB control block.
 901  * Use SCB_NONPACKET_TAG as the tag value.
 902  */
 903 p_mesgout_tag:
 904         test    SCB_CONTROL,TAG_ENB jz  p_mesgout_onebyte;
 905         mov     SCSIDAT, SINDEX;        /* Send the identify message */
 906         call    phase_lock;
 907         cmp     LASTPHASE, P_MESGOUT    jne p_mesgout_done;
 908         and     SCSIDAT,TAG_ENB|SCB_TAG_TYPE,SCB_CONTROL;
 909         call    phase_lock;
 910         cmp     LASTPHASE, P_MESGOUT    jne p_mesgout_done;
 911         mov     SCBPTR jmp p_mesgout_onebyte;
 912 /*
 913  * Interrupt the driver, and allow it to handle this message
 914  * phase and any required retries.
 915  */
 916 p_mesgout_from_host:
 917         cmp     SINDEX, HOST_MSG        jne p_mesgout_onebyte;
 918         jmp     host_message_loop;
 919
 920 p_mesgout_onebyte:
 921         mvi     CLRSINT1, CLRATNO;
 922         mov     SCSIDAT, SINDEX;
 923
 924 /*
 925  * If the next bus phase after ATN drops is message out, it means
 926  * that the target is requesting that the last message(s) be resent.
 927  */
 928         call    phase_lock;
 929         cmp     LASTPHASE, P_MESGOUT    je p_mesgout_retry;
 930
 931 p_mesgout_done:
 932         mvi     CLRSINT1,CLRATNO;       /* Be sure to turn ATNO off */
 933         mov     LAST_MSG, MSG_OUT;
 934         mvi     MSG_OUT, MSG_NOOP;      /* No message left */
 935         jmp     ITloop;
 936
 937 /*
 938  * Message in phase.  Bytes are read using Automatic PIO mode.
 939  */
 940 p_mesgin:
 941         /* read the 1st message byte */
 942         mvi     ACCUM           call inb_first;
 943
 944         test    A,MSG_IDENTIFYFLAG      jnz mesgin_identify;
 945         cmp     A,MSG_DISCONNECT        je mesgin_disconnect;
 946         cmp     A,MSG_SAVEDATAPOINTER   je mesgin_sdptrs;
 947         cmp     ALLZEROS,A              je mesgin_complete;
 948         cmp     A,MSG_RESTOREPOINTERS   je mesgin_rdptrs;
 949         cmp     A,MSG_IGN_WIDE_RESIDUE  je mesgin_ign_wide_residue;
 950         cmp     A,MSG_NOOP              je mesgin_done;
 951
 952 /*
 953  * Pushed message loop to allow the kernel to
 954  * run it's own message state engine.  To avoid an
 955  * extra nop instruction after signaling the kernel,
 956  * we perform the phase_lock before checking to see
 957  * if we should exit the loop and skip the phase_lock
 958  * in the ITloop.  Performing back to back phase_locks
 959  * shouldn't hurt, but why do it twice...
 960  */
 961 host_message_loop:
 962         call    phase_lock;     /* Benign the first time through. */
 963         SET_SEQINTCODE(HOST_MSG_LOOP)
 964         cmp     RETURN_1, EXIT_MSG_LOOP je ITloop;
 965         cmp     RETURN_1, CONT_MSG_LOOP_WRITE   jne . + 3;
 966         mov     SCSIDAT, RETURN_2;
 967         jmp     host_message_loop;
 968         /* Must be CONT_MSG_LOOP_READ */
 969         mov     NONE, SCSIDAT;  /* ACK Byte */
 970         jmp     host_message_loop;
 971
 972 mesgin_ign_wide_residue:
 973         mov     SAVED_MODE, MODE_PTR;
 974         SET_MODE(M_SCSI, M_SCSI)
 975         shr     NEGOADDR, 4, SAVED_SCSIID;
 976         mov     A, NEGCONOPTS;
 977         RESTORE_MODE(SAVED_MODE)
 978         test    A, WIDEXFER jz mesgin_reject;
 979         /* Pull the residue byte */
 980         mvi     REG0    call inb_next;
 981         cmp     REG0, 0x01 jne mesgin_reject;
 982         test    SCB_RESIDUAL_SGPTR[0], SG_LIST_NULL jz . + 2;
 983         test    SCB_TASK_ATTRIBUTE, SCB_XFERLEN_ODD jnz mesgin_done;
 984         SET_SEQINTCODE(IGN_WIDE_RES)
 985         jmp     mesgin_done;
 986
 987 mesgin_proto_violation:
 988         SET_SEQINTCODE(PROTO_VIOLATION)
 989         jmp     mesgin_done;
 990 mesgin_reject:
 991         mvi     MSG_MESSAGE_REJECT      call mk_mesg;
 992 mesgin_done:
 993         mov     NONE,SCSIDAT;           /*dummy read from latch to ACK*/
 994         jmp     ITloop;
 995
 996 #define INDEX_DISC_LIST(scsiid, lun)                                    \
 997         and     A, 0xC0, scsiid;                                        \
 998         or      SCBPTR, A, lun;                                         \
 999         clr     SCBPTR[1];                                              \
1000         and     SINDEX, 0x30, scsiid;                                   \
1001         shr     SINDEX, 3;      /* Multiply by 2 */                     \
1002         add     SINDEX, (SCB_DISCONNECTED_LISTS & 0xFF);                \
1003         mvi     SINDEX[1], ((SCB_DISCONNECTED_LISTS >> 8) & 0xFF)
1004
1005 mesgin_identify:
1006         /*
1007          * Determine whether a target is using tagged or non-tagged
1008          * transactions by first looking at the transaction stored in
1009          * the per-device, disconnected array.  If there is no untagged
1010          * transaction for this target, this must be a tagged transaction.
1011          */
1012         and     SAVED_LUN, MSG_IDENTIFY_LUNMASK, A;
1013         INDEX_DISC_LIST(SAVED_SCSIID, SAVED_LUN);
1014         bmov    DINDEX, SINDEX, 2;
1015         bmov    REG0, SINDIR, 2;
1016         cmp     REG0[1], SCB_LIST_NULL je snoop_tag;
1017         /* Untagged.  Clear the busy table entry and setup the SCB. */
1018         bmov    DINDIR, ALLONES, 2;
1019         bmov    SCBPTR, REG0, 2;
1020         jmp     setup_SCB;
1021
1022 /*
1023  * Here we "snoop" the bus looking for a SIMPLE QUEUE TAG message.
1024  * If we get one, we use the tag returned to find the proper
1025  * SCB.  After receiving the tag, look for the SCB at SCB locations tag and
1026  * tag + 256.
1027  */
1028 snoop_tag:
1029         if ((ahd->flags & AHD_SEQUENCER_DEBUG) != 0) {
1030                 or      SEQ_FLAGS, 0x80;
1031         }
1032         mov     NONE, SCSIDAT;          /* ACK Identify MSG */
1033         call    phase_lock;
1034         if ((ahd->flags & AHD_SEQUENCER_DEBUG) != 0) {
1035                 or      SEQ_FLAGS, 0x1;
1036         }
1037         cmp     LASTPHASE, P_MESGIN     jne not_found_ITloop;
1038         if ((ahd->flags & AHD_SEQUENCER_DEBUG) != 0) {
1039                 or      SEQ_FLAGS, 0x2;
1040         }
1041         cmp     SCSIBUS, MSG_SIMPLE_Q_TAG jne not_found;
1042 get_tag:
1043         clr     SCBPTR[1];
1044         mvi     SCBPTR  call inb_next;  /* tag value */
1045 verify_scb:
1046         test    SCB_CONTROL,DISCONNECTED jz verify_other_scb;
1047         mov     A, SAVED_SCSIID;
1048         cmp     SCB_SCSIID, A jne verify_other_scb;
1049         mov     A, SAVED_LUN;
1050         cmp     SCB_LUN, A je setup_SCB_disconnected;
1051 verify_other_scb:
1052         xor     SCBPTR[1], 1;
1053         test    SCBPTR[1], 0xFF jnz verify_scb;
1054         jmp     not_found;
1055
1056 /*
1057  * Ensure that the SCB the tag points to is for
1058  * an SCB transaction to the reconnecting target.
1059  */
1060 setup_SCB:
1061         if ((ahd->flags & AHD_SEQUENCER_DEBUG) != 0) {
1062                 or      SEQ_FLAGS, 0x10;
1063         }
1064         test    SCB_CONTROL,DISCONNECTED jz not_found;
1065 setup_SCB_disconnected:
1066         and     SCB_CONTROL,~DISCONNECTED;
1067         clr     SEQ_FLAGS;      /* make note of IDENTIFY */
1068         test    SCB_SGPTR, SG_LIST_NULL jnz . + 3;
1069         bmov    ALLOCFIFO_SCBPTR, SCBPTR, 2;
1070         call    allocate_fifo;
1071         /* See if the host wants to send a message upon reconnection */
1072         test    SCB_CONTROL, MK_MESSAGE jz mesgin_done;
1073         mvi     HOST_MSG        call mk_mesg;
1074         jmp     mesgin_done;
1075
1076 not_found:
1077         SET_SEQINTCODE(NO_MATCH)
1078         jmp     mesgin_done;
1079
1080 not_found_ITloop:
1081         SET_SEQINTCODE(NO_MATCH)
1082         jmp     ITloop;
1083
1084 /*
1085  * We received a "command complete" message.  Put the SCB on the complete
1086  * queue and trigger a completion interrupt via the idle loop.  Before doing
1087  * so, check to see if there is a residual or the status byte is something
1088  * other than STATUS_GOOD (0).  In either of these conditions, we upload the
1089  * SCB back to the host so it can process this information.
1090  */
1091 mesgin_complete:
1092
1093         /*
1094          * If ATN is raised, we still want to give the target a message.
1095          * Perhaps there was a parity error on this last message byte.
1096          * Either way, the target should take us to message out phase
1097          * and then attempt to complete the command again.  We should use a
1098          * critical section here to guard against a timeout triggering
1099          * for this command and setting ATN while we are still processing
1100          * the completion.
1101         test    SCSISIGI, ATNI jnz mesgin_done;
1102          */
1103
1104         /*
1105          * If we are identified and have successfully sent the CDB,
1106          * any status will do.  Optimize this fast path.
1107          */
1108         test    SCB_CONTROL, STATUS_RCVD jz mesgin_proto_violation;
1109         test    SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT jz complete_accepted;
1110
1111         /*
1112          * If the target never sent an identify message but instead went
1113          * to mesgin to give an invalid message, let the host abort us.
1114          */
1115         test    SEQ_FLAGS, NOT_IDENTIFIED jnz mesgin_proto_violation;
1116
1117         /*
1118          * If we recevied good status but never successfully sent the
1119          * cdb, abort the command.
1120          */
1121         test    SCB_SCSI_STATUS,0xff    jnz complete_accepted;
1122         test    SEQ_FLAGS, NO_CDB_SENT jnz mesgin_proto_violation;
1123 complete_accepted:
1124
1125         /*
1126          * See if we attempted to deliver a message but the target ingnored us.
1127          */
1128         test    SCB_CONTROL, MK_MESSAGE jz complete_nomsg;
1129         SET_SEQINTCODE(MKMSG_FAILED)
1130 complete_nomsg:
1131         call    queue_scb_completion;
1132         jmp     await_busfree;
1133
1134 BEGIN_CRITICAL;
1135 freeze_queue:
1136         /* Cancel any pending select-out. */
1137         test    SSTAT0, SELDO|SELINGO jnz . + 2;
1138         and     SCSISEQ0, ~ENSELO;
1139         mov     ACCUM_SAVE, A;
1140         clr     A;
1141         add     QFREEZE_COUNT, 1;
1142         adc     QFREEZE_COUNT[1], A;
1143         or      SEQ_FLAGS2, SELECTOUT_QFROZEN;
1144         mov     A, ACCUM_SAVE ret;
1145 END_CRITICAL;
1146
1147 /*
1148  * Complete the current FIFO's SCB if data for this same
1149  * SCB is not transferring in the other FIFO.
1150  */
1151 SET_SRC_MODE    M_DFF1;
1152 SET_DST_MODE    M_DFF1;
1153 pkt_complete_scb_if_fifos_idle:
1154         bmov    ARG_1, SCBPTR, 2;
1155         mvi     DFFSXFRCTL, CLRCHN;
1156         SET_MODE(M_SCSI, M_SCSI)
1157         bmov    SCBPTR, ARG_1, 2;
1158         test    SCB_FIFO_USE_COUNT, 0xFF jnz return;
1159 queue_scb_completion:
1160         test    SCB_SCSI_STATUS,0xff    jnz bad_status;
1161         /*
1162          * Check for residuals
1163          */
1164         test    SCB_SGPTR, SG_LIST_NULL jnz complete;   /* No xfer */
1165         test    SCB_SGPTR, SG_FULL_RESID jnz upload_scb;/* Never xfered */
1166         test    SCB_RESIDUAL_SGPTR, SG_LIST_NULL jz upload_scb;
1167 complete:
1168 BEGIN_CRITICAL;
1169         bmov    SCB_NEXT_COMPLETE, COMPLETE_SCB_HEAD, 2;
1170         bmov    COMPLETE_SCB_HEAD, SCBPTR, 2 ret;
1171 END_CRITICAL;
1172 bad_status:
1173         cmp     SCB_SCSI_STATUS, STATUS_PKT_SENSE je upload_scb;
1174         call    freeze_queue;
1175 upload_scb:
1176         /*
1177          * Restore SCB TAG since we reuse this field
1178          * in the sequencer.  We don't want to corrupt
1179          * it on the host.
1180          */
1181         bmov    SCB_TAG, SCBPTR, 2;
1182 BEGIN_CRITICAL;
1183         or      SCB_SGPTR, SG_STATUS_VALID;
1184         mvi     SCB_NEXT_COMPLETE[1], SCB_LIST_NULL;
1185         cmp     COMPLETE_DMA_SCB_HEAD[1], SCB_LIST_NULL jne add_dma_scb_tail;
1186         bmov    COMPLETE_DMA_SCB_HEAD, SCBPTR, 2;
1187         bmov    COMPLETE_DMA_SCB_TAIL, SCBPTR, 2 ret;
1188 add_dma_scb_tail:
1189         bmov    REG0, SCBPTR, 2;
1190         bmov    SCBPTR, COMPLETE_DMA_SCB_TAIL, 2;
1191         bmov    SCB_NEXT_COMPLETE, REG0, 2;
1192         bmov    COMPLETE_DMA_SCB_TAIL, REG0, 2 ret;
1193 END_CRITICAL;
1194
1195 /*
1196  * Is it a disconnect message?  Set a flag in the SCB to remind us
1197  * and await the bus going free.  If this is an untagged transaction
1198  * store the SCB id for it in our untagged target table for lookup on
1199  * a reselction.
1200  */
1201 mesgin_disconnect:
1202         /*
1203          * If ATN is raised, we still want to give the target a message.
1204          * Perhaps there was a parity error on this last message byte
1205          * or we want to abort this command.  Either way, the target
1206          * should take us to message out phase and then attempt to
1207          * disconnect again.
1208          * XXX - Wait for more testing.
1209         test    SCSISIGI, ATNI jnz mesgin_done;
1210          */
1211         test    SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT
1212                 jnz mesgin_proto_violation;
1213         or      SCB_CONTROL,DISCONNECTED;
1214         test    SCB_CONTROL, TAG_ENB jnz await_busfree;
1215 queue_disc_scb:
1216         bmov    REG0, SCBPTR, 2;
1217         INDEX_DISC_LIST(SAVED_SCSIID, SAVED_LUN);
1218         bmov    DINDEX, SINDEX, 2;
1219         bmov    DINDIR, REG0, 2;
1220         bmov    SCBPTR, REG0, 2;
1221         /* FALLTHROUGH */
1222 await_busfree:
1223         and     SIMODE1, ~ENBUSFREE;
1224         if ((ahd->bugs & AHD_BUSFREEREV_BUG) == 0) {
1225                 /*
1226                  * In the BUSFREEREV_BUG case, the
1227                  * busfree status was cleared at the
1228                  * beginning of the connection.
1229                  */
1230                 mvi     CLRSINT1,CLRBUSFREE;
1231         }
1232         mov     NONE, SCSIDAT;          /* Ack the last byte */
1233         test    MODE_PTR, ~(MK_MODE(M_DFF1, M_DFF1))
1234                 jnz await_busfree_not_m_dff;
1235 SET_SRC_MODE    M_DFF1;
1236 SET_DST_MODE    M_DFF1;
1237 await_busfree_clrchn:
1238         mvi     DFFSXFRCTL, CLRCHN;
1239 await_busfree_not_m_dff:
1240         /* clear target specific flags */
1241         mvi     SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT;
1242         test    SSTAT1,REQINIT|BUSFREE  jz .;
1243         /*
1244          * We only set BUSFREE status once either a new
1245          * phase has been detected or we are really
1246          * BUSFREE.  This allows the driver to know
1247          * that we are active on the bus even though
1248          * no identified transaction exists should a
1249          * timeout occur while awaiting busfree.
1250          */
1251         mvi     LASTPHASE, P_BUSFREE;
1252         test    SSTAT1, BUSFREE jnz idle_loop;
1253         SET_SEQINTCODE(MISSED_BUSFREE)
1254
1255
1256 /*
1257  * Save data pointers message:
1258  * Copying RAM values back to SCB, for Save Data Pointers message, but
1259  * only if we've actually been into a data phase to change them.  This
1260  * protects against bogus data in scratch ram and the residual counts
1261  * since they are only initialized when we go into data_in or data_out.
1262  * Ack the message as soon as possible.
1263  */
1264 SET_SRC_MODE    M_DFF1;
1265 SET_DST_MODE    M_DFF1;
1266 mesgin_sdptrs:
1267         mov     NONE,SCSIDAT;           /*dummy read from latch to ACK*/
1268         test    SEQ_FLAGS, DPHASE       jz ITloop;
1269         call    save_pointers;
1270         jmp     ITloop;
1271
1272 save_pointers:
1273         /*
1274          * If we are asked to save our position at the end of the
1275          * transfer, just mark us at the end rather than perform a
1276          * full save.
1277          */
1278         test    SCB_RESIDUAL_SGPTR[0], SG_LIST_NULL jz save_pointers_full;
1279         or      SCB_SGPTR, SG_LIST_NULL ret;
1280
1281 save_pointers_full:
1282         /*
1283          * The SCB_DATAPTR becomes the current SHADDR.
1284          * All other information comes directly from our residual
1285          * state.
1286          */
1287         bmov    SCB_DATAPTR, SHADDR, 8;
1288         bmov    SCB_DATACNT, SCB_RESIDUAL_DATACNT, 8 ret;
1289
1290 /*
1291  * Restore pointers message?  Data pointers are recopied from the
1292  * SCB anytime we enter a data phase for the first time, so all
1293  * we need to do is clear the DPHASE flag and let the data phase
1294  * code do the rest.  We also reset/reallocate the FIFO to make
1295  * sure we have a clean start for the next data or command phase.
1296  */
1297 mesgin_rdptrs:
1298         and     SEQ_FLAGS, ~DPHASE;
1299         test    MODE_PTR, ~(MK_MODE(M_DFF1, M_DFF1)) jnz msgin_rdptrs_get_fifo;
1300         mvi     DFFSXFRCTL, RSTCHN|CLRSHCNT;
1301         SET_MODE(M_SCSI, M_SCSI)
1302 msgin_rdptrs_get_fifo:
1303         call    allocate_fifo;
1304         jmp     mesgin_done;
1305
1306 phase_lock:
1307         if ((ahd->bugs & AHD_EARLY_REQ_BUG) != 0) {
1308                 /*
1309                  * Don't ignore persistent REQ assertions just because
1310                  * they were asserted within the bus settle delay window.
1311                  * This allows us to tolerate devices like the GEM318
1312                  * that violate the SCSI spec.  We are careful not to
1313                  * count REQ while we are waiting for it to fall during
1314                  * an async phase due to our asserted ACK.  Each
1315                  * sequencer instruction takes ~25ns, so the REQ must
1316                  * last at least 100ns in order to be counted as a true
1317                  * REQ.
1318                  */
1319                 test    SCSIPHASE, 0xFF jnz phase_locked;
1320                 test    SCSISIGI, ACKI jnz phase_lock;
1321                 test    SCSISIGI, REQI jz phase_lock;
1322                 test    SCSIPHASE, 0xFF jnz phase_locked;
1323                 test    SCSISIGI, ACKI jnz phase_lock;
1324                 test    SCSISIGI, REQI jz phase_lock;
1325 phase_locked:
1326         } else {
1327                 test    SCSIPHASE, 0xFF jz .;
1328         }
1329         test    SSTAT1, SCSIPERR jnz phase_lock;
1330 phase_lock_latch_phase:
1331         and     LASTPHASE, PHASE_MASK, SCSISIGI ret;
1332
1333 /*
1334  * Functions to read data in Automatic PIO mode.
1335  *
1336  * An ACK is not sent on input from the target until SCSIDATL is read from.
1337  * So we wait until SCSIDATL is latched (the usual way), then read the data
1338  * byte directly off the bus using SCSIBUSL.  When we have pulled the ATN
1339  * line, or we just want to acknowledge the byte, then we do a dummy read
1340  * from SCISDATL.  The SCSI spec guarantees that the target will hold the
1341  * data byte on the bus until we send our ACK.
1342  *
1343  * The assumption here is that these are called in a particular sequence,
1344  * and that REQ is already set when inb_first is called.  inb_{first,next}
1345  * use the same calling convention as inb.
1346  */
1347 inb_next:
1348         mov     NONE,SCSIDAT;           /*dummy read from latch to ACK*/
1349 inb_next_wait:
1350         /*
1351          * If there is a parity error, wait for the kernel to
1352          * see the interrupt and prepare our message response
1353          * before continuing.
1354          */
1355         test    SCSIPHASE, 0xFF jz .;
1356         test    SSTAT1, SCSIPERR jnz inb_next_wait;
1357 inb_next_check_phase:
1358         and     LASTPHASE, PHASE_MASK, SCSISIGI;
1359         cmp     LASTPHASE, P_MESGIN jne mesgin_phasemis;
1360 inb_first:
1361         clr     DINDEX[1];
1362         mov     DINDEX,SINDEX;
1363         mov     DINDIR,SCSIBUS  ret;            /*read byte directly from bus*/
1364 inb_last:
1365         mov     NONE,SCSIDAT ret;               /*dummy read from latch to ACK*/
1366
1367 mk_mesg:
1368         mvi     SCSISIGO, ATNO;
1369         mov     MSG_OUT,SINDEX ret;
1370
1371 SET_SRC_MODE    M_DFF1;
1372 SET_DST_MODE    M_DFF1;
1373 disable_ccsgen:
1374         test    SG_STATE, FETCH_INPROG jz disable_ccsgen_fetch_done;
1375         clr     CCSGCTL;
1376 disable_ccsgen_fetch_done:
1377         clr     SG_STATE ret;
1378
1379 service_fifo:
1380         /*
1381          * Do we have any prefetch left???
1382          */
1383         test    SG_STATE, SEGS_AVAIL jnz idle_sg_avail;
1384
1385         /*
1386          * Can this FIFO have access to the S/G cache yet?
1387          */
1388         test    CCSGCTL, SG_CACHE_AVAIL jz return;
1389
1390         /* Did we just finish fetching segs? */
1391         test    CCSGCTL, CCSGDONE jnz idle_sgfetch_complete;
1392
1393         /* Are we actively fetching segments? */
1394         test    CCSGCTL, CCSGENACK jnz return;
1395
1396         /*
1397          * Should the other FIFO get the S/G cache first?  If
1398          * both FIFOs have been allocated since we last checked
1399          * any FIFO, it is important that we service a FIFO
1400          * that is not actively on the bus first.  This guarantees
1401          * that a FIFO will be freed to handle snapshot requests for
1402          * any FIFO that is still on the bus.  Chips with RTI do not
1403          * perform snapshots, so don't bother with this test there.
1404          */
1405         if ((ahd->features & AHD_RTI) == 0) {
1406                 /*
1407                  * If we're not still receiving SCSI data,
1408                  * it is safe to allocate the S/G cache to
1409                  * this FIFO.
1410                  */
1411                 test    DFCNTRL, SCSIEN jz idle_sgfetch_start;
1412
1413                 /*
1414                  * Switch to the other FIFO.  Non-RTI chips
1415                  * also have the "set mode" bug, so we must
1416                  * disable interrupts during the switch.
1417                  */
1418                 mvi     SEQINTCTL, INTVEC1DSL;
1419                 xor     MODE_PTR, MK_MODE(M_DFF1, M_DFF1);
1420
1421                 /*
1422                  * If the other FIFO needs loading, then it
1423                  * must not have claimed the S/G cache yet
1424                  * (SG_CACHE_AVAIL would have been cleared in
1425                  * the orginal FIFO mode and we test this above).
1426                  * Return to the idle loop so we can process the
1427                  * FIFO not currently on the bus first.
1428                  */
1429                 test    SG_STATE, LOADING_NEEDED jz idle_sgfetch_okay;
1430                 clr     SEQINTCTL ret;
1431 idle_sgfetch_okay:
1432                 xor     MODE_PTR, MK_MODE(M_DFF1, M_DFF1);
1433                 clr     SEQINTCTL;
1434         }
1435
1436 idle_sgfetch_start:
1437         /*
1438          * We fetch a "cacheline aligned" and sized amount of data
1439          * so we don't end up referencing a non-existant page.
1440          * Cacheline aligned is in quotes because the kernel will
1441          * set the prefetch amount to a reasonable level if the
1442          * cacheline size is unknown.
1443          */
1444         bmov    SGHADDR, SCB_RESIDUAL_SGPTR, 4;
1445         mvi     SGHCNT, SG_PREFETCH_CNT;
1446         if ((ahd->bugs & AHD_REG_SLOW_SETTLE_BUG) != 0) {
1447                 /*
1448                  * Need two instructions between "touches" of SGHADDR.
1449                  */
1450                 nop;
1451         }
1452         and     SGHADDR[0], SG_PREFETCH_ALIGN_MASK, SCB_RESIDUAL_SGPTR;
1453         mvi     CCSGCTL, CCSGEN|CCSGRESET;
1454         or      SG_STATE, FETCH_INPROG ret;
1455 idle_sgfetch_complete:
1456         /*
1457          * Guard against SG_CACHE_AVAIL activating during sg fetch
1458          * request in the other FIFO.
1459          */
1460         test    SG_STATE, FETCH_INPROG jz return;
1461         clr     CCSGCTL;
1462         and     CCSGADDR, SG_PREFETCH_ADDR_MASK, SCB_RESIDUAL_SGPTR;
1463         mvi     SG_STATE, SEGS_AVAIL|LOADING_NEEDED;
1464 idle_sg_avail:
1465         /* Does the hardware have space for another SG entry? */
1466         test    DFSTATUS, PRELOAD_AVAIL jz return;
1467         /*
1468          * On the A, preloading a segment before HDMAENACK
1469          * comes true can clobber the shaddow address of the
1470          * first segment in the S/G FIFO.  Wait until it is
1471          * safe to proceed.
1472          */
1473         if ((ahd->features & AHD_NEW_DFCNTRL_OPTS) == 0) {
1474                 test    DFCNTRL, HDMAENACK jz return;
1475         }
1476         if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0) {
1477                 bmov    HADDR, CCSGRAM, 8;
1478         } else {
1479                 bmov    HADDR, CCSGRAM, 4;
1480         }
1481         bmov    HCNT, CCSGRAM, 3;
1482         bmov    SCB_RESIDUAL_DATACNT[3], CCSGRAM, 1;
1483         if ((ahd->flags & AHD_39BIT_ADDRESSING) != 0) {
1484                 and     HADDR[4], SG_HIGH_ADDR_BITS, SCB_RESIDUAL_DATACNT[3];
1485         }
1486         if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0) {
1487                 /* Skip 4 bytes of pad. */
1488                 add     CCSGADDR, 4;
1489         }
1490 sg_advance:
1491         clr     A;                      /* add sizeof(struct scatter) */
1492         add     SCB_RESIDUAL_SGPTR[0],SG_SIZEOF;
1493         adc     SCB_RESIDUAL_SGPTR[1],A;
1494         adc     SCB_RESIDUAL_SGPTR[2],A;
1495         adc     SCB_RESIDUAL_SGPTR[3],A;
1496         mov     SINDEX, SCB_RESIDUAL_SGPTR[0];
1497         test    SCB_RESIDUAL_DATACNT[3], SG_LAST_SEG jz . + 3;
1498         or      SINDEX, LAST_SEG;
1499         clr     SG_STATE;
1500         mov     SG_CACHE_PRE, SINDEX;
1501         if ((ahd->features & AHD_NEW_DFCNTRL_OPTS) != 0) {
1502                 /*
1503                  * Use SCSIENWRDIS so that SCSIEN is never
1504                  * modified by this operation.
1505                  */
1506                 or      DFCNTRL, PRELOADEN|HDMAEN|SCSIENWRDIS;
1507         } else {
1508                 or      DFCNTRL, PRELOADEN|HDMAEN;
1509         }
1510         /*
1511          * Do we have another segment in the cache?
1512          */
1513         add     NONE, SG_PREFETCH_CNT_LIMIT, CCSGADDR;
1514         jnc     return;
1515         and     SG_STATE, ~SEGS_AVAIL ret;
1516
1517 /*
1518  * Initialize the DMA address and counter from the SCB.
1519  */
1520 load_first_seg:
1521         bmov    HADDR, SCB_DATAPTR, 11;
1522         and     REG_ISR, ~SG_FULL_RESID, SCB_SGPTR[0];
1523         test    SCB_DATACNT[3], SG_LAST_SEG jz . + 2;
1524         or      REG_ISR, LAST_SEG;
1525         mov     SG_CACHE_PRE, REG_ISR;
1526         mvi     DFCNTRL, (PRELOADEN|SCSIEN|HDMAEN);
1527         /*
1528          * Since we've are entering a data phase, we will
1529          * rely on the SCB_RESID* fields.  Initialize the
1530          * residual and clear the full residual flag.
1531          */
1532         and     SCB_SGPTR[0], ~SG_FULL_RESID;
1533         bmov    SCB_RESIDUAL_DATACNT[3], SCB_DATACNT[3], 5;
1534         /* If we need more S/G elements, tell the idle loop */
1535         test    SCB_RESIDUAL_DATACNT[3], SG_LAST_SEG jnz . + 2;
1536         mvi     SG_STATE, LOADING_NEEDED ret;
1537         clr     SG_STATE ret;
1538
1539 p_data_handle_xfer:
1540         call    setjmp;
1541         test    SG_STATE, LOADING_NEEDED jnz service_fifo;
1542 p_data_clear_handler:
1543         or      LONGJMP_ADDR[1], INVALID_ADDR ret;
1544
1545 p_data:
1546         test    SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT   jz p_data_allowed;
1547         SET_SEQINTCODE(PROTO_VIOLATION)
1548 p_data_allowed:
1549
1550         test    SEQ_FLAGS, DPHASE       jz data_phase_initialize;
1551
1552         /*
1553          * If we re-enter the data phase after going through another
1554          * phase, our transfer location has almost certainly been
1555          * corrupted by the interveining, non-data, transfers.  Ask
1556          * the host driver to fix us up based on the transfer residual
1557          * unless we already know that we should be bitbucketing.
1558          */
1559         test    SCB_RESIDUAL_SGPTR[0], SG_LIST_NULL jnz p_data_bitbucket;
1560         SET_SEQINTCODE(PDATA_REINIT)
1561         jmp     data_phase_inbounds;
1562
1563 p_data_bitbucket:
1564         /*
1565          * Turn on `Bit Bucket' mode, wait until the target takes
1566          * us to another phase, and then notify the host.
1567          */
1568         mov     SAVED_MODE, MODE_PTR;
1569         test    MODE_PTR, ~(MK_MODE(M_DFF1, M_DFF1))
1570                 jnz bitbucket_not_m_dff;
1571         /*
1572          * Ensure that any FIFO contents are cleared out and the
1573          * FIFO free'd prior to starting the BITBUCKET.  BITBUCKET
1574          * doesn't discard data already in the FIFO.
1575          */
1576         mvi     DFFSXFRCTL, RSTCHN|CLRSHCNT;
1577         SET_MODE(M_SCSI, M_SCSI)
1578 bitbucket_not_m_dff:
1579         or      SXFRCTL1,BITBUCKET;
1580         /* Wait for non-data phase. */
1581         test    SCSIPHASE, ~DATA_PHASE_MASK jz .;
1582         and     SXFRCTL1, ~BITBUCKET;
1583         RESTORE_MODE(SAVED_MODE)
1584 SET_SRC_MODE    M_DFF1;
1585 SET_DST_MODE    M_DFF1;
1586         SET_SEQINTCODE(DATA_OVERRUN)
1587         jmp     ITloop;
1588
1589 data_phase_initialize:
1590         test    SCB_SGPTR[0], SG_LIST_NULL jnz p_data_bitbucket;
1591         call    load_first_seg;
1592 data_phase_inbounds:
1593         /* We have seen a data phase at least once. */
1594         or      SEQ_FLAGS, DPHASE;
1595         mov     SAVED_MODE, MODE_PTR;
1596         test    SG_STATE, LOADING_NEEDED jz data_group_dma_loop;
1597         call    p_data_handle_xfer;
1598 data_group_dma_loop:
1599         /*
1600          * The transfer is complete if either the last segment
1601          * completes or the target changes phase.  Both conditions
1602          * will clear SCSIEN.
1603          */
1604         call    idle_loop_service_fifos;
1605         call    idle_loop_cchan;
1606         call    idle_loop_gsfifo;
1607         RESTORE_MODE(SAVED_MODE)
1608         test    DFCNTRL, SCSIEN jnz data_group_dma_loop;
1609
1610 data_group_dmafinish:
1611         /*
1612          * The transfer has terminated either due to a phase
1613          * change, and/or the completion of the last segment.
1614          * We have two goals here.  Do as much other work
1615          * as possible while the data fifo drains on a read
1616          * and respond as quickly as possible to the standard
1617          * messages (save data pointers/disconnect and command
1618          * complete) that usually follow a data phase.
1619          */
1620         call    calc_residual;
1621
1622         /*
1623          * Go ahead and shut down the DMA engine now.
1624          */
1625         test    DFCNTRL, DIRECTION jnz data_phase_finish;
1626 data_group_fifoflush:
1627         if ((ahd->bugs & AHD_AUTOFLUSH_BUG) != 0) {
1628                 or      DFCNTRL, FIFOFLUSH;
1629         }
1630         /*
1631          * We have enabled the auto-ack feature.  This means
1632          * that the controller may have already transferred
1633          * some overrun bytes into the data FIFO and acked them
1634          * on the bus.  The only way to detect this situation is
1635          * to wait for LAST_SEG_DONE to come true on a completed
1636          * transfer and then test to see if the data FIFO is
1637          * non-empty.  We know there is more data yet to transfer
1638          * if SG_LIST_NULL is not yet set, thus there cannot be
1639          * an overrun.
1640          */
1641         test    SCB_RESIDUAL_SGPTR[0], SG_LIST_NULL jz data_phase_finish;
1642         test    SG_CACHE_SHADOW, LAST_SEG_DONE jz .;
1643         test    DFSTATUS, FIFOEMP jnz data_phase_finish;
1644         /* Overrun */
1645         jmp     p_data;
1646 data_phase_finish:
1647         /*
1648          * If the target has left us in data phase, loop through
1649          * the dma code again.  We will only loop if there is a
1650          * data overrun.
1651          */
1652         if ((ahd->flags & AHD_TARGETROLE) != 0) {
1653                 test    SSTAT0, TARGET jnz data_phase_done;
1654         }
1655         if ((ahd->flags & AHD_INITIATORROLE) != 0) {
1656                 test    SSTAT1, REQINIT jz .;
1657                 test    SCSIPHASE, DATA_PHASE_MASK jnz p_data;
1658         }
1659
1660 data_phase_done:
1661         /* Kill off any pending prefetch */
1662         call    disable_ccsgen;
1663         or      LONGJMP_ADDR[1], INVALID_ADDR;
1664
1665         if ((ahd->flags & AHD_TARGETROLE) != 0) {
1666                 test    SEQ_FLAGS, DPHASE_PENDING jz ITloop;
1667                 /*
1668                 and     SEQ_FLAGS, ~DPHASE_PENDING;
1669                  * For data-in phases, wait for any pending acks from the
1670                  * initiator before changing phase.  We only need to
1671                  * send Ignore Wide Residue messages for data-in phases.
1672                 test    DFCNTRL, DIRECTION jz target_ITloop;
1673                 test    SSTAT1, REQINIT jnz .;
1674                 test    SCB_TASK_ATTRIBUTE, SCB_XFERLEN_ODD jz target_ITloop;
1675                 SET_MODE(M_SCSI, M_SCSI)
1676                 test    NEGCONOPTS, WIDEXFER jz target_ITloop;
1677                  */
1678                 /*
1679                  * Issue an Ignore Wide Residue Message.
1680                 mvi     P_MESGIN|BSYO call change_phase;
1681                 mvi     MSG_IGN_WIDE_RESIDUE call target_outb;
1682                 mvi     1 call target_outb;
1683                 jmp     target_ITloop;
1684                  */
1685         } else {
1686                 jmp     ITloop;
1687         }
1688
1689 /*
1690  * We assume that, even though data may still be
1691  * transferring to the host, that the SCSI side of
1692  * the DMA engine is now in a static state.  This
1693  * allows us to update our notion of where we are
1694  * in this transfer.
1695  *
1696  * If, by chance, we stopped before being able
1697  * to fetch additional segments for this transfer,
1698  * yet the last S/G was completely exhausted,
1699  * call our idle loop until it is able to load
1700  * another segment.  This will allow us to immediately
1701  * pickup on the next segment on the next data phase.
1702  *
1703  * If we happened to stop on the last segment, then
1704  * our residual information is still correct from
1705  * the idle loop and there is no need to perform
1706  * any fixups.
1707  */
1708 residual_before_last_seg:
1709         test    MDFFSTAT, SHVALID       jnz sgptr_fixup;
1710         /*
1711          * Can never happen from an interrupt as the packetized
1712          * hardware will only interrupt us once SHVALID or
1713          * LAST_SEG_DONE.
1714          */
1715         call    idle_loop_service_fifos;
1716         RESTORE_MODE(SAVED_MODE)
1717         /* FALLTHROUGH */
1718 calc_residual:
1719         test    SG_CACHE_SHADOW, LAST_SEG jz residual_before_last_seg;
1720         /* Record if we've consumed all S/G entries */
1721         test    MDFFSTAT, SHVALID       jz . + 2;
1722         bmov    SCB_RESIDUAL_DATACNT, SHCNT, 3 ret;
1723         or      SCB_RESIDUAL_SGPTR[0], SG_LIST_NULL ret;
1724
1725 sgptr_fixup:
1726         /*
1727          * Fixup the residual next S/G pointer.  The S/G preload
1728          * feature of the chip allows us to load two elements
1729          * in addition to the currently active element.  We
1730          * store the bottom byte of the next S/G pointer in
1731          * the SG_CACHE_PTR register so we can restore the
1732          * correct value when the DMA completes.  If the next
1733          * sg ptr value has advanced to the point where higher
1734          * bytes in the address have been affected, fix them
1735          * too.
1736          */
1737         test    SG_CACHE_SHADOW, 0x80 jz sgptr_fixup_done;
1738         test    SCB_RESIDUAL_SGPTR[0], 0x80 jnz sgptr_fixup_done;
1739         add     SCB_RESIDUAL_SGPTR[1], -1;
1740         adc     SCB_RESIDUAL_SGPTR[2], -1;
1741         adc     SCB_RESIDUAL_SGPTR[3], -1;
1742 sgptr_fixup_done:
1743         and     SCB_RESIDUAL_SGPTR[0], SG_ADDR_MASK, SG_CACHE_SHADOW;
1744         clr     SCB_RESIDUAL_DATACNT[3]; /* We are not the last seg */
1745         bmov    SCB_RESIDUAL_DATACNT, SHCNT, 3 ret;
1746
1747 export timer_isr:
1748         call    issue_cmdcmplt;
1749         mvi     CLRSEQINTSTAT, CLRSEQ_SWTMRTO;
1750         if ((ahd->bugs & AHD_SET_MODE_BUG) != 0) {
1751                 /*
1752                  * In H2A4, the mode pointer is not saved
1753                  * for intvec2, but is restored on iret.
1754                  * This can lead to the restoration of a
1755                  * bogus mode ptr.  Manually clear the
1756                  * intmask bits and do a normal return
1757                  * to compensate.
1758                  */
1759                 and     SEQINTCTL, ~(INTMASK2|INTMASK1) ret;
1760         } else {
1761                 or      SEQINTCTL, IRET ret;
1762         }
1763
1764 export seq_isr:
1765         if ((ahd->features & AHD_RTI) == 0) {
1766                 /*
1767                  * On RevA Silicon, if the target returns us to data-out
1768                  * after we have already trained for data-out, it is
1769                  * possible for us to transition the free running clock to
1770                  * data-valid before the required 100ns P1 setup time (8 P1
1771                  * assertions in fast-160 mode).  This will only happen if
1772                  * this L-Q is a continuation of a data transfer for which
1773                  * we have already prefetched data into our FIFO (LQ/Data
1774                  * followed by LQ/Data for the same write transaction).
1775                  * This can cause some target implementations to miss the
1776                  * first few data transfers on the bus.  We detect this
1777                  * situation by noticing that this is the first data transfer
1778                  * after an LQ (LQIWORKONLQ true), that the data transfer is
1779                  * a continuation of a transfer already setup in our FIFO
1780                  * (SAVEPTRS interrupt), and that the transaction is a write
1781                  * (DIRECTION set in DFCNTRL). The delay is performed by
1782                  * disabling SCSIEN until we see the first REQ from the
1783                  * target.
1784                  *
1785                  * First instruction in an ISR cannot be a branch on
1786                  * Rev A.  Snapshot LQISTAT2 so the status is not missed
1787                  * and deffer the test by one instruction.
1788                  */
1789                 mov     REG_ISR, LQISTAT2;
1790                 test    REG_ISR, LQIWORKONLQ jz main_isr;
1791                 test    SEQINTSRC, SAVEPTRS  jz main_isr;
1792                 test    LONGJMP_ADDR[1], INVALID_ADDR jz saveptr_active_fifo;
1793                 /*
1794                  * Switch to the active FIFO after clearing the snapshot
1795                  * savepointer in the current FIFO.  We do this so that
1796                  * a pending CTXTDONE or SAVEPTR is visible in the active
1797                  * FIFO.  This status is the only way we can detect if we
1798                  * have lost the race (e.g. host paused us) and our attempts
1799                  * to disable the channel occurred after all REQs were
1800                  * already seen and acked (REQINIT never comes true).
1801                  */
1802                 mvi     DFFSXFRCTL, CLRCHN;
1803                 xor     MODE_PTR, MK_MODE(M_DFF1, M_DFF1);
1804                 test    DFCNTRL, DIRECTION jz interrupt_return;
1805                 and     DFCNTRL, ~SCSIEN;
1806 snapshot_wait_data_valid:
1807                 test    SEQINTSRC, (CTXTDONE|SAVEPTRS) jnz interrupt_return;
1808                 test    SSTAT1, REQINIT jz snapshot_wait_data_valid;
1809 snapshot_data_valid:
1810                 or      DFCNTRL, SCSIEN;
1811                 or      SEQINTCTL, IRET ret;
1812 snapshot_saveptr:
1813                 mvi     DFFSXFRCTL, CLRCHN;
1814                 or      SEQINTCTL, IRET ret;
1815 main_isr:
1816         }
1817         test    SEQINTSRC, CFG4DATA     jnz cfg4data_intr;
1818         test    SEQINTSRC, CFG4ISTAT    jnz cfg4istat_intr;
1819         test    SEQINTSRC, SAVEPTRS     jnz saveptr_intr;
1820         test    SEQINTSRC, CFG4ICMD     jnz cfg4icmd_intr;
1821         SET_SEQINTCODE(INVALID_SEQINT)
1822
1823 /*
1824  * There are two types of save pointers interrupts:
1825  * The first is a snapshot save pointers where the current FIFO is not
1826  * active and contains a snapshot of the current poniter information.
1827  * This happens between packets in a stream for a single L_Q.  Since we
1828  * are not performing a pointer save, we can safely clear the channel
1829  * so it can be used for other transactions.  On RTI capable controllers,
1830  * where snapshots can, and are, disabled, the code to handle this type
1831  * of snapshot is not active.
1832  *
1833  * The second case is a save pointers on an active FIFO which occurs
1834  * if the target changes to a new L_Q or busfrees/QASes and the transfer
1835  * has a residual.  This should occur coincident with a ctxtdone.  We
1836  * disable the interrupt and allow our active routine to handle the
1837  * save.
1838  */
1839 saveptr_intr:
1840         if ((ahd->features & AHD_RTI) == 0) {
1841                 test    LONGJMP_ADDR[1], INVALID_ADDR jnz snapshot_saveptr;
1842         }
1843 saveptr_active_fifo:
1844         and     SEQIMODE, ~ENSAVEPTRS;
1845         or      SEQINTCTL, IRET ret;
1846
1847 cfg4data_intr:
1848         test    SCB_SGPTR[0], SG_LIST_NULL jnz pkt_handle_overrun_inc_use_count;
1849         call    load_first_seg;
1850         call    pkt_handle_xfer;
1851         inc     SCB_FIFO_USE_COUNT;
1852 interrupt_return:
1853         or      SEQINTCTL, IRET ret;
1854
1855 cfg4istat_intr:
1856         call    freeze_queue;
1857         add     NONE, -13, SCB_CDB_LEN;
1858         jnc     cfg4istat_have_sense_addr;
1859         test    SCB_CDB_LEN, SCB_CDB_LEN_PTR jnz cfg4istat_have_sense_addr;
1860         /*
1861          * Host sets up address/count and enables transfer.
1862          */
1863         SET_SEQINTCODE(CFG4ISTAT_INTR)
1864         jmp     cfg4istat_setup_handler;
1865 cfg4istat_have_sense_addr:
1866         bmov    HADDR, SCB_SENSE_BUSADDR, 4;
1867         mvi     HCNT[1], (AHD_SENSE_BUFSIZE >> 8);
1868         mvi     SG_CACHE_PRE, LAST_SEG;
1869         mvi     DFCNTRL, PRELOADEN|SCSIEN|HDMAEN;
1870 cfg4istat_setup_handler:
1871         /*
1872          * Status pkt is transferring to host.
1873          * Wait in idle loop for transfer to complete.
1874          * If a command completed before an attempted
1875          * task management function completed, notify the host.
1876          */
1877         test    SCB_TASK_MANAGEMENT, 0xFF jz cfg4istat_no_taskmgmt_func;
1878         SET_SEQINTCODE(TASKMGMT_CMD_CMPLT_OKAY)
1879 cfg4istat_no_taskmgmt_func:
1880         call    pkt_handle_status;
1881         or      SEQINTCTL, IRET ret;
1882
1883 cfg4icmd_intr:
1884         /*
1885          * In the case of DMAing a CDB from the host, the normal
1886          * CDB buffer is formatted with an 8 byte address followed
1887          * by a 1 byte count.
1888          */
1889         bmov    HADDR[0], SCB_HOST_CDB_PTR, 9;
1890         mvi     SG_CACHE_PRE, LAST_SEG;
1891         mvi     DFCNTRL, (PRELOADEN|SCSIEN|HDMAEN);
1892         call    pkt_handle_cdb;
1893         or      SEQINTCTL, IRET ret;
1894
1895 /*
1896  * See if the target has gone on in this context creating an
1897  * overrun condition.  For the write case, the hardware cannot
1898  * ack bytes until data are provided.  So, if the target begins
1899  * another  packet without changing contexts, implying we are
1900  * not sitting on a packet boundary, we are in an overrun
1901  * situation.  For the read case, the hardware will continue to
1902  * ack bytes into the FIFO, and may even ack the last overrun packet
1903  * into the FIFO.   If the FIFO should become non-empty, we are in
1904  * a read overrun case.
1905  */
1906 #define check_overrun                                                   \
1907         /* Not on a packet boundary. */                                 \
1908         test    MDFFSTAT, DLZERO jz pkt_handle_overrun;                 \
1909         test    DFSTATUS, FIFOEMP jz pkt_handle_overrun
1910
1911 pkt_handle_xfer:
1912         test    SG_STATE, LOADING_NEEDED jz pkt_last_seg;
1913         call    setjmp;
1914         test    SEQINTSRC, SAVEPTRS jnz pkt_saveptrs;
1915         test    SCSIPHASE, ~DATA_PHASE_MASK jz . + 2;
1916         test    SCSISIGO, ATNO jnz . + 2;
1917         test    SSTAT2, NONPACKREQ jz pkt_service_fifo;
1918         /*
1919          * Defer handling of this NONPACKREQ until we
1920          * can be sure it pertains to this FIFO.  SAVEPTRS
1921          * will not be asserted if the NONPACKREQ is for us,
1922          * so we must simulate it if shaddow is valid.  If
1923          * shaddow is not valid, keep running this FIFO until we
1924          * have satisfied the transfer by loading segments and
1925          * waiting for either shaddow valid or last_seg_done.
1926          */
1927         test    MDFFSTAT, SHVALID jnz pkt_saveptrs;
1928 pkt_service_fifo:
1929         test    SG_STATE, LOADING_NEEDED jnz service_fifo;
1930 pkt_last_seg:
1931         call    setjmp;
1932         test    SEQINTSRC, SAVEPTRS jnz pkt_saveptrs;
1933         test    SG_CACHE_SHADOW, LAST_SEG_DONE jnz pkt_last_seg_done;
1934         test    SCSIPHASE, ~DATA_PHASE_MASK jz . + 2;
1935         test    SCSISIGO, ATNO jnz . + 2;
1936         test    SSTAT2, NONPACKREQ jz return;
1937         test    MDFFSTAT, SHVALID jz return;
1938         /* FALLTHROUGH */
1939
1940 /*
1941  * Either a SAVEPTRS interrupt condition is pending for this FIFO
1942  * or we have a pending NONPACKREQ for this FIFO.  We differentiate
1943  * between the two by capturing the state of the SAVEPTRS interrupt
1944  * prior to clearing this status and executing the common code for
1945  * these two cases.
1946  */
1947 pkt_saveptrs:
1948 BEGIN_CRITICAL;
1949         if ((ahd->bugs & AHD_AUTOFLUSH_BUG) != 0) {
1950                 or      DFCNTRL, FIFOFLUSH;
1951         }
1952         mov     REG0, SEQINTSRC;
1953         call    calc_residual;
1954         call    save_pointers;
1955         mvi     CLRSEQINTSRC, CLRSAVEPTRS;
1956         call    disable_ccsgen;
1957         or      SEQIMODE, ENSAVEPTRS;
1958         test    DFCNTRL, DIRECTION jnz pkt_saveptrs_check_status;
1959         test    DFSTATUS, FIFOEMP jnz pkt_saveptrs_check_status;
1960         /*
1961          * Keep a handler around for this FIFO until it drains
1962          * to the host to guarantee that we don't complete the
1963          * command to the host before the data arrives.
1964          */
1965 pkt_saveptrs_wait_fifoemp:
1966         call    setjmp;
1967         test    DFSTATUS, FIFOEMP jz return;
1968 pkt_saveptrs_check_status:
1969         or      LONGJMP_ADDR[1], INVALID_ADDR;
1970         test    REG0, SAVEPTRS jz unexpected_nonpkt_phase;
1971         dec     SCB_FIFO_USE_COUNT;
1972         test    SCB_CONTROL, STATUS_RCVD jnz pkt_complete_scb_if_fifos_idle;
1973         mvi     DFFSXFRCTL, CLRCHN ret;
1974
1975 /*
1976  * LAST_SEG_DONE status has been seen in the current FIFO.
1977  * This indicates that all of the allowed data for this
1978  * command has transferred across the SCSI and host buses.
1979  * Check for overrun and see if we can complete this command.
1980  */
1981 pkt_last_seg_done:
1982         /*
1983          * Mark transfer as completed.
1984          */
1985         or      SCB_SGPTR, SG_LIST_NULL;
1986
1987         /*
1988          * Wait for the current context to finish to verify that
1989          * no overrun condition has occurred.
1990          */
1991         test    SEQINTSRC, CTXTDONE jnz pkt_ctxt_done;
1992         call    setjmp;
1993 pkt_wait_ctxt_done_loop:
1994         test    SEQINTSRC, CTXTDONE jnz pkt_ctxt_done;
1995         /*
1996          * A sufficiently large overrun or a NONPACKREQ may
1997          * prevent CTXTDONE from ever asserting, so we must
1998          * poll for these statuses too.
1999          */
2000         check_overrun;
2001         test    SSTAT2, NONPACKREQ jz return;
2002         test    SEQINTSRC, CTXTDONE jz unexpected_nonpkt_phase;
2003         /* FALLTHROUGH */
2004
2005 pkt_ctxt_done:
2006         check_overrun;
2007         or      LONGJMP_ADDR[1], INVALID_ADDR;
2008         /*
2009          * If status has been received, it is safe to skip
2010          * the check to see if another FIFO is active because
2011          * LAST_SEG_DONE has been observed.  However, we check
2012          * the FIFO anyway since it costs us only one extra
2013          * instruction to leverage common code to perform the
2014          * SCB completion.
2015          */
2016         dec     SCB_FIFO_USE_COUNT;
2017         test    SCB_CONTROL, STATUS_RCVD jnz pkt_complete_scb_if_fifos_idle;
2018         mvi     DFFSXFRCTL, CLRCHN ret;
2019 END_CRITICAL;
2020
2021 /*
2022  * Must wait until CDB xfer is over before issuing the
2023  * clear channel.
2024  */
2025 pkt_handle_cdb:
2026         call    setjmp;
2027         test    SG_CACHE_SHADOW, LAST_SEG_DONE jz return;
2028         or      LONGJMP_ADDR[1], INVALID_ADDR;
2029         mvi     DFFSXFRCTL, CLRCHN ret;
2030
2031 /*
2032  * Watch over the status transfer.  Our host sense buffer is
2033  * large enough to take the maximum allowed status packet.
2034  * None-the-less, we must still catch and report overruns to
2035  * the host.  Additionally, properly catch unexpected non-packet
2036  * phases that are typically caused by CRC errors in status packet
2037  * transmission.
2038  */
2039 pkt_handle_status:
2040         call    setjmp;
2041         test    SG_CACHE_SHADOW, LAST_SEG_DONE jnz pkt_status_check_overrun;
2042         test    SEQINTSRC, CTXTDONE jz pkt_status_check_nonpackreq;
2043         test    SG_CACHE_SHADOW, LAST_SEG_DONE jnz pkt_status_check_overrun;
2044 pkt_status_IU_done:
2045         if ((ahd->bugs & AHD_AUTOFLUSH_BUG) != 0) {
2046                 or      DFCNTRL, FIFOFLUSH;
2047         }
2048         test    DFSTATUS, FIFOEMP jz return;
2049 BEGIN_CRITICAL;
2050         or      LONGJMP_ADDR[1], INVALID_ADDR;
2051         mvi     SCB_SCSI_STATUS, STATUS_PKT_SENSE;
2052         or      SCB_CONTROL, STATUS_RCVD;
2053         jmp     pkt_complete_scb_if_fifos_idle;
2054 END_CRITICAL;
2055 pkt_status_check_overrun:
2056         /*
2057          * Status PKT overruns are uncerimoniously recovered with a
2058          * bus reset.  If we've overrun, let the host know so that
2059          * recovery can be performed.
2060          *
2061          * LAST_SEG_DONE has been observed.  If either CTXTDONE or
2062          * a NONPACKREQ phase change have occurred and the FIFO is
2063          * empty, there is no overrun.
2064          */
2065         test    DFSTATUS, FIFOEMP jz pkt_status_report_overrun;
2066         test    SEQINTSRC, CTXTDONE jz . + 2;
2067         test    DFSTATUS, FIFOEMP jnz pkt_status_IU_done;
2068         test    SCSIPHASE, ~DATA_PHASE_MASK jz return;
2069         test    DFSTATUS, FIFOEMP jnz pkt_status_check_nonpackreq;
2070 pkt_status_report_overrun:
2071         SET_SEQINTCODE(STATUS_OVERRUN)
2072         /* SEQUENCER RESTARTED */
2073 pkt_status_check_nonpackreq:
2074         /*
2075          * CTXTDONE may be held off if a NONPACKREQ is associated with
2076          * the current context.  If a NONPACKREQ is observed, decide
2077          * if it is for the current context.  If it is for the current
2078          * context, we must defer NONPACKREQ processing until all data
2079          * has transferred to the host.
2080          */
2081         test    SCSIPHASE, ~DATA_PHASE_MASK jz return;
2082         test    SCSISIGO, ATNO jnz . + 2;
2083         test    SSTAT2, NONPACKREQ jz return;
2084         test    SEQINTSRC, CTXTDONE jnz pkt_status_IU_done;
2085         test    DFSTATUS, FIFOEMP jz return;
2086         /*
2087          * The unexpected nonpkt phase handler assumes that any
2088          * data channel use will have a FIFO reference count.  It
2089          * turns out that the status handler doesn't need a refernce
2090          * count since the status received flag, and thus completion
2091          * processing, cannot be set until the handler is finished.
2092          * We increment the count here to make the nonpkt handler
2093          * happy.
2094          */
2095         inc     SCB_FIFO_USE_COUNT;
2096         /* FALLTHROUGH */
2097
2098 /*
2099  * Nonpackreq is a polled status.  It can come true in three situations:
2100  * we have received an L_Q, we have sent one or more L_Qs, or there is no
2101  * L_Q context associated with this REQ (REQ occurs immediately after a
2102  * (re)selection).  Routines that know that the context responsible for this
2103  * nonpackreq call directly into unexpected_nonpkt_phase.  In the case of the
2104  * top level idle loop, we exhaust all active contexts prior to determining that
2105  * we simply do not have the full I_T_L_Q for this phase.
2106  */
2107 unexpected_nonpkt_phase_find_ctxt:
2108         /*
2109          * This nonpackreq is most likely associated with one of the tags
2110          * in a FIFO or an outgoing LQ.  Only treat it as an I_T only
2111          * nonpackreq if we've cleared out the FIFOs and handled any
2112          * pending SELDO.
2113          */
2114 SET_SRC_MODE    M_SCSI;
2115 SET_DST_MODE    M_SCSI;
2116         and     A, FIFO1FREE|FIFO0FREE, DFFSTAT;
2117         cmp     A, FIFO1FREE|FIFO0FREE jne return;
2118         test    SSTAT0, SELDO jnz return;
2119         mvi     SCBPTR[1], SCB_LIST_NULL;
2120 unexpected_nonpkt_phase:
2121         test    MODE_PTR, ~(MK_MODE(M_DFF1, M_DFF1))
2122                 jnz unexpected_nonpkt_mode_cleared;
2123 SET_SRC_MODE    M_DFF0;
2124 SET_DST_MODE    M_DFF0;
2125         or      LONGJMP_ADDR[1], INVALID_ADDR;
2126         dec     SCB_FIFO_USE_COUNT;
2127         mvi     DFFSXFRCTL, CLRCHN;
2128 unexpected_nonpkt_mode_cleared:
2129         mvi     CLRSINT2, CLRNONPACKREQ;
2130         test    SCSIPHASE, ~(MSG_IN_PHASE|MSG_OUT_PHASE) jnz illegal_phase;
2131         SET_SEQINTCODE(ENTERING_NONPACK)
2132         jmp     ITloop;
2133
2134 illegal_phase:
2135         SET_SEQINTCODE(ILLEGAL_PHASE)
2136         jmp     ITloop;
2137
2138 /*
2139  * We have entered an overrun situation.  If we have working
2140  * BITBUCKET, flip that on and let the hardware eat any overrun
2141  * data.  Otherwise use an overrun buffer in the host to simulate
2142  * BITBUCKET.
2143  */
2144 pkt_handle_overrun_inc_use_count:
2145         inc     SCB_FIFO_USE_COUNT;
2146 pkt_handle_overrun:
2147         SET_SEQINTCODE(CFG4OVERRUN)
2148         call    freeze_queue;
2149         if ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) == 0) {
2150                 or      DFFSXFRCTL, DFFBITBUCKET;
2151 SET_SRC_MODE    M_DFF1;
2152 SET_DST_MODE    M_DFF1;
2153         } else {
2154                 call    load_overrun_buf;
2155                 mvi     DFCNTRL, (HDMAEN|SCSIEN|PRELOADEN);
2156         }
2157         call    setjmp;
2158         if ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) != 0) {
2159                 test    DFSTATUS, PRELOAD_AVAIL jz overrun_load_done;
2160                 call    load_overrun_buf;
2161                 or      DFCNTRL, PRELOADEN;
2162 overrun_load_done:
2163                 test    SEQINTSRC, CTXTDONE jnz pkt_overrun_end;
2164         } else {
2165                 test    DFFSXFRCTL, DFFBITBUCKET jz pkt_overrun_end;
2166         }
2167         test    SSTAT2, NONPACKREQ jz return;
2168 pkt_overrun_end:
2169         or      SCB_RESIDUAL_SGPTR, SG_OVERRUN_RESID;
2170         test    SEQINTSRC, CTXTDONE jz unexpected_nonpkt_phase;
2171         dec     SCB_FIFO_USE_COUNT;
2172         or      LONGJMP_ADDR[1], INVALID_ADDR;
2173         test    SCB_CONTROL, STATUS_RCVD jnz pkt_complete_scb_if_fifos_idle;
2174         mvi     DFFSXFRCTL, CLRCHN ret;
2175
2176 if ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) != 0) {
2177 load_overrun_buf:
2178         /*
2179          * Load a dummy segment if preload space is available.
2180          */
2181         mov     HADDR[0], SHARED_DATA_ADDR;
2182         add     HADDR[1], PKT_OVERRUN_BUFOFFSET, SHARED_DATA_ADDR[1];
2183         mov     ACCUM_SAVE, A;
2184         clr     A;
2185         adc     HADDR[2], A, SHARED_DATA_ADDR[2];
2186         adc     HADDR[3], A, SHARED_DATA_ADDR[3];
2187         mov     A, ACCUM_SAVE;
2188         bmov    HADDR[4], ALLZEROS, 4;
2189         /* PKT_OVERRUN_BUFSIZE is a multiple of 256 */
2190         clr     HCNT[0];
2191         mvi     HCNT[1], ((PKT_OVERRUN_BUFSIZE >> 8) & 0xFF);
2192         clr     HCNT[2] ret;
2193 }