11da177e4SLinus Torvalds/* 21da177e4SLinus Torvalds * Adaptec U320 device driver firmware for Linux and FreeBSD. 31da177e4SLinus Torvalds * 453467e63SHannes Reinecke * Copyright (c) 1994-2001, 2004 Justin T. Gibbs. 51da177e4SLinus Torvalds * Copyright (c) 2000-2002 Adaptec Inc. 61da177e4SLinus Torvalds * All rights reserved. 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * Redistribution and use in source and binary forms, with or without 91da177e4SLinus Torvalds * modification, are permitted provided that the following conditions 101da177e4SLinus Torvalds * are met: 111da177e4SLinus Torvalds * 1. Redistributions of source code must retain the above copyright 121da177e4SLinus Torvalds * notice, this list of conditions, and the following disclaimer, 131da177e4SLinus Torvalds * without modification. 141da177e4SLinus Torvalds * 2. Redistributions in binary form must reproduce at minimum a disclaimer 151da177e4SLinus Torvalds * substantially similar to the "NO WARRANTY" disclaimer below 161da177e4SLinus Torvalds * ("Disclaimer") and any redistribution must be conditioned upon 171da177e4SLinus Torvalds * including a substantially similar Disclaimer requirement for further 181da177e4SLinus Torvalds * binary redistribution. 191da177e4SLinus Torvalds * 3. Neither the names of the above-listed copyright holders nor the names 201da177e4SLinus Torvalds * of any contributors may be used to endorse or promote products derived 211da177e4SLinus Torvalds * from this software without specific prior written permission. 221da177e4SLinus Torvalds * 231da177e4SLinus Torvalds * Alternatively, this software may be distributed under the terms of the 241da177e4SLinus Torvalds * GNU General Public License ("GPL") version 2 as published by the Free 251da177e4SLinus Torvalds * Software Foundation. 261da177e4SLinus Torvalds * 271da177e4SLinus Torvalds * NO WARRANTY 281da177e4SLinus Torvalds * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 291da177e4SLinus Torvalds * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 301da177e4SLinus Torvalds * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 311da177e4SLinus Torvalds * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 321da177e4SLinus Torvalds * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 331da177e4SLinus Torvalds * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 341da177e4SLinus Torvalds * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 351da177e4SLinus Torvalds * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 361da177e4SLinus Torvalds * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 371da177e4SLinus Torvalds * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 381da177e4SLinus Torvalds * POSSIBILITY OF SUCH DAMAGES. 391da177e4SLinus Torvalds * 401da177e4SLinus Torvalds * $FreeBSD$ 411da177e4SLinus Torvalds */ 421da177e4SLinus Torvalds 4353467e63SHannes ReineckeVERSION = "$Id: //depot/aic7xxx/aic7xxx/aic79xx.seq#120 $" 441da177e4SLinus TorvaldsPATCH_ARG_LIST = "struct ahd_softc *ahd" 451da177e4SLinus TorvaldsPREFIX = "ahd_" 461da177e4SLinus Torvalds 471da177e4SLinus Torvalds#include "aic79xx.reg" 481da177e4SLinus Torvalds#include "scsi_message.h" 491da177e4SLinus Torvalds 501da177e4SLinus Torvaldsrestart: 511da177e4SLinus Torvaldsif ((ahd->bugs & AHD_INTCOLLISION_BUG) != 0) { 521da177e4SLinus Torvalds test SEQINTCODE, 0xFF jz idle_loop; 531da177e4SLinus Torvalds SET_SEQINTCODE(NO_SEQINT) 541da177e4SLinus Torvalds} 551da177e4SLinus Torvalds 561da177e4SLinus Torvaldsidle_loop: 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds if ((ahd->bugs & AHD_INTCOLLISION_BUG) != 0) { 591da177e4SLinus Torvalds /* 601da177e4SLinus Torvalds * Convert ERROR status into a sequencer 611da177e4SLinus Torvalds * interrupt to handle the case of an 621da177e4SLinus Torvalds * interrupt collision on the hardware 631da177e4SLinus Torvalds * setting of HWERR. 641da177e4SLinus Torvalds */ 651da177e4SLinus Torvalds test ERROR, 0xFF jz no_error_set; 661da177e4SLinus Torvalds SET_SEQINTCODE(SAW_HWERR) 671da177e4SLinus Torvaldsno_error_set: 681da177e4SLinus Torvalds } 691da177e4SLinus Torvalds SET_MODE(M_SCSI, M_SCSI) 701da177e4SLinus Torvalds test SCSISEQ0, ENSELO|ENARBO jnz idle_loop_checkbus; 7111668bb6SHannes Reinecke test SEQ_FLAGS2, SELECTOUT_QFROZEN jz check_waiting_list; 7211668bb6SHannes Reinecke /* 7311668bb6SHannes Reinecke * If the kernel has caught up with us, thaw the queue. 7411668bb6SHannes Reinecke */ 7511668bb6SHannes Reinecke mov A, KERNEL_QFREEZE_COUNT; 7611668bb6SHannes Reinecke cmp QFREEZE_COUNT, A jne check_frozen_completions; 7711668bb6SHannes Reinecke mov A, KERNEL_QFREEZE_COUNT[1]; 7811668bb6SHannes Reinecke cmp QFREEZE_COUNT[1], A jne check_frozen_completions; 7911668bb6SHannes Reinecke and SEQ_FLAGS2, ~SELECTOUT_QFROZEN; 8011668bb6SHannes Reinecke jmp check_waiting_list; 8111668bb6SHannes Reineckecheck_frozen_completions: 8211668bb6SHannes Reinecke test SSTAT0, SELDO|SELINGO jnz idle_loop_checkbus; 8311668bb6SHannes ReineckeBEGIN_CRITICAL; 8411668bb6SHannes Reinecke /* 8511668bb6SHannes Reinecke * If we have completions stalled waiting for the qfreeze 8611668bb6SHannes Reinecke * to take effect, move them over to the complete_scb list 8711668bb6SHannes Reinecke * now that no selections are pending. 8811668bb6SHannes Reinecke */ 8911668bb6SHannes Reinecke cmp COMPLETE_ON_QFREEZE_HEAD[1],SCB_LIST_NULL je idle_loop_checkbus; 9011668bb6SHannes Reinecke /* 9111668bb6SHannes Reinecke * Find the end of the qfreeze list. The first element has 9211668bb6SHannes Reinecke * to be treated specially. 9311668bb6SHannes Reinecke */ 9411668bb6SHannes Reinecke bmov SCBPTR, COMPLETE_ON_QFREEZE_HEAD, 2; 9511668bb6SHannes Reinecke cmp SCB_NEXT_COMPLETE[1], SCB_LIST_NULL je join_lists; 9611668bb6SHannes Reinecke /* 9711668bb6SHannes Reinecke * Now the normal loop. 9811668bb6SHannes Reinecke */ 9911668bb6SHannes Reinecke bmov SCBPTR, SCB_NEXT_COMPLETE, 2; 10011668bb6SHannes Reinecke cmp SCB_NEXT_COMPLETE[1], SCB_LIST_NULL jne . - 1; 10111668bb6SHannes Reineckejoin_lists: 10211668bb6SHannes Reinecke bmov SCB_NEXT_COMPLETE, COMPLETE_SCB_HEAD, 2; 10311668bb6SHannes Reinecke bmov COMPLETE_SCB_HEAD, COMPLETE_ON_QFREEZE_HEAD, 2; 10411668bb6SHannes Reinecke mvi COMPLETE_ON_QFREEZE_HEAD[1], SCB_LIST_NULL; 10511668bb6SHannes Reinecke jmp idle_loop_checkbus; 10611668bb6SHannes Reineckecheck_waiting_list: 1071da177e4SLinus Torvalds cmp WAITING_TID_HEAD[1], SCB_LIST_NULL je idle_loop_checkbus; 1081da177e4SLinus Torvalds /* 1091da177e4SLinus Torvalds * ENSELO is cleared by a SELDO, so we must test for SELDO 1101da177e4SLinus Torvalds * one last time. 1111da177e4SLinus Torvalds */ 1121da177e4SLinus Torvalds test SSTAT0, SELDO jnz select_out; 1131da177e4SLinus Torvalds call start_selection; 1141da177e4SLinus Torvaldsidle_loop_checkbus: 1151da177e4SLinus Torvalds test SSTAT0, SELDO jnz select_out; 1161da177e4SLinus TorvaldsEND_CRITICAL; 1171da177e4SLinus Torvalds test SSTAT0, SELDI jnz select_in; 1181da177e4SLinus Torvalds test SCSIPHASE, ~DATA_PHASE_MASK jz idle_loop_check_nonpackreq; 1191da177e4SLinus Torvalds test SCSISIGO, ATNO jz idle_loop_check_nonpackreq; 1201da177e4SLinus Torvalds call unexpected_nonpkt_phase_find_ctxt; 1211da177e4SLinus Torvaldsidle_loop_check_nonpackreq: 1221da177e4SLinus Torvalds test SSTAT2, NONPACKREQ jz . + 2; 1231da177e4SLinus Torvalds call unexpected_nonpkt_phase_find_ctxt; 1241da177e4SLinus Torvalds if ((ahd->bugs & AHD_FAINT_LED_BUG) != 0) { 12511668bb6SHannes Reinecke /* 12611668bb6SHannes Reinecke * On Rev A. hardware, the busy LED is only 12711668bb6SHannes Reinecke * turned on automaically during selections 12811668bb6SHannes Reinecke * and re-selections. Make the LED status 12911668bb6SHannes Reinecke * more useful by forcing it to be on so 13011668bb6SHannes Reinecke * long as one of our data FIFOs is active. 13111668bb6SHannes Reinecke */ 1321da177e4SLinus Torvalds and A, FIFO0FREE|FIFO1FREE, DFFSTAT; 1331da177e4SLinus Torvalds cmp A, FIFO0FREE|FIFO1FREE jne . + 3; 1341da177e4SLinus Torvalds and SBLKCTL, ~DIAGLEDEN|DIAGLEDON; 1351da177e4SLinus Torvalds jmp . + 2; 1361da177e4SLinus Torvalds or SBLKCTL, DIAGLEDEN|DIAGLEDON; 1371da177e4SLinus Torvalds } 1381da177e4SLinus Torvalds call idle_loop_gsfifo_in_scsi_mode; 1391da177e4SLinus Torvalds call idle_loop_service_fifos; 1401da177e4SLinus Torvalds call idle_loop_cchan; 1411da177e4SLinus Torvalds jmp idle_loop; 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvaldsidle_loop_gsfifo: 1441da177e4SLinus Torvalds SET_MODE(M_SCSI, M_SCSI) 14511668bb6SHannes ReineckeBEGIN_CRITICAL; 1461da177e4SLinus Torvaldsidle_loop_gsfifo_in_scsi_mode: 1471da177e4SLinus Torvalds test LQISTAT2, LQIGSAVAIL jz return; 1481da177e4SLinus Torvalds /* 1491da177e4SLinus Torvalds * We have received good status for this transaction. There may 1501da177e4SLinus Torvalds * still be data in our FIFOs draining to the host. Complete 1511da177e4SLinus Torvalds * the SCB only if all data has transferred to the host. 1521da177e4SLinus Torvalds */ 1531da177e4SLinus Torvaldsgood_status_IU_done: 1541da177e4SLinus Torvalds bmov SCBPTR, GSFIFO, 2; 1551da177e4SLinus Torvalds clr SCB_SCSI_STATUS; 1561da177e4SLinus Torvalds /* 1571da177e4SLinus Torvalds * If a command completed before an attempted task management 1581da177e4SLinus Torvalds * function completed, notify the host after disabling any 1591da177e4SLinus Torvalds * pending select-outs. 1601da177e4SLinus Torvalds */ 1611da177e4SLinus Torvalds test SCB_TASK_MANAGEMENT, 0xFF jz gsfifo_complete_normally; 1621da177e4SLinus Torvalds test SSTAT0, SELDO|SELINGO jnz . + 2; 1631da177e4SLinus Torvalds and SCSISEQ0, ~ENSELO; 1641da177e4SLinus Torvalds SET_SEQINTCODE(TASKMGMT_CMD_CMPLT_OKAY) 1651da177e4SLinus Torvaldsgsfifo_complete_normally: 1661da177e4SLinus Torvalds or SCB_CONTROL, STATUS_RCVD; 1671da177e4SLinus Torvalds 1681da177e4SLinus Torvalds /* 1691da177e4SLinus Torvalds * Since this status did not consume a FIFO, we have to 1701da177e4SLinus Torvalds * be a bit more dilligent in how we check for FIFOs pertaining 1711da177e4SLinus Torvalds * to this transaction. There are two states that a FIFO still 1721da177e4SLinus Torvalds * transferring data may be in. 1731da177e4SLinus Torvalds * 1741da177e4SLinus Torvalds * 1) Configured and draining to the host, with a FIFO handler. 1751da177e4SLinus Torvalds * 2) Pending cfg4data, fifo not empty. 1761da177e4SLinus Torvalds * 1771da177e4SLinus Torvalds * Case 1 can be detected by noticing a non-zero FIFO active 1781da177e4SLinus Torvalds * count in the SCB. In this case, we allow the routine servicing 1791da177e4SLinus Torvalds * the FIFO to complete the SCB. 1801da177e4SLinus Torvalds * 1811da177e4SLinus Torvalds * Case 2 implies either a pending or yet to occur save data 1821da177e4SLinus Torvalds * pointers for this same context in the other FIFO. So, if 1831da177e4SLinus Torvalds * we detect case 1, we will properly defer the post of the SCB 1841da177e4SLinus Torvalds * and achieve the desired result. The pending cfg4data will 1851da177e4SLinus Torvalds * notice that status has been received and complete the SCB. 1861da177e4SLinus Torvalds */ 1871da177e4SLinus Torvalds test SCB_FIFO_USE_COUNT, 0xFF jnz idle_loop_gsfifo_in_scsi_mode; 1881da177e4SLinus Torvalds call complete; 1891da177e4SLinus TorvaldsEND_CRITICAL; 1901da177e4SLinus Torvalds jmp idle_loop_gsfifo_in_scsi_mode; 1911da177e4SLinus Torvalds 1921da177e4SLinus Torvaldsidle_loop_service_fifos: 1931da177e4SLinus Torvalds SET_MODE(M_DFF0, M_DFF0) 19411668bb6SHannes ReineckeBEGIN_CRITICAL; 1951da177e4SLinus Torvalds test LONGJMP_ADDR[1], INVALID_ADDR jnz idle_loop_next_fifo; 1961da177e4SLinus Torvalds call longjmp; 19711668bb6SHannes ReineckeEND_CRITICAL; 1981da177e4SLinus Torvaldsidle_loop_next_fifo: 1991da177e4SLinus Torvalds SET_MODE(M_DFF1, M_DFF1) 20011668bb6SHannes ReineckeBEGIN_CRITICAL; 2011da177e4SLinus Torvalds test LONGJMP_ADDR[1], INVALID_ADDR jz longjmp; 20211668bb6SHannes ReineckeEND_CRITICAL; 2031da177e4SLinus Torvaldsreturn: 2041da177e4SLinus Torvalds ret; 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvaldsidle_loop_cchan: 2071da177e4SLinus Torvalds SET_MODE(M_CCHAN, M_CCHAN) 2081da177e4SLinus Torvalds test QOFF_CTLSTA, HS_MAILBOX_ACT jz hs_mailbox_empty; 2091da177e4SLinus Torvalds or QOFF_CTLSTA, HS_MAILBOX_ACT; 2101da177e4SLinus Torvalds mov LOCAL_HS_MAILBOX, HS_MAILBOX; 2111da177e4SLinus Torvaldshs_mailbox_empty: 2121da177e4SLinus TorvaldsBEGIN_CRITICAL; 2131da177e4SLinus Torvalds test CCSCBCTL, CCARREN|CCSCBEN jz scbdma_idle; 2141da177e4SLinus Torvalds test CCSCBCTL, CCSCBDIR jnz fetch_new_scb_inprog; 2151da177e4SLinus Torvalds test CCSCBCTL, CCSCBDONE jz return; 2161da177e4SLinus Torvalds /* FALLTHROUGH */ 2171da177e4SLinus Torvaldsscbdma_tohost_done: 2181da177e4SLinus Torvalds test CCSCBCTL, CCARREN jz fill_qoutfifo_dmadone; 2191da177e4SLinus Torvalds /* 220af901ca1SAndré Goddard Rosa * An SCB has been successfully uploaded to the host. 2211da177e4SLinus Torvalds * If the SCB was uploaded for some reason other than 2221da177e4SLinus Torvalds * bad SCSI status (currently only for underruns), we 2231da177e4SLinus Torvalds * queue the SCB for normal completion. Otherwise, we 2241da177e4SLinus Torvalds * wait until any select-out activity has halted, and 22511668bb6SHannes Reinecke * then queue the completion. 2261da177e4SLinus Torvalds */ 2271da177e4SLinus Torvalds and CCSCBCTL, ~(CCARREN|CCSCBEN); 2281da177e4SLinus Torvalds bmov COMPLETE_DMA_SCB_HEAD, SCB_NEXT_COMPLETE, 2; 22911668bb6SHannes Reinecke cmp SCB_NEXT_COMPLETE[1], SCB_LIST_NULL jne . + 2; 23011668bb6SHannes Reinecke mvi COMPLETE_DMA_SCB_TAIL[1], SCB_LIST_NULL; 23111668bb6SHannes Reinecke test SCB_SCSI_STATUS, 0xff jz scbdma_queue_completion; 23211668bb6SHannes Reinecke bmov SCB_NEXT_COMPLETE, COMPLETE_ON_QFREEZE_HEAD, 2; 23311668bb6SHannes Reinecke bmov COMPLETE_ON_QFREEZE_HEAD, SCBPTR, 2 ret; 23411668bb6SHannes Reineckescbdma_queue_completion: 2351da177e4SLinus Torvalds bmov SCB_NEXT_COMPLETE, COMPLETE_SCB_HEAD, 2; 2361da177e4SLinus Torvalds bmov COMPLETE_SCB_HEAD, SCBPTR, 2 ret; 2371da177e4SLinus Torvaldsfill_qoutfifo_dmadone: 2381da177e4SLinus Torvalds and CCSCBCTL, ~(CCARREN|CCSCBEN); 2391da177e4SLinus Torvalds call qoutfifo_updated; 2401da177e4SLinus Torvalds mvi COMPLETE_SCB_DMAINPROG_HEAD[1], SCB_LIST_NULL; 2411da177e4SLinus Torvalds bmov QOUTFIFO_NEXT_ADDR, SCBHADDR, 4; 2421da177e4SLinus Torvalds test QOFF_CTLSTA, SDSCB_ROLLOVR jz return; 2431da177e4SLinus Torvalds bmov QOUTFIFO_NEXT_ADDR, SHARED_DATA_ADDR, 4; 2441da177e4SLinus Torvalds xor QOUTFIFO_ENTRY_VALID_TAG, QOUTFIFO_ENTRY_VALID_TOGGLE ret; 24511668bb6SHannes ReineckeEND_CRITICAL; 2461da177e4SLinus Torvalds 2471da177e4SLinus Torvaldsqoutfifo_updated: 2481da177e4SLinus Torvalds /* 2491da177e4SLinus Torvalds * If there are more commands waiting to be dma'ed 2501da177e4SLinus Torvalds * to the host, always coalesce. Otherwise honor the 2511da177e4SLinus Torvalds * host's wishes. 2521da177e4SLinus Torvalds */ 2531da177e4SLinus Torvalds cmp COMPLETE_DMA_SCB_HEAD[1], SCB_LIST_NULL jne coalesce_by_count; 2541da177e4SLinus Torvalds cmp COMPLETE_SCB_HEAD[1], SCB_LIST_NULL jne coalesce_by_count; 2551da177e4SLinus Torvalds test LOCAL_HS_MAILBOX, ENINT_COALESCE jz issue_cmdcmplt; 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds /* 2581da177e4SLinus Torvalds * If we have relatively few commands outstanding, don't 2591da177e4SLinus Torvalds * bother waiting for another command to complete. 2601da177e4SLinus Torvalds */ 2611da177e4SLinus Torvalds test CMDS_PENDING[1], 0xFF jnz coalesce_by_count; 2621da177e4SLinus Torvalds /* Add -1 so that jnc means <= not just < */ 2631da177e4SLinus Torvalds add A, -1, INT_COALESCING_MINCMDS; 2641da177e4SLinus Torvalds add NONE, A, CMDS_PENDING; 2651da177e4SLinus Torvalds jnc issue_cmdcmplt; 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds /* 2681da177e4SLinus Torvalds * If coalescing, only coalesce up to the limit 2691da177e4SLinus Torvalds * provided by the host driver. 2701da177e4SLinus Torvalds */ 2711da177e4SLinus Torvaldscoalesce_by_count: 2721da177e4SLinus Torvalds mov A, INT_COALESCING_MAXCMDS; 2731da177e4SLinus Torvalds add NONE, A, INT_COALESCING_CMDCOUNT; 2741da177e4SLinus Torvalds jc issue_cmdcmplt; 2751da177e4SLinus Torvalds /* 2761da177e4SLinus Torvalds * If the timer is not currently active, 2771da177e4SLinus Torvalds * fire it up. 2781da177e4SLinus Torvalds */ 2791da177e4SLinus Torvalds test INTCTL, SWTMINTMASK jz return; 2801da177e4SLinus Torvalds bmov SWTIMER, INT_COALESCING_TIMER, 2; 2811da177e4SLinus Torvalds mvi CLRSEQINTSTAT, CLRSEQ_SWTMRTO; 2821da177e4SLinus Torvalds or INTCTL, SWTMINTEN|SWTIMER_START; 2831da177e4SLinus Torvalds and INTCTL, ~SWTMINTMASK ret; 2841da177e4SLinus Torvalds 2851da177e4SLinus Torvaldsissue_cmdcmplt: 2861da177e4SLinus Torvalds mvi INTSTAT, CMDCMPLT; 2871da177e4SLinus Torvalds clr INT_COALESCING_CMDCOUNT; 2881da177e4SLinus Torvalds or INTCTL, SWTMINTMASK ret; 2891da177e4SLinus Torvalds 2901da177e4SLinus TorvaldsBEGIN_CRITICAL; 2911da177e4SLinus Torvaldsfetch_new_scb_inprog: 2921da177e4SLinus Torvalds test CCSCBCTL, ARRDONE jz return; 2931da177e4SLinus Torvaldsfetch_new_scb_done: 2941da177e4SLinus Torvalds and CCSCBCTL, ~(CCARREN|CCSCBEN); 2951da177e4SLinus Torvalds clr A; 2961da177e4SLinus Torvalds add CMDS_PENDING, 1; 2971da177e4SLinus Torvalds adc CMDS_PENDING[1], A; 2981da177e4SLinus Torvalds if ((ahd->bugs & AHD_PKT_LUN_BUG) != 0) { 2991da177e4SLinus Torvalds /* 3001da177e4SLinus Torvalds * "Short Luns" are not placed into outgoing LQ 3011da177e4SLinus Torvalds * packets in the correct byte order. Use a full 3021da177e4SLinus Torvalds * sized lun field instead and fill it with the 3031da177e4SLinus Torvalds * one byte of lun information we support. 3041da177e4SLinus Torvalds */ 3051da177e4SLinus Torvalds mov SCB_PKT_LUN[6], SCB_LUN; 3061da177e4SLinus Torvalds } 3071da177e4SLinus Torvalds /* 3081da177e4SLinus Torvalds * The FIFO use count field is shared with the 3091da177e4SLinus Torvalds * tag set by the host so that our SCB dma engine 3101da177e4SLinus Torvalds * knows the correct location to store the SCB. 3111da177e4SLinus Torvalds * Set it to zero before processing the SCB. 3121da177e4SLinus Torvalds */ 3131da177e4SLinus Torvalds clr SCB_FIFO_USE_COUNT; 3141da177e4SLinus Torvalds /* Update the next SCB address to download. */ 3151da177e4SLinus Torvalds bmov NEXT_QUEUED_SCB_ADDR, SCB_NEXT_SCB_BUSADDR, 4; 31653467e63SHannes Reinecke /* 31753467e63SHannes Reinecke * NULL out the SCB links since these fields 31853467e63SHannes Reinecke * occupy the same location as SCB_NEXT_SCB_BUSADDR. 31953467e63SHannes Reinecke */ 3201da177e4SLinus Torvalds mvi SCB_NEXT[1], SCB_LIST_NULL; 3211da177e4SLinus Torvalds mvi SCB_NEXT2[1], SCB_LIST_NULL; 3221da177e4SLinus Torvalds /* Increment our position in the QINFIFO. */ 3231da177e4SLinus Torvalds mov NONE, SNSCB_QOFF; 32453467e63SHannes Reinecke 3251da177e4SLinus Torvalds /* 32653467e63SHannes Reinecke * Save SCBID of this SCB in REG0 since 32753467e63SHannes Reinecke * SCBPTR will be clobbered during target 32853467e63SHannes Reinecke * list updates. We also record the SCB's 32953467e63SHannes Reinecke * flags so that we can refer to them even 33053467e63SHannes Reinecke * after SCBPTR has been changed. 3311da177e4SLinus Torvalds */ 33253467e63SHannes Reinecke bmov REG0, SCBPTR, 2; 33353467e63SHannes Reinecke mov A, SCB_CONTROL; 33453467e63SHannes Reinecke 33553467e63SHannes Reinecke /* 33653467e63SHannes Reinecke * Find the tail SCB of the execution queue 33753467e63SHannes Reinecke * for this target. 33853467e63SHannes Reinecke */ 3391da177e4SLinus Torvalds shr SINDEX, 3, SCB_SCSIID; 3401da177e4SLinus Torvalds and SINDEX, ~0x1; 3411da177e4SLinus Torvalds mvi SINDEX[1], (WAITING_SCB_TAILS >> 8); 3421da177e4SLinus Torvalds bmov DINDEX, SINDEX, 2; 3431da177e4SLinus Torvalds bmov SCBPTR, SINDIR, 2; 34453467e63SHannes Reinecke 34553467e63SHannes Reinecke /* 34653467e63SHannes Reinecke * Update the tail to point to the new SCB. 34753467e63SHannes Reinecke */ 3481da177e4SLinus Torvalds bmov DINDIR, REG0, 2; 34953467e63SHannes Reinecke 35053467e63SHannes Reinecke /* 35153467e63SHannes Reinecke * If the queue was empty, queue this SCB as 35253467e63SHannes Reinecke * the first for this target. 35353467e63SHannes Reinecke */ 3541da177e4SLinus Torvalds cmp SCBPTR[1], SCB_LIST_NULL je first_new_target_scb; 35553467e63SHannes Reinecke 35653467e63SHannes Reinecke /* 35753467e63SHannes Reinecke * SCBs that want to send messages must always be 35853467e63SHannes Reinecke * at the head of their per-target queue so that 35953467e63SHannes Reinecke * ATN can be asserted even if the current 36053467e63SHannes Reinecke * negotiation agreement is packetized. If the 36153467e63SHannes Reinecke * target queue is empty, the SCB can be queued 36253467e63SHannes Reinecke * immediately. If the queue is not empty, we must 36353467e63SHannes Reinecke * wait for it to empty before entering this SCB 36453467e63SHannes Reinecke * into the waiting for selection queue. Otherwise 36553467e63SHannes Reinecke * our batching and round-robin selection scheme 36653467e63SHannes Reinecke * could allow commands to be queued out of order. 36753467e63SHannes Reinecke * To simplify the implementation, we stop pulling 36853467e63SHannes Reinecke * new commands from the host until the MK_MESSAGE 36953467e63SHannes Reinecke * SCB can be queued to the waiting for selection 37053467e63SHannes Reinecke * list. 37153467e63SHannes Reinecke */ 37253467e63SHannes Reinecke test A, MK_MESSAGE jz batch_scb; 37353467e63SHannes Reinecke 37453467e63SHannes Reinecke /* 37553467e63SHannes Reinecke * If the last SCB is also a MK_MESSAGE SCB, then 37653467e63SHannes Reinecke * order is preserved even if we batch. 37753467e63SHannes Reinecke */ 37853467e63SHannes Reinecke test SCB_CONTROL, MK_MESSAGE jz batch_scb; 37953467e63SHannes Reinecke 38053467e63SHannes Reinecke /* 38153467e63SHannes Reinecke * Defer this SCB and stop fetching new SCBs until 38253467e63SHannes Reinecke * it can be queued. Since the SCB_SCSIID of the 38353467e63SHannes Reinecke * tail SCB must be the same as that of the newly 38453467e63SHannes Reinecke * queued SCB, there is no need to restore the SCBID 38553467e63SHannes Reinecke * here. 38653467e63SHannes Reinecke */ 38753467e63SHannes Reinecke or SEQ_FLAGS2, PENDING_MK_MESSAGE; 38853467e63SHannes Reinecke bmov MK_MESSAGE_SCB, REG0, 2; 38953467e63SHannes Reinecke mov MK_MESSAGE_SCSIID, SCB_SCSIID ret; 39053467e63SHannes Reinecke 39153467e63SHannes Reineckebatch_scb: 39253467e63SHannes Reinecke /* 39353467e63SHannes Reinecke * Otherwise just update the previous tail SCB to 39453467e63SHannes Reinecke * point to the new tail. 39553467e63SHannes Reinecke */ 3961da177e4SLinus Torvalds bmov SCB_NEXT, REG0, 2 ret; 39753467e63SHannes Reinecke 3981da177e4SLinus Torvaldsfirst_new_target_scb: 39953467e63SHannes Reinecke /* 40053467e63SHannes Reinecke * Append SCB to the tail of the waiting for 40153467e63SHannes Reinecke * selection list. 40253467e63SHannes Reinecke */ 4031da177e4SLinus Torvalds cmp WAITING_TID_HEAD[1], SCB_LIST_NULL je first_new_scb; 4041da177e4SLinus Torvalds bmov SCBPTR, WAITING_TID_TAIL, 2; 4051da177e4SLinus Torvalds bmov SCB_NEXT2, REG0, 2; 4061da177e4SLinus Torvalds bmov WAITING_TID_TAIL, REG0, 2 ret; 4071da177e4SLinus Torvaldsfirst_new_scb: 40853467e63SHannes Reinecke /* 40953467e63SHannes Reinecke * Whole list is empty, so the head of 41053467e63SHannes Reinecke * the list must be initialized too. 41153467e63SHannes Reinecke */ 4121da177e4SLinus Torvalds bmov WAITING_TID_HEAD, REG0, 2; 4131da177e4SLinus Torvalds bmov WAITING_TID_TAIL, REG0, 2 ret; 4141da177e4SLinus TorvaldsEND_CRITICAL; 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvaldsscbdma_idle: 4171da177e4SLinus Torvalds /* 41853467e63SHannes Reinecke * Don't bother downloading new SCBs to execute 41953467e63SHannes Reinecke * if select-outs are currently frozen or we have 42053467e63SHannes Reinecke * a MK_MESSAGE SCB waiting to enter the queue. 4211da177e4SLinus Torvalds */ 42253467e63SHannes Reinecke test SEQ_FLAGS2, SELECTOUT_QFROZEN|PENDING_MK_MESSAGE 42353467e63SHannes Reinecke jnz scbdma_no_new_scbs; 4241da177e4SLinus TorvaldsBEGIN_CRITICAL; 4251da177e4SLinus Torvalds test QOFF_CTLSTA, NEW_SCB_AVAIL jnz fetch_new_scb; 42653467e63SHannes Reineckescbdma_no_new_scbs: 4271da177e4SLinus Torvalds cmp COMPLETE_DMA_SCB_HEAD[1], SCB_LIST_NULL jne dma_complete_scb; 4281da177e4SLinus Torvalds cmp COMPLETE_SCB_HEAD[1], SCB_LIST_NULL je return; 4291da177e4SLinus Torvalds /* FALLTHROUGH */ 4301da177e4SLinus Torvaldsfill_qoutfifo: 4311da177e4SLinus Torvalds /* 4321da177e4SLinus Torvalds * Keep track of the SCBs we are dmaing just 4331da177e4SLinus Torvalds * in case the DMA fails or is aborted. 4341da177e4SLinus Torvalds */ 4351da177e4SLinus Torvalds bmov COMPLETE_SCB_DMAINPROG_HEAD, COMPLETE_SCB_HEAD, 2; 4361da177e4SLinus Torvalds mvi CCSCBCTL, CCSCBRESET; 4371da177e4SLinus Torvalds bmov SCBHADDR, QOUTFIFO_NEXT_ADDR, 4; 43811668bb6SHannes Reinecke mov A, QOUTFIFO_NEXT_ADDR; 4391da177e4SLinus Torvalds bmov SCBPTR, COMPLETE_SCB_HEAD, 2; 4401da177e4SLinus Torvaldsfill_qoutfifo_loop: 44111668bb6SHannes Reinecke bmov CCSCBRAM, SCBPTR, 2; 44211668bb6SHannes Reinecke mov CCSCBRAM, SCB_SGPTR[0]; 44311668bb6SHannes Reinecke mov CCSCBRAM, QOUTFIFO_ENTRY_VALID_TAG; 4441da177e4SLinus Torvalds mov NONE, SDSCB_QOFF; 4451da177e4SLinus Torvalds inc INT_COALESCING_CMDCOUNT; 4461da177e4SLinus Torvalds add CMDS_PENDING, -1; 4471da177e4SLinus Torvalds adc CMDS_PENDING[1], -1; 4481da177e4SLinus Torvalds cmp SCB_NEXT_COMPLETE[1], SCB_LIST_NULL je fill_qoutfifo_done; 4491da177e4SLinus Torvalds cmp CCSCBADDR, CCSCBADDR_MAX je fill_qoutfifo_done; 4501da177e4SLinus Torvalds test QOFF_CTLSTA, SDSCB_ROLLOVR jnz fill_qoutfifo_done; 45111668bb6SHannes Reinecke /* 45211668bb6SHannes Reinecke * Don't cross an ADB or Cachline boundary when DMA'ing 45311668bb6SHannes Reinecke * completion entries. In PCI mode, at least in 32/33 45411668bb6SHannes Reinecke * configurations, the SCB DMA engine may lose its place 45511668bb6SHannes Reinecke * in the data-stream should the target force a retry on 45611668bb6SHannes Reinecke * something other than an 8byte aligned boundary. In 45711668bb6SHannes Reinecke * PCI-X mode, we do this to avoid split transactions since 45811668bb6SHannes Reinecke * many chipsets seem to be unable to format proper split 45911668bb6SHannes Reinecke * completions to continue the data transfer. 46011668bb6SHannes Reinecke */ 46111668bb6SHannes Reinecke add SINDEX, A, CCSCBADDR; 46211668bb6SHannes Reinecke test SINDEX, CACHELINE_MASK jz fill_qoutfifo_done; 4631da177e4SLinus Torvalds bmov SCBPTR, SCB_NEXT_COMPLETE, 2; 4641da177e4SLinus Torvalds jmp fill_qoutfifo_loop; 4651da177e4SLinus Torvaldsfill_qoutfifo_done: 4661da177e4SLinus Torvalds mov SCBHCNT, CCSCBADDR; 4671da177e4SLinus Torvalds mvi CCSCBCTL, CCSCBEN|CCSCBRESET; 4681da177e4SLinus Torvalds bmov COMPLETE_SCB_HEAD, SCB_NEXT_COMPLETE, 2; 4691da177e4SLinus Torvalds mvi SCB_NEXT_COMPLETE[1], SCB_LIST_NULL ret; 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvaldsfetch_new_scb: 4721da177e4SLinus Torvalds bmov SCBHADDR, NEXT_QUEUED_SCB_ADDR, 4; 4731da177e4SLinus Torvalds mvi CCARREN|CCSCBEN|CCSCBDIR|CCSCBRESET jmp dma_scb; 4741da177e4SLinus Torvaldsdma_complete_scb: 4751da177e4SLinus Torvalds bmov SCBPTR, COMPLETE_DMA_SCB_HEAD, 2; 4761da177e4SLinus Torvalds bmov SCBHADDR, SCB_BUSADDR, 4; 4771da177e4SLinus Torvalds mvi CCARREN|CCSCBEN|CCSCBRESET jmp dma_scb; 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds/* 4801da177e4SLinus Torvalds * Either post or fetch an SCB from host memory. The caller 4811da177e4SLinus Torvalds * is responsible for polling for transfer completion. 4821da177e4SLinus Torvalds * 4831da177e4SLinus Torvalds * Prerequisits: Mode == M_CCHAN 4841da177e4SLinus Torvalds * SINDEX contains CCSCBCTL flags 4851da177e4SLinus Torvalds * SCBHADDR set to Host SCB address 4861da177e4SLinus Torvalds * SCBPTR set to SCB src location on "push" operations 4871da177e4SLinus Torvalds */ 4881da177e4SLinus TorvaldsSET_SRC_MODE M_CCHAN; 4891da177e4SLinus TorvaldsSET_DST_MODE M_CCHAN; 4901da177e4SLinus Torvaldsdma_scb: 4911da177e4SLinus Torvalds mvi SCBHCNT, SCB_TRANSFER_SIZE; 4921da177e4SLinus Torvalds mov CCSCBCTL, SINDEX ret; 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvaldssetjmp: 49511668bb6SHannes Reinecke /* 49611668bb6SHannes Reinecke * At least on the A, a return in the same 49711668bb6SHannes Reinecke * instruction as the bmov results in a return 49811668bb6SHannes Reinecke * to the caller, not to the new address at the 49911668bb6SHannes Reinecke * top of the stack. Since we want the latter 50011668bb6SHannes Reinecke * (we use setjmp to register a handler from an 50111668bb6SHannes Reinecke * interrupt context but not invoke that handler 50211668bb6SHannes Reinecke * until we return to our idle loop), use a 50311668bb6SHannes Reinecke * separate ret instruction. 50411668bb6SHannes Reinecke */ 50511668bb6SHannes Reinecke bmov LONGJMP_ADDR, STACK, 2; 50611668bb6SHannes Reinecke ret; 5071da177e4SLinus Torvaldssetjmp_inline: 5081da177e4SLinus Torvalds bmov LONGJMP_ADDR, STACK, 2; 5091da177e4SLinus Torvaldslongjmp: 5101da177e4SLinus Torvalds bmov STACK, LONGJMP_ADDR, 2 ret; 5111da177e4SLinus TorvaldsEND_CRITICAL; 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds/*************************** Chip Bug Work Arounds ****************************/ 5141da177e4SLinus Torvalds/* 5151da177e4SLinus Torvalds * Must disable interrupts when setting the mode pointer 5161da177e4SLinus Torvalds * register as an interrupt occurring mid update will 5171da177e4SLinus Torvalds * fail to store the new mode value for restoration on 5181da177e4SLinus Torvalds * an iret. 5191da177e4SLinus Torvalds */ 5201da177e4SLinus Torvaldsif ((ahd->bugs & AHD_SET_MODE_BUG) != 0) { 5211da177e4SLinus Torvaldsset_mode_work_around: 5221da177e4SLinus Torvalds mvi SEQINTCTL, INTVEC1DSL; 5231da177e4SLinus Torvalds mov MODE_PTR, SINDEX; 5241da177e4SLinus Torvalds clr SEQINTCTL ret; 5251da177e4SLinus Torvalds} 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvalds 5281da177e4SLinus Torvaldsif ((ahd->bugs & AHD_INTCOLLISION_BUG) != 0) { 5291da177e4SLinus Torvaldsset_seqint_work_around: 5301da177e4SLinus Torvalds mov SEQINTCODE, SINDEX; 5311da177e4SLinus Torvalds mvi SEQINTCODE, NO_SEQINT ret; 5321da177e4SLinus Torvalds} 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds/************************ Packetized LongJmp Routines *************************/ 5351da177e4SLinus TorvaldsSET_SRC_MODE M_SCSI; 5361da177e4SLinus TorvaldsSET_DST_MODE M_SCSI; 5371da177e4SLinus Torvaldsstart_selection: 5381da177e4SLinus TorvaldsBEGIN_CRITICAL; 5391da177e4SLinus Torvalds if ((ahd->bugs & AHD_SENT_SCB_UPDATE_BUG) != 0) { 5401da177e4SLinus Torvalds /* 5411da177e4SLinus Torvalds * Razor #494 5421da177e4SLinus Torvalds * Rev A hardware fails to update LAST/CURR/NEXTSCB 5431da177e4SLinus Torvalds * correctly after a packetized selection in several 5441da177e4SLinus Torvalds * situations: 5451da177e4SLinus Torvalds * 5461da177e4SLinus Torvalds * 1) If only one command existed in the queue, the 5471da177e4SLinus Torvalds * LAST/CURR/NEXTSCB are unchanged. 5481da177e4SLinus Torvalds * 5491da177e4SLinus Torvalds * 2) In a non QAS, protocol allowed phase change, 5501da177e4SLinus Torvalds * the queue is shifted 1 too far. LASTSCB is 5511da177e4SLinus Torvalds * the last SCB that was correctly processed. 5521da177e4SLinus Torvalds * 5531da177e4SLinus Torvalds * 3) In the QAS case, if the full list of commands 5541da177e4SLinus Torvalds * was successfully sent, NEXTSCB is NULL and neither 5551da177e4SLinus Torvalds * CURRSCB nor LASTSCB can be trusted. We must 5561da177e4SLinus Torvalds * manually walk the list counting MAXCMDCNT elements 5571da177e4SLinus Torvalds * to find the last SCB that was sent correctly. 5581da177e4SLinus Torvalds * 5591da177e4SLinus Torvalds * To simplify the workaround for this bug in SELDO 5601da177e4SLinus Torvalds * handling, we initialize LASTSCB prior to enabling 5611da177e4SLinus Torvalds * selection so we can rely on it even for case #1 above. 5621da177e4SLinus Torvalds */ 5631da177e4SLinus Torvalds bmov LASTSCB, WAITING_TID_HEAD, 2; 5641da177e4SLinus Torvalds } 5651da177e4SLinus Torvalds bmov CURRSCB, WAITING_TID_HEAD, 2; 5661da177e4SLinus Torvalds bmov SCBPTR, WAITING_TID_HEAD, 2; 5671da177e4SLinus Torvalds shr SELOID, 4, SCB_SCSIID; 5681da177e4SLinus Torvalds /* 5691da177e4SLinus Torvalds * If we want to send a message to the device, ensure 570*25985edcSLucas De Marchi * we are selecting with atn regardless of our packetized 5711da177e4SLinus Torvalds * agreement. Since SPI4 only allows target reset or PPR 5721da177e4SLinus Torvalds * messages if this is a packetized connection, the change 5731da177e4SLinus Torvalds * to our negotiation table entry for this selection will 5741da177e4SLinus Torvalds * be cleared when the message is acted on. 5751da177e4SLinus Torvalds */ 5761da177e4SLinus Torvalds test SCB_CONTROL, MK_MESSAGE jz . + 3; 5771da177e4SLinus Torvalds mov NEGOADDR, SELOID; 5781da177e4SLinus Torvalds or NEGCONOPTS, ENAUTOATNO; 5791da177e4SLinus Torvalds or SCSISEQ0, ENSELO ret; 5801da177e4SLinus TorvaldsEND_CRITICAL; 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds/* 5831da177e4SLinus Torvalds * Allocate a FIFO for a non-packetized transaction. 5841da177e4SLinus Torvalds * In RevA hardware, both FIFOs must be free before we 5851da177e4SLinus Torvalds * can allocate a FIFO for a non-packetized transaction. 5861da177e4SLinus Torvalds */ 5871da177e4SLinus Torvaldsallocate_fifo_loop: 5881da177e4SLinus Torvalds /* 5891da177e4SLinus Torvalds * Do whatever work is required to free a FIFO. 5901da177e4SLinus Torvalds */ 5911da177e4SLinus Torvalds call idle_loop_service_fifos; 5921da177e4SLinus Torvalds SET_MODE(M_SCSI, M_SCSI) 5931da177e4SLinus Torvaldsallocate_fifo: 5941da177e4SLinus Torvalds if ((ahd->bugs & AHD_NONPACKFIFO_BUG) != 0) { 5951da177e4SLinus Torvalds and A, FIFO0FREE|FIFO1FREE, DFFSTAT; 5961da177e4SLinus Torvalds cmp A, FIFO0FREE|FIFO1FREE jne allocate_fifo_loop; 5971da177e4SLinus Torvalds } else { 5981da177e4SLinus Torvalds test DFFSTAT, FIFO1FREE jnz allocate_fifo1; 5991da177e4SLinus Torvalds test DFFSTAT, FIFO0FREE jz allocate_fifo_loop; 6001da177e4SLinus Torvalds mvi DFFSTAT, B_CURRFIFO_0; 6011da177e4SLinus Torvalds SET_MODE(M_DFF0, M_DFF0) 6021da177e4SLinus Torvalds bmov SCBPTR, ALLOCFIFO_SCBPTR, 2 ret; 6031da177e4SLinus Torvalds } 6041da177e4SLinus TorvaldsSET_SRC_MODE M_SCSI; 6051da177e4SLinus TorvaldsSET_DST_MODE M_SCSI; 6061da177e4SLinus Torvaldsallocate_fifo1: 6071da177e4SLinus Torvalds mvi DFFSTAT, CURRFIFO_1; 6081da177e4SLinus Torvalds SET_MODE(M_DFF1, M_DFF1) 6091da177e4SLinus Torvalds bmov SCBPTR, ALLOCFIFO_SCBPTR, 2 ret; 6101da177e4SLinus Torvalds 6111da177e4SLinus Torvalds/* 6121da177e4SLinus Torvalds * We have been reselected as an initiator 6131da177e4SLinus Torvalds * or selected as a target. 6141da177e4SLinus Torvalds */ 6151da177e4SLinus TorvaldsSET_SRC_MODE M_SCSI; 6161da177e4SLinus TorvaldsSET_DST_MODE M_SCSI; 6171da177e4SLinus Torvaldsselect_in: 61811668bb6SHannes Reinecke if ((ahd->bugs & AHD_FAINT_LED_BUG) != 0) { 61911668bb6SHannes Reinecke /* 62011668bb6SHannes Reinecke * On Rev A. hardware, the busy LED is only 62111668bb6SHannes Reinecke * turned on automaically during selections 62211668bb6SHannes Reinecke * and re-selections. Make the LED status 62311668bb6SHannes Reinecke * more useful by forcing it to be on from 62411668bb6SHannes Reinecke * the point of selection until our idle 62511668bb6SHannes Reinecke * loop determines that neither of our FIFOs 62611668bb6SHannes Reinecke * are busy. This handles the non-packetized 62711668bb6SHannes Reinecke * case nicely as we will not return to the 62811668bb6SHannes Reinecke * idle loop until the busfree at the end of 62911668bb6SHannes Reinecke * each transaction. 63011668bb6SHannes Reinecke */ 63111668bb6SHannes Reinecke or SBLKCTL, DIAGLEDEN|DIAGLEDON; 63211668bb6SHannes Reinecke } 6331da177e4SLinus Torvalds if ((ahd->bugs & AHD_BUSFREEREV_BUG) != 0) { 6341da177e4SLinus Torvalds /* 6351da177e4SLinus Torvalds * Test to ensure that the bus has not 6361da177e4SLinus Torvalds * already gone free prior to clearing 6371da177e4SLinus Torvalds * any stale busfree status. This avoids 6381da177e4SLinus Torvalds * a window whereby a busfree just after 6391da177e4SLinus Torvalds * a selection could be missed. 6401da177e4SLinus Torvalds */ 6411da177e4SLinus Torvalds test SCSISIGI, BSYI jz . + 2; 6421da177e4SLinus Torvalds mvi CLRSINT1,CLRBUSFREE; 6431da177e4SLinus Torvalds or SIMODE1, ENBUSFREE; 6441da177e4SLinus Torvalds } 6451da177e4SLinus Torvalds or SXFRCTL0, SPIOEN; 6461da177e4SLinus Torvalds and SAVED_SCSIID, SELID_MASK, SELID; 6471da177e4SLinus Torvalds and A, OID, IOWNID; 6481da177e4SLinus Torvalds or SAVED_SCSIID, A; 6491da177e4SLinus Torvalds mvi CLRSINT0, CLRSELDI; 6501da177e4SLinus Torvalds jmp ITloop; 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds/* 6531da177e4SLinus Torvalds * We have successfully selected out. 6541da177e4SLinus Torvalds * 6551da177e4SLinus Torvalds * Clear SELDO. 6561da177e4SLinus Torvalds * Dequeue all SCBs sent from the waiting queue 6571da177e4SLinus Torvalds * Requeue all SCBs *not* sent to the tail of the waiting queue 6581da177e4SLinus Torvalds * Take Razor #494 into account for above. 6591da177e4SLinus Torvalds * 6601da177e4SLinus Torvalds * In Packetized Mode: 6611da177e4SLinus Torvalds * Return to the idle loop. Our interrupt handler will take 6621da177e4SLinus Torvalds * care of any incoming L_Qs. 6631da177e4SLinus Torvalds * 6641da177e4SLinus Torvalds * In Non-Packetize Mode: 6651da177e4SLinus Torvalds * Continue to our normal state machine. 6661da177e4SLinus Torvalds */ 6671da177e4SLinus TorvaldsSET_SRC_MODE M_SCSI; 6681da177e4SLinus TorvaldsSET_DST_MODE M_SCSI; 6691da177e4SLinus Torvaldsselect_out: 6701da177e4SLinus TorvaldsBEGIN_CRITICAL; 67111668bb6SHannes Reinecke if ((ahd->bugs & AHD_FAINT_LED_BUG) != 0) { 67211668bb6SHannes Reinecke /* 67311668bb6SHannes Reinecke * On Rev A. hardware, the busy LED is only 67411668bb6SHannes Reinecke * turned on automaically during selections 67511668bb6SHannes Reinecke * and re-selections. Make the LED status 67611668bb6SHannes Reinecke * more useful by forcing it to be on from 67711668bb6SHannes Reinecke * the point of re-selection until our idle 67811668bb6SHannes Reinecke * loop determines that neither of our FIFOs 67911668bb6SHannes Reinecke * are busy. This handles the non-packetized 68011668bb6SHannes Reinecke * case nicely as we will not return to the 68111668bb6SHannes Reinecke * idle loop until the busfree at the end of 68211668bb6SHannes Reinecke * each transaction. 68311668bb6SHannes Reinecke */ 68411668bb6SHannes Reinecke or SBLKCTL, DIAGLEDEN|DIAGLEDON; 68511668bb6SHannes Reinecke } 6861da177e4SLinus Torvalds /* Clear out all SCBs that have been successfully sent. */ 6871da177e4SLinus Torvalds if ((ahd->bugs & AHD_SENT_SCB_UPDATE_BUG) != 0) { 6881da177e4SLinus Torvalds /* 6891da177e4SLinus Torvalds * For packetized, the LQO manager clears ENSELO on 6901da177e4SLinus Torvalds * the assertion of SELDO. If we are non-packetized, 6911da177e4SLinus Torvalds * LASTSCB and CURRSCB are accurate. 6921da177e4SLinus Torvalds */ 6931da177e4SLinus Torvalds test SCSISEQ0, ENSELO jnz use_lastscb; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds /* 6961da177e4SLinus Torvalds * The update is correct for LQOSTAT1 errors. All 6971da177e4SLinus Torvalds * but LQOBUSFREE are handled by kernel interrupts. 6981da177e4SLinus Torvalds * If we see LQOBUSFREE, return to the idle loop. 6991da177e4SLinus Torvalds * Once we are out of the select_out critical section, 7001da177e4SLinus Torvalds * the kernel will cleanup the LQOBUSFREE and we will 7011da177e4SLinus Torvalds * eventually restart the selection if appropriate. 7021da177e4SLinus Torvalds */ 7031da177e4SLinus Torvalds test LQOSTAT1, LQOBUSFREE jnz idle_loop; 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds /* 7061da177e4SLinus Torvalds * On a phase change oustside of packet boundaries, 7071da177e4SLinus Torvalds * LASTSCB points to the currently active SCB context 7081da177e4SLinus Torvalds * on the bus. 7091da177e4SLinus Torvalds */ 7101da177e4SLinus Torvalds test LQOSTAT2, LQOPHACHGOUTPKT jnz use_lastscb; 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds /* 7131da177e4SLinus Torvalds * If the hardware has traversed the whole list, NEXTSCB 7141da177e4SLinus Torvalds * will be NULL, CURRSCB and LASTSCB cannot be trusted, 7151da177e4SLinus Torvalds * but MAXCMDCNT is accurate. If we stop part way through 7161da177e4SLinus Torvalds * the list or only had one command to issue, NEXTSCB[1] is 7171da177e4SLinus Torvalds * not NULL and LASTSCB is the last command to go out. 7181da177e4SLinus Torvalds */ 7191da177e4SLinus Torvalds cmp NEXTSCB[1], SCB_LIST_NULL jne use_lastscb; 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds /* 7221da177e4SLinus Torvalds * Brute force walk. 7231da177e4SLinus Torvalds */ 7241da177e4SLinus Torvalds bmov SCBPTR, WAITING_TID_HEAD, 2; 7251da177e4SLinus Torvalds mvi SEQINTCTL, INTVEC1DSL; 7261da177e4SLinus Torvalds mvi MODE_PTR, MK_MODE(M_CFG, M_CFG); 7271da177e4SLinus Torvalds mov A, MAXCMDCNT; 7281da177e4SLinus Torvalds mvi MODE_PTR, MK_MODE(M_SCSI, M_SCSI); 7291da177e4SLinus Torvalds clr SEQINTCTL; 7301da177e4SLinus Torvaldsfind_lastscb_loop: 7311da177e4SLinus Torvalds dec A; 7321da177e4SLinus Torvalds test A, 0xFF jz found_last_sent_scb; 7331da177e4SLinus Torvalds bmov SCBPTR, SCB_NEXT, 2; 7341da177e4SLinus Torvalds jmp find_lastscb_loop; 7351da177e4SLinus Torvaldsuse_lastscb: 7361da177e4SLinus Torvalds bmov SCBPTR, LASTSCB, 2; 7371da177e4SLinus Torvaldsfound_last_sent_scb: 7381da177e4SLinus Torvalds bmov CURRSCB, SCBPTR, 2; 7391da177e4SLinus Torvaldscurscb_ww_done: 7401da177e4SLinus Torvalds } else { 7411da177e4SLinus Torvalds bmov SCBPTR, CURRSCB, 2; 7421da177e4SLinus Torvalds } 7431da177e4SLinus Torvalds 7441da177e4SLinus Torvalds /* 74553467e63SHannes Reinecke * The whole list made it. Clear our tail pointer to indicate 74653467e63SHannes Reinecke * that the per-target selection queue is now empty. 7471da177e4SLinus Torvalds */ 74853467e63SHannes Reinecke cmp SCB_NEXT[1], SCB_LIST_NULL je select_out_clear_tail; 7491da177e4SLinus Torvalds 7501da177e4SLinus Torvalds /* 75153467e63SHannes Reinecke * Requeue any SCBs not sent, to the tail of the waiting Q. 7521da177e4SLinus Torvalds * We know that neither the per-TID list nor the list of 75353467e63SHannes Reinecke * TIDs is empty. Use this knowledge to our advantage and 75453467e63SHannes Reinecke * queue the remainder to the tail of the global execution 75553467e63SHannes Reinecke * queue. 7561da177e4SLinus Torvalds */ 7571da177e4SLinus Torvalds bmov REG0, SCB_NEXT, 2; 75853467e63SHannes Reineckeselect_out_queue_remainder: 7591da177e4SLinus Torvalds bmov SCBPTR, WAITING_TID_TAIL, 2; 7601da177e4SLinus Torvalds bmov SCB_NEXT2, REG0, 2; 7611da177e4SLinus Torvalds bmov WAITING_TID_TAIL, REG0, 2; 7621da177e4SLinus Torvalds jmp select_out_inc_tid_q; 7631da177e4SLinus Torvalds 76453467e63SHannes Reineckeselect_out_clear_tail: 7651da177e4SLinus Torvalds /* 76653467e63SHannes Reinecke * Queue any pending MK_MESSAGE SCB for this target now 76753467e63SHannes Reinecke * that the queue is empty. 7681da177e4SLinus Torvalds */ 76953467e63SHannes Reinecke test SEQ_FLAGS2, PENDING_MK_MESSAGE jz select_out_no_mk_message_scb; 77053467e63SHannes Reinecke mov A, MK_MESSAGE_SCSIID; 77153467e63SHannes Reinecke cmp SCB_SCSIID, A jne select_out_no_mk_message_scb; 77253467e63SHannes Reinecke and SEQ_FLAGS2, ~PENDING_MK_MESSAGE; 77353467e63SHannes Reinecke bmov REG0, MK_MESSAGE_SCB, 2; 77453467e63SHannes Reinecke jmp select_out_queue_remainder; 77553467e63SHannes Reinecke 77653467e63SHannes Reineckeselect_out_no_mk_message_scb: 77753467e63SHannes Reinecke /* 77853467e63SHannes Reinecke * Clear this target's execution tail and increment the queue. 77953467e63SHannes Reinecke */ 7801da177e4SLinus Torvalds shr DINDEX, 3, SCB_SCSIID; 7811da177e4SLinus Torvalds or DINDEX, 1; /* Want only the second byte */ 7821da177e4SLinus Torvalds mvi DINDEX[1], ((WAITING_SCB_TAILS) >> 8); 7831da177e4SLinus Torvalds mvi DINDIR, SCB_LIST_NULL; 7841da177e4SLinus Torvaldsselect_out_inc_tid_q: 7851da177e4SLinus Torvalds bmov SCBPTR, WAITING_TID_HEAD, 2; 7861da177e4SLinus Torvalds bmov WAITING_TID_HEAD, SCB_NEXT2, 2; 7871da177e4SLinus Torvalds cmp WAITING_TID_HEAD[1], SCB_LIST_NULL jne . + 2; 7881da177e4SLinus Torvalds mvi WAITING_TID_TAIL[1], SCB_LIST_NULL; 7891da177e4SLinus Torvalds bmov SCBPTR, CURRSCB, 2; 7901da177e4SLinus Torvalds mvi CLRSINT0, CLRSELDO; 79153467e63SHannes Reinecke test LQOSTAT2, LQOPHACHGOUTPKT jnz unexpected_nonpkt_mode_cleared; 79253467e63SHannes Reinecke test LQOSTAT1, LQOPHACHGINPKT jnz unexpected_nonpkt_mode_cleared; 7931da177e4SLinus Torvalds 7941da177e4SLinus Torvalds /* 7951da177e4SLinus Torvalds * If this is a packetized connection, return to our 7961da177e4SLinus Torvalds * idle_loop and let our interrupt handler deal with 7971da177e4SLinus Torvalds * any connection setup/teardown issues. The only 7981da177e4SLinus Torvalds * exceptions are the case of MK_MESSAGE and task management 7991da177e4SLinus Torvalds * SCBs. 8001da177e4SLinus Torvalds */ 8011da177e4SLinus Torvalds if ((ahd->bugs & AHD_LQO_ATNO_BUG) != 0) { 8021da177e4SLinus Torvalds /* 8031da177e4SLinus Torvalds * In the A, the LQO manager transitions to LQOSTOP0 even if 8041da177e4SLinus Torvalds * we have selected out with ATN asserted and the target 8051da177e4SLinus Torvalds * REQs in a non-packet phase. 8061da177e4SLinus Torvalds */ 8071da177e4SLinus Torvalds test SCB_CONTROL, MK_MESSAGE jz select_out_no_message; 8081da177e4SLinus Torvalds test SCSISIGO, ATNO jnz select_out_non_packetized; 8091da177e4SLinus Torvaldsselect_out_no_message: 8101da177e4SLinus Torvalds } 8111da177e4SLinus Torvalds test LQOSTAT2, LQOSTOP0 jz select_out_non_packetized; 8121da177e4SLinus Torvalds test SCB_TASK_MANAGEMENT, 0xFF jz idle_loop; 8131da177e4SLinus Torvalds SET_SEQINTCODE(TASKMGMT_FUNC_COMPLETE) 8141da177e4SLinus Torvalds jmp idle_loop; 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvaldsselect_out_non_packetized: 8171da177e4SLinus Torvalds /* Non packetized request. */ 8181da177e4SLinus Torvalds and SCSISEQ0, ~ENSELO; 8191da177e4SLinus Torvalds if ((ahd->bugs & AHD_BUSFREEREV_BUG) != 0) { 8201da177e4SLinus Torvalds /* 8211da177e4SLinus Torvalds * Test to ensure that the bus has not 8221da177e4SLinus Torvalds * already gone free prior to clearing 8231da177e4SLinus Torvalds * any stale busfree status. This avoids 8241da177e4SLinus Torvalds * a window whereby a busfree just after 8251da177e4SLinus Torvalds * a selection could be missed. 8261da177e4SLinus Torvalds */ 8271da177e4SLinus Torvalds test SCSISIGI, BSYI jz . + 2; 8281da177e4SLinus Torvalds mvi CLRSINT1,CLRBUSFREE; 8291da177e4SLinus Torvalds or SIMODE1, ENBUSFREE; 8301da177e4SLinus Torvalds } 8311da177e4SLinus Torvalds mov SAVED_SCSIID, SCB_SCSIID; 8321da177e4SLinus Torvalds mov SAVED_LUN, SCB_LUN; 8331da177e4SLinus Torvalds mvi SEQ_FLAGS, NO_CDB_SENT; 8341da177e4SLinus TorvaldsEND_CRITICAL; 8351da177e4SLinus Torvalds or SXFRCTL0, SPIOEN; 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds /* 8381da177e4SLinus Torvalds * As soon as we get a successful selection, the target 8391da177e4SLinus Torvalds * should go into the message out phase since we have ATN 8401da177e4SLinus Torvalds * asserted. 8411da177e4SLinus Torvalds */ 8421da177e4SLinus Torvalds mvi MSG_OUT, MSG_IDENTIFYFLAG; 8431da177e4SLinus Torvalds 8441da177e4SLinus Torvalds /* 8451da177e4SLinus Torvalds * Main loop for information transfer phases. Wait for the 8461da177e4SLinus Torvalds * target to assert REQ before checking MSG, C/D and I/O for 8471da177e4SLinus Torvalds * the bus phase. 8481da177e4SLinus Torvalds */ 8491da177e4SLinus Torvaldsmesgin_phasemis: 8501da177e4SLinus TorvaldsITloop: 8511da177e4SLinus Torvalds call phase_lock; 8521da177e4SLinus Torvalds 8531da177e4SLinus Torvalds mov A, LASTPHASE; 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds test A, ~P_DATAIN_DT jz p_data; 8561da177e4SLinus Torvalds cmp A,P_COMMAND je p_command; 8571da177e4SLinus Torvalds cmp A,P_MESGOUT je p_mesgout; 8581da177e4SLinus Torvalds cmp A,P_STATUS je p_status; 8591da177e4SLinus Torvalds cmp A,P_MESGIN je p_mesgin; 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds SET_SEQINTCODE(BAD_PHASE) 8621da177e4SLinus Torvalds jmp ITloop; /* Try reading the bus again. */ 8631da177e4SLinus Torvalds 8641da177e4SLinus Torvalds/* 8651da177e4SLinus Torvalds * Command phase. Set up the DMA registers and let 'er rip. 8661da177e4SLinus Torvalds */ 8671da177e4SLinus Torvaldsp_command: 8681da177e4SLinus Torvalds test SEQ_FLAGS, NOT_IDENTIFIED jz p_command_okay; 8691da177e4SLinus Torvalds SET_SEQINTCODE(PROTO_VIOLATION) 8701da177e4SLinus Torvaldsp_command_okay: 8711da177e4SLinus Torvalds test MODE_PTR, ~(MK_MODE(M_DFF1, M_DFF1)) 8721da177e4SLinus Torvalds jnz p_command_allocate_fifo; 8731da177e4SLinus Torvalds /* 8741da177e4SLinus Torvalds * Command retry. Free our current FIFO and 8751da177e4SLinus Torvalds * re-allocate a FIFO so transfer state is 8761da177e4SLinus Torvalds * reset. 8771da177e4SLinus Torvalds */ 8781da177e4SLinus TorvaldsSET_SRC_MODE M_DFF1; 8791da177e4SLinus TorvaldsSET_DST_MODE M_DFF1; 8801da177e4SLinus Torvalds mvi DFFSXFRCTL, RSTCHN|CLRSHCNT; 8811da177e4SLinus Torvalds SET_MODE(M_SCSI, M_SCSI) 8821da177e4SLinus Torvaldsp_command_allocate_fifo: 8831da177e4SLinus Torvalds bmov ALLOCFIFO_SCBPTR, SCBPTR, 2; 8841da177e4SLinus Torvalds call allocate_fifo; 8851da177e4SLinus TorvaldsSET_SRC_MODE M_DFF1; 8861da177e4SLinus TorvaldsSET_DST_MODE M_DFF1; 8871da177e4SLinus Torvalds add NONE, -17, SCB_CDB_LEN; 8881da177e4SLinus Torvalds jnc p_command_embedded; 8891da177e4SLinus Torvaldsp_command_from_host: 8901da177e4SLinus Torvalds bmov HADDR[0], SCB_HOST_CDB_PTR, 9; 8911da177e4SLinus Torvalds mvi SG_CACHE_PRE, LAST_SEG; 8921da177e4SLinus Torvalds mvi DFCNTRL, (PRELOADEN|SCSIEN|HDMAEN); 8931da177e4SLinus Torvalds jmp p_command_xfer; 8941da177e4SLinus Torvaldsp_command_embedded: 8951da177e4SLinus Torvalds bmov SHCNT[0], SCB_CDB_LEN, 1; 8961da177e4SLinus Torvalds bmov DFDAT, SCB_CDB_STORE, 16; 8971da177e4SLinus Torvalds mvi DFCNTRL, SCSIEN; 8981da177e4SLinus Torvaldsp_command_xfer: 8991da177e4SLinus Torvalds and SEQ_FLAGS, ~NO_CDB_SENT; 9001da177e4SLinus Torvalds if ((ahd->features & AHD_FAST_CDB_DELIVERY) != 0) { 9011da177e4SLinus Torvalds /* 9021da177e4SLinus Torvalds * To speed up CDB delivery in Rev B, all CDB acks 9031da177e4SLinus Torvalds * are "released" to the output sync as soon as the 9041da177e4SLinus Torvalds * command phase starts. There is only one problem 9051da177e4SLinus Torvalds * with this approach. If the target changes phase 9061da177e4SLinus Torvalds * before all data are sent, we have left over acks 9071da177e4SLinus Torvalds * that can go out on the bus in a data phase. Due 9081da177e4SLinus Torvalds * to other chip contraints, this only happens if 9091da177e4SLinus Torvalds * the target goes to data-in, but if the acks go 9101da177e4SLinus Torvalds * out before we can test SDONE, we'll think that 9111da177e4SLinus Torvalds * the transfer has completed successfully. Work 9121da177e4SLinus Torvalds * around this by taking advantage of the 400ns or 9131da177e4SLinus Torvalds * 800ns dead time between command phase and the REQ 9141da177e4SLinus Torvalds * of the new phase. If the transfer has completed 9151da177e4SLinus Torvalds * successfully, SCSIEN should fall *long* before we 9161da177e4SLinus Torvalds * see a phase change. We thus treat any phasemiss 9171da177e4SLinus Torvalds * that occurs before SCSIEN falls as an incomplete 9181da177e4SLinus Torvalds * transfer. 9191da177e4SLinus Torvalds */ 9201da177e4SLinus Torvalds test SSTAT1, PHASEMIS jnz p_command_xfer_failed; 9211da177e4SLinus Torvalds test DFCNTRL, SCSIEN jnz . - 1; 9221da177e4SLinus Torvalds } else { 9231da177e4SLinus Torvalds test DFCNTRL, SCSIEN jnz .; 9241da177e4SLinus Torvalds } 9251da177e4SLinus Torvalds /* 9261da177e4SLinus Torvalds * DMA Channel automatically disabled. 9271da177e4SLinus Torvalds * Don't allow a data phase if the command 9281da177e4SLinus Torvalds * was not fully transferred. 9291da177e4SLinus Torvalds */ 9301da177e4SLinus Torvalds test SSTAT2, SDONE jnz ITloop; 9311da177e4SLinus Torvaldsp_command_xfer_failed: 9321da177e4SLinus Torvalds or SEQ_FLAGS, NO_CDB_SENT; 9331da177e4SLinus Torvalds jmp ITloop; 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds 9361da177e4SLinus Torvalds/* 9371da177e4SLinus Torvalds * Status phase. Wait for the data byte to appear, then read it 9381da177e4SLinus Torvalds * and store it into the SCB. 9391da177e4SLinus Torvalds */ 9401da177e4SLinus TorvaldsSET_SRC_MODE M_SCSI; 9411da177e4SLinus TorvaldsSET_DST_MODE M_SCSI; 9421da177e4SLinus Torvaldsp_status: 9431da177e4SLinus Torvalds test SEQ_FLAGS,NOT_IDENTIFIED jnz mesgin_proto_violation; 9441da177e4SLinus Torvaldsp_status_okay: 9451da177e4SLinus Torvalds mov SCB_SCSI_STATUS, SCSIDAT; 9461da177e4SLinus Torvalds or SCB_CONTROL, STATUS_RCVD; 9471da177e4SLinus Torvalds jmp ITloop; 9481da177e4SLinus Torvalds 9491da177e4SLinus Torvalds/* 9501da177e4SLinus Torvalds * Message out phase. If MSG_OUT is MSG_IDENTIFYFLAG, build a full 9511da177e4SLinus Torvalds * indentify message sequence and send it to the target. The host may 9521da177e4SLinus Torvalds * override this behavior by setting the MK_MESSAGE bit in the SCB 9531da177e4SLinus Torvalds * control byte. This will cause us to interrupt the host and allow 9541da177e4SLinus Torvalds * it to handle the message phase completely on its own. If the bit 9551da177e4SLinus Torvalds * associated with this target is set, we will also interrupt the host, 9561da177e4SLinus Torvalds * thereby allowing it to send a message on the next selection regardless 9571da177e4SLinus Torvalds * of the transaction being sent. 9581da177e4SLinus Torvalds * 9591da177e4SLinus Torvalds * If MSG_OUT is == HOST_MSG, also interrupt the host and take a message. 9601da177e4SLinus Torvalds * This is done to allow the host to send messages outside of an identify 9611da177e4SLinus Torvalds * sequence while protecting the seqencer from testing the MK_MESSAGE bit 9621da177e4SLinus Torvalds * on an SCB that might not be for the current nexus. (For example, a 963*25985edcSLucas De Marchi * BDR message in response to a bad reselection would leave us pointed to 9641da177e4SLinus Torvalds * an SCB that doesn't have anything to do with the current target). 9651da177e4SLinus Torvalds * 9661da177e4SLinus Torvalds * Otherwise, treat MSG_OUT as a 1 byte message to send (abort, abort tag, 9671da177e4SLinus Torvalds * bus device reset). 9681da177e4SLinus Torvalds * 9691da177e4SLinus Torvalds * When there are no messages to send, MSG_OUT should be set to MSG_NOOP, 9701da177e4SLinus Torvalds * in case the target decides to put us in this phase for some strange 9711da177e4SLinus Torvalds * reason. 9721da177e4SLinus Torvalds */ 9731da177e4SLinus Torvaldsp_mesgout_retry: 9741da177e4SLinus Torvalds /* Turn on ATN for the retry */ 9751da177e4SLinus Torvalds mvi SCSISIGO, ATNO; 9761da177e4SLinus Torvaldsp_mesgout: 9771da177e4SLinus Torvalds mov SINDEX, MSG_OUT; 9781da177e4SLinus Torvalds cmp SINDEX, MSG_IDENTIFYFLAG jne p_mesgout_from_host; 9791da177e4SLinus Torvalds test SCB_CONTROL,MK_MESSAGE jnz host_message_loop; 9801da177e4SLinus Torvaldsp_mesgout_identify: 9811da177e4SLinus Torvalds or SINDEX, MSG_IDENTIFYFLAG|DISCENB, SCB_LUN; 9821da177e4SLinus Torvalds test SCB_CONTROL, DISCENB jnz . + 2; 9831da177e4SLinus Torvalds and SINDEX, ~DISCENB; 9841da177e4SLinus Torvalds/* 9851da177e4SLinus Torvalds * Send a tag message if TAG_ENB is set in the SCB control block. 9861da177e4SLinus Torvalds * Use SCB_NONPACKET_TAG as the tag value. 9871da177e4SLinus Torvalds */ 9881da177e4SLinus Torvaldsp_mesgout_tag: 9891da177e4SLinus Torvalds test SCB_CONTROL,TAG_ENB jz p_mesgout_onebyte; 9901da177e4SLinus Torvalds mov SCSIDAT, SINDEX; /* Send the identify message */ 9911da177e4SLinus Torvalds call phase_lock; 9921da177e4SLinus Torvalds cmp LASTPHASE, P_MESGOUT jne p_mesgout_done; 9931da177e4SLinus Torvalds and SCSIDAT,TAG_ENB|SCB_TAG_TYPE,SCB_CONTROL; 9941da177e4SLinus Torvalds call phase_lock; 9951da177e4SLinus Torvalds cmp LASTPHASE, P_MESGOUT jne p_mesgout_done; 9961da177e4SLinus Torvalds mov SCBPTR jmp p_mesgout_onebyte; 9971da177e4SLinus Torvalds/* 9981da177e4SLinus Torvalds * Interrupt the driver, and allow it to handle this message 9991da177e4SLinus Torvalds * phase and any required retries. 10001da177e4SLinus Torvalds */ 10011da177e4SLinus Torvaldsp_mesgout_from_host: 10021da177e4SLinus Torvalds cmp SINDEX, HOST_MSG jne p_mesgout_onebyte; 10031da177e4SLinus Torvalds jmp host_message_loop; 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvaldsp_mesgout_onebyte: 10061da177e4SLinus Torvalds mvi CLRSINT1, CLRATNO; 10071da177e4SLinus Torvalds mov SCSIDAT, SINDEX; 10081da177e4SLinus Torvalds 10091da177e4SLinus Torvalds/* 10101da177e4SLinus Torvalds * If the next bus phase after ATN drops is message out, it means 10111da177e4SLinus Torvalds * that the target is requesting that the last message(s) be resent. 10121da177e4SLinus Torvalds */ 10131da177e4SLinus Torvalds call phase_lock; 10141da177e4SLinus Torvalds cmp LASTPHASE, P_MESGOUT je p_mesgout_retry; 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvaldsp_mesgout_done: 10171da177e4SLinus Torvalds mvi CLRSINT1,CLRATNO; /* Be sure to turn ATNO off */ 10181da177e4SLinus Torvalds mov LAST_MSG, MSG_OUT; 10191da177e4SLinus Torvalds mvi MSG_OUT, MSG_NOOP; /* No message left */ 10201da177e4SLinus Torvalds jmp ITloop; 10211da177e4SLinus Torvalds 10221da177e4SLinus Torvalds/* 10231da177e4SLinus Torvalds * Message in phase. Bytes are read using Automatic PIO mode. 10241da177e4SLinus Torvalds */ 10251da177e4SLinus Torvaldsp_mesgin: 10261da177e4SLinus Torvalds /* read the 1st message byte */ 10271da177e4SLinus Torvalds mvi ACCUM call inb_first; 10281da177e4SLinus Torvalds 10291da177e4SLinus Torvalds test A,MSG_IDENTIFYFLAG jnz mesgin_identify; 10301da177e4SLinus Torvalds cmp A,MSG_DISCONNECT je mesgin_disconnect; 10311da177e4SLinus Torvalds cmp A,MSG_SAVEDATAPOINTER je mesgin_sdptrs; 10321da177e4SLinus Torvalds cmp ALLZEROS,A je mesgin_complete; 10331da177e4SLinus Torvalds cmp A,MSG_RESTOREPOINTERS je mesgin_rdptrs; 10341da177e4SLinus Torvalds cmp A,MSG_IGN_WIDE_RESIDUE je mesgin_ign_wide_residue; 10351da177e4SLinus Torvalds cmp A,MSG_NOOP je mesgin_done; 10361da177e4SLinus Torvalds 10371da177e4SLinus Torvalds/* 10381da177e4SLinus Torvalds * Pushed message loop to allow the kernel to 10391da177e4SLinus Torvalds * run it's own message state engine. To avoid an 10401da177e4SLinus Torvalds * extra nop instruction after signaling the kernel, 10411da177e4SLinus Torvalds * we perform the phase_lock before checking to see 10421da177e4SLinus Torvalds * if we should exit the loop and skip the phase_lock 10431da177e4SLinus Torvalds * in the ITloop. Performing back to back phase_locks 10441da177e4SLinus Torvalds * shouldn't hurt, but why do it twice... 10451da177e4SLinus Torvalds */ 10461da177e4SLinus Torvaldshost_message_loop: 10471da177e4SLinus Torvalds call phase_lock; /* Benign the first time through. */ 10481da177e4SLinus Torvalds SET_SEQINTCODE(HOST_MSG_LOOP) 10491da177e4SLinus Torvalds cmp RETURN_1, EXIT_MSG_LOOP je ITloop; 10501da177e4SLinus Torvalds cmp RETURN_1, CONT_MSG_LOOP_WRITE jne . + 3; 10511da177e4SLinus Torvalds mov SCSIDAT, RETURN_2; 10521da177e4SLinus Torvalds jmp host_message_loop; 10531da177e4SLinus Torvalds /* Must be CONT_MSG_LOOP_READ */ 10541da177e4SLinus Torvalds mov NONE, SCSIDAT; /* ACK Byte */ 10551da177e4SLinus Torvalds jmp host_message_loop; 10561da177e4SLinus Torvalds 10571da177e4SLinus Torvaldsmesgin_ign_wide_residue: 10581da177e4SLinus Torvalds mov SAVED_MODE, MODE_PTR; 10591da177e4SLinus Torvalds SET_MODE(M_SCSI, M_SCSI) 10601da177e4SLinus Torvalds shr NEGOADDR, 4, SAVED_SCSIID; 10611da177e4SLinus Torvalds mov A, NEGCONOPTS; 10621da177e4SLinus Torvalds RESTORE_MODE(SAVED_MODE) 10631da177e4SLinus Torvalds test A, WIDEXFER jz mesgin_reject; 10641da177e4SLinus Torvalds /* Pull the residue byte */ 10651da177e4SLinus Torvalds mvi REG0 call inb_next; 10661da177e4SLinus Torvalds cmp REG0, 0x01 jne mesgin_reject; 10671da177e4SLinus Torvalds test SCB_RESIDUAL_SGPTR[0], SG_LIST_NULL jz . + 2; 10681da177e4SLinus Torvalds test SCB_TASK_ATTRIBUTE, SCB_XFERLEN_ODD jnz mesgin_done; 10691da177e4SLinus Torvalds SET_SEQINTCODE(IGN_WIDE_RES) 10701da177e4SLinus Torvalds jmp mesgin_done; 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvaldsmesgin_proto_violation: 10731da177e4SLinus Torvalds SET_SEQINTCODE(PROTO_VIOLATION) 10741da177e4SLinus Torvalds jmp mesgin_done; 10751da177e4SLinus Torvaldsmesgin_reject: 10761da177e4SLinus Torvalds mvi MSG_MESSAGE_REJECT call mk_mesg; 10771da177e4SLinus Torvaldsmesgin_done: 10781da177e4SLinus Torvalds mov NONE,SCSIDAT; /*dummy read from latch to ACK*/ 10791da177e4SLinus Torvalds jmp ITloop; 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds#define INDEX_DISC_LIST(scsiid, lun) \ 10821da177e4SLinus Torvalds and A, 0xC0, scsiid; \ 10831da177e4SLinus Torvalds or SCBPTR, A, lun; \ 10841da177e4SLinus Torvalds clr SCBPTR[1]; \ 10851da177e4SLinus Torvalds and SINDEX, 0x30, scsiid; \ 10861da177e4SLinus Torvalds shr SINDEX, 3; /* Multiply by 2 */ \ 10871da177e4SLinus Torvalds add SINDEX, (SCB_DISCONNECTED_LISTS & 0xFF); \ 10881da177e4SLinus Torvalds mvi SINDEX[1], ((SCB_DISCONNECTED_LISTS >> 8) & 0xFF) 10891da177e4SLinus Torvalds 10901da177e4SLinus Torvaldsmesgin_identify: 10911da177e4SLinus Torvalds /* 10921da177e4SLinus Torvalds * Determine whether a target is using tagged or non-tagged 10931da177e4SLinus Torvalds * transactions by first looking at the transaction stored in 10941da177e4SLinus Torvalds * the per-device, disconnected array. If there is no untagged 10951da177e4SLinus Torvalds * transaction for this target, this must be a tagged transaction. 10961da177e4SLinus Torvalds */ 10971da177e4SLinus Torvalds and SAVED_LUN, MSG_IDENTIFY_LUNMASK, A; 10981da177e4SLinus Torvalds INDEX_DISC_LIST(SAVED_SCSIID, SAVED_LUN); 10991da177e4SLinus Torvalds bmov DINDEX, SINDEX, 2; 11001da177e4SLinus Torvalds bmov REG0, SINDIR, 2; 11011da177e4SLinus Torvalds cmp REG0[1], SCB_LIST_NULL je snoop_tag; 11021da177e4SLinus Torvalds /* Untagged. Clear the busy table entry and setup the SCB. */ 11031da177e4SLinus Torvalds bmov DINDIR, ALLONES, 2; 11041da177e4SLinus Torvalds bmov SCBPTR, REG0, 2; 11051da177e4SLinus Torvalds jmp setup_SCB; 11061da177e4SLinus Torvalds 11071da177e4SLinus Torvalds/* 11081da177e4SLinus Torvalds * Here we "snoop" the bus looking for a SIMPLE QUEUE TAG message. 11091da177e4SLinus Torvalds * If we get one, we use the tag returned to find the proper 11101da177e4SLinus Torvalds * SCB. After receiving the tag, look for the SCB at SCB locations tag and 11111da177e4SLinus Torvalds * tag + 256. 11121da177e4SLinus Torvalds */ 11131da177e4SLinus Torvaldssnoop_tag: 11141da177e4SLinus Torvalds if ((ahd->flags & AHD_SEQUENCER_DEBUG) != 0) { 11151da177e4SLinus Torvalds or SEQ_FLAGS, 0x80; 11161da177e4SLinus Torvalds } 11171da177e4SLinus Torvalds mov NONE, SCSIDAT; /* ACK Identify MSG */ 11181da177e4SLinus Torvalds call phase_lock; 11191da177e4SLinus Torvalds if ((ahd->flags & AHD_SEQUENCER_DEBUG) != 0) { 11201da177e4SLinus Torvalds or SEQ_FLAGS, 0x1; 11211da177e4SLinus Torvalds } 11221da177e4SLinus Torvalds cmp LASTPHASE, P_MESGIN jne not_found_ITloop; 11231da177e4SLinus Torvalds if ((ahd->flags & AHD_SEQUENCER_DEBUG) != 0) { 11241da177e4SLinus Torvalds or SEQ_FLAGS, 0x2; 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds cmp SCSIBUS, MSG_SIMPLE_Q_TAG jne not_found; 11271da177e4SLinus Torvaldsget_tag: 11281da177e4SLinus Torvalds clr SCBPTR[1]; 11291da177e4SLinus Torvalds mvi SCBPTR call inb_next; /* tag value */ 11301da177e4SLinus Torvaldsverify_scb: 11311da177e4SLinus Torvalds test SCB_CONTROL,DISCONNECTED jz verify_other_scb; 11321da177e4SLinus Torvalds mov A, SAVED_SCSIID; 11331da177e4SLinus Torvalds cmp SCB_SCSIID, A jne verify_other_scb; 11341da177e4SLinus Torvalds mov A, SAVED_LUN; 11351da177e4SLinus Torvalds cmp SCB_LUN, A je setup_SCB_disconnected; 11361da177e4SLinus Torvaldsverify_other_scb: 11371da177e4SLinus Torvalds xor SCBPTR[1], 1; 11381da177e4SLinus Torvalds test SCBPTR[1], 0xFF jnz verify_scb; 11391da177e4SLinus Torvalds jmp not_found; 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds/* 11421da177e4SLinus Torvalds * Ensure that the SCB the tag points to is for 11431da177e4SLinus Torvalds * an SCB transaction to the reconnecting target. 11441da177e4SLinus Torvalds */ 11451da177e4SLinus Torvaldssetup_SCB: 11461da177e4SLinus Torvalds if ((ahd->flags & AHD_SEQUENCER_DEBUG) != 0) { 11471da177e4SLinus Torvalds or SEQ_FLAGS, 0x10; 11481da177e4SLinus Torvalds } 11491da177e4SLinus Torvalds test SCB_CONTROL,DISCONNECTED jz not_found; 11501da177e4SLinus Torvaldssetup_SCB_disconnected: 11511da177e4SLinus Torvalds and SCB_CONTROL,~DISCONNECTED; 11521da177e4SLinus Torvalds clr SEQ_FLAGS; /* make note of IDENTIFY */ 11531da177e4SLinus Torvalds test SCB_SGPTR, SG_LIST_NULL jnz . + 3; 11541da177e4SLinus Torvalds bmov ALLOCFIFO_SCBPTR, SCBPTR, 2; 11551da177e4SLinus Torvalds call allocate_fifo; 11561da177e4SLinus Torvalds /* See if the host wants to send a message upon reconnection */ 11571da177e4SLinus Torvalds test SCB_CONTROL, MK_MESSAGE jz mesgin_done; 11581da177e4SLinus Torvalds mvi HOST_MSG call mk_mesg; 11591da177e4SLinus Torvalds jmp mesgin_done; 11601da177e4SLinus Torvalds 11611da177e4SLinus Torvaldsnot_found: 11621da177e4SLinus Torvalds SET_SEQINTCODE(NO_MATCH) 11631da177e4SLinus Torvalds jmp mesgin_done; 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvaldsnot_found_ITloop: 11661da177e4SLinus Torvalds SET_SEQINTCODE(NO_MATCH) 11671da177e4SLinus Torvalds jmp ITloop; 11681da177e4SLinus Torvalds 11691da177e4SLinus Torvalds/* 11701da177e4SLinus Torvalds * We received a "command complete" message. Put the SCB on the complete 11711da177e4SLinus Torvalds * queue and trigger a completion interrupt via the idle loop. Before doing 117211668bb6SHannes Reinecke * so, check to see if there is a residual or the status byte is something 117311668bb6SHannes Reinecke * other than STATUS_GOOD (0). In either of these conditions, we upload the 117411668bb6SHannes Reinecke * SCB back to the host so it can process this information. 11751da177e4SLinus Torvalds */ 11761da177e4SLinus Torvaldsmesgin_complete: 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds /* 11791da177e4SLinus Torvalds * If ATN is raised, we still want to give the target a message. 11801da177e4SLinus Torvalds * Perhaps there was a parity error on this last message byte. 11811da177e4SLinus Torvalds * Either way, the target should take us to message out phase 11821da177e4SLinus Torvalds * and then attempt to complete the command again. We should use a 11831da177e4SLinus Torvalds * critical section here to guard against a timeout triggering 11841da177e4SLinus Torvalds * for this command and setting ATN while we are still processing 11851da177e4SLinus Torvalds * the completion. 11861da177e4SLinus Torvalds test SCSISIGI, ATNI jnz mesgin_done; 11871da177e4SLinus Torvalds */ 11881da177e4SLinus Torvalds 11891da177e4SLinus Torvalds /* 11901da177e4SLinus Torvalds * If we are identified and have successfully sent the CDB, 11911da177e4SLinus Torvalds * any status will do. Optimize this fast path. 11921da177e4SLinus Torvalds */ 11931da177e4SLinus Torvalds test SCB_CONTROL, STATUS_RCVD jz mesgin_proto_violation; 11941da177e4SLinus Torvalds test SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT jz complete_accepted; 11951da177e4SLinus Torvalds 11961da177e4SLinus Torvalds /* 11971da177e4SLinus Torvalds * If the target never sent an identify message but instead went 11981da177e4SLinus Torvalds * to mesgin to give an invalid message, let the host abort us. 11991da177e4SLinus Torvalds */ 12001da177e4SLinus Torvalds test SEQ_FLAGS, NOT_IDENTIFIED jnz mesgin_proto_violation; 12011da177e4SLinus Torvalds 12021da177e4SLinus Torvalds /* 12031da177e4SLinus Torvalds * If we recevied good status but never successfully sent the 12041da177e4SLinus Torvalds * cdb, abort the command. 12051da177e4SLinus Torvalds */ 12061da177e4SLinus Torvalds test SCB_SCSI_STATUS,0xff jnz complete_accepted; 12071da177e4SLinus Torvalds test SEQ_FLAGS, NO_CDB_SENT jnz mesgin_proto_violation; 12081da177e4SLinus Torvaldscomplete_accepted: 12091da177e4SLinus Torvalds 12101da177e4SLinus Torvalds /* 12111da177e4SLinus Torvalds * See if we attempted to deliver a message but the target ingnored us. 12121da177e4SLinus Torvalds */ 12131da177e4SLinus Torvalds test SCB_CONTROL, MK_MESSAGE jz complete_nomsg; 12141da177e4SLinus Torvalds SET_SEQINTCODE(MKMSG_FAILED) 12151da177e4SLinus Torvaldscomplete_nomsg: 12161da177e4SLinus Torvalds call queue_scb_completion; 12171da177e4SLinus Torvalds jmp await_busfree; 12181da177e4SLinus Torvalds 121911668bb6SHannes ReineckeBEGIN_CRITICAL; 12201da177e4SLinus Torvaldsfreeze_queue: 12211da177e4SLinus Torvalds /* Cancel any pending select-out. */ 12221da177e4SLinus Torvalds test SSTAT0, SELDO|SELINGO jnz . + 2; 12231da177e4SLinus Torvalds and SCSISEQ0, ~ENSELO; 12241da177e4SLinus Torvalds mov ACCUM_SAVE, A; 12251da177e4SLinus Torvalds clr A; 12261da177e4SLinus Torvalds add QFREEZE_COUNT, 1; 12271da177e4SLinus Torvalds adc QFREEZE_COUNT[1], A; 12281da177e4SLinus Torvalds or SEQ_FLAGS2, SELECTOUT_QFROZEN; 12291da177e4SLinus Torvalds mov A, ACCUM_SAVE ret; 123011668bb6SHannes ReineckeEND_CRITICAL; 12311da177e4SLinus Torvalds 12321da177e4SLinus Torvalds/* 12331da177e4SLinus Torvalds * Complete the current FIFO's SCB if data for this same 12341da177e4SLinus Torvalds * SCB is not transferring in the other FIFO. 12351da177e4SLinus Torvalds */ 12361da177e4SLinus TorvaldsSET_SRC_MODE M_DFF1; 12371da177e4SLinus TorvaldsSET_DST_MODE M_DFF1; 12381da177e4SLinus Torvaldspkt_complete_scb_if_fifos_idle: 12391da177e4SLinus Torvalds bmov ARG_1, SCBPTR, 2; 12401da177e4SLinus Torvalds mvi DFFSXFRCTL, CLRCHN; 12411da177e4SLinus Torvalds SET_MODE(M_SCSI, M_SCSI) 12421da177e4SLinus Torvalds bmov SCBPTR, ARG_1, 2; 12431da177e4SLinus Torvalds test SCB_FIFO_USE_COUNT, 0xFF jnz return; 12441da177e4SLinus Torvaldsqueue_scb_completion: 12451da177e4SLinus Torvalds test SCB_SCSI_STATUS,0xff jnz bad_status; 12461da177e4SLinus Torvalds /* 12471da177e4SLinus Torvalds * Check for residuals 12481da177e4SLinus Torvalds */ 12491da177e4SLinus Torvalds test SCB_SGPTR, SG_LIST_NULL jnz complete; /* No xfer */ 12501da177e4SLinus Torvalds test SCB_SGPTR, SG_FULL_RESID jnz upload_scb;/* Never xfered */ 12511da177e4SLinus Torvalds test SCB_RESIDUAL_SGPTR, SG_LIST_NULL jz upload_scb; 12521da177e4SLinus Torvaldscomplete: 125311668bb6SHannes ReineckeBEGIN_CRITICAL; 12541da177e4SLinus Torvalds bmov SCB_NEXT_COMPLETE, COMPLETE_SCB_HEAD, 2; 12551da177e4SLinus Torvalds bmov COMPLETE_SCB_HEAD, SCBPTR, 2 ret; 125611668bb6SHannes ReineckeEND_CRITICAL; 12571da177e4SLinus Torvaldsbad_status: 12581da177e4SLinus Torvalds cmp SCB_SCSI_STATUS, STATUS_PKT_SENSE je upload_scb; 12591da177e4SLinus Torvalds call freeze_queue; 12601da177e4SLinus Torvaldsupload_scb: 12611da177e4SLinus Torvalds /* 12621da177e4SLinus Torvalds * Restore SCB TAG since we reuse this field 12631da177e4SLinus Torvalds * in the sequencer. We don't want to corrupt 12641da177e4SLinus Torvalds * it on the host. 12651da177e4SLinus Torvalds */ 12661da177e4SLinus Torvalds bmov SCB_TAG, SCBPTR, 2; 126711668bb6SHannes ReineckeBEGIN_CRITICAL; 126811668bb6SHannes Reinecke or SCB_SGPTR, SG_STATUS_VALID; 126911668bb6SHannes Reinecke mvi SCB_NEXT_COMPLETE[1], SCB_LIST_NULL; 127011668bb6SHannes Reinecke cmp COMPLETE_DMA_SCB_HEAD[1], SCB_LIST_NULL jne add_dma_scb_tail; 12711da177e4SLinus Torvalds bmov COMPLETE_DMA_SCB_HEAD, SCBPTR, 2; 127211668bb6SHannes Reinecke bmov COMPLETE_DMA_SCB_TAIL, SCBPTR, 2 ret; 127311668bb6SHannes Reineckeadd_dma_scb_tail: 127411668bb6SHannes Reinecke bmov REG0, SCBPTR, 2; 127511668bb6SHannes Reinecke bmov SCBPTR, COMPLETE_DMA_SCB_TAIL, 2; 127611668bb6SHannes Reinecke bmov SCB_NEXT_COMPLETE, REG0, 2; 127711668bb6SHannes Reinecke bmov COMPLETE_DMA_SCB_TAIL, REG0, 2 ret; 127811668bb6SHannes ReineckeEND_CRITICAL; 12791da177e4SLinus Torvalds 12801da177e4SLinus Torvalds/* 12811da177e4SLinus Torvalds * Is it a disconnect message? Set a flag in the SCB to remind us 12821da177e4SLinus Torvalds * and await the bus going free. If this is an untagged transaction 12831da177e4SLinus Torvalds * store the SCB id for it in our untagged target table for lookup on 1284b71a8eb0SUwe Kleine-König * a reselection. 12851da177e4SLinus Torvalds */ 12861da177e4SLinus Torvaldsmesgin_disconnect: 12871da177e4SLinus Torvalds /* 12881da177e4SLinus Torvalds * If ATN is raised, we still want to give the target a message. 12891da177e4SLinus Torvalds * Perhaps there was a parity error on this last message byte 12901da177e4SLinus Torvalds * or we want to abort this command. Either way, the target 12911da177e4SLinus Torvalds * should take us to message out phase and then attempt to 12921da177e4SLinus Torvalds * disconnect again. 12931da177e4SLinus Torvalds * XXX - Wait for more testing. 12941da177e4SLinus Torvalds test SCSISIGI, ATNI jnz mesgin_done; 12951da177e4SLinus Torvalds */ 12961da177e4SLinus Torvalds test SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT 12971da177e4SLinus Torvalds jnz mesgin_proto_violation; 12981da177e4SLinus Torvalds or SCB_CONTROL,DISCONNECTED; 12991da177e4SLinus Torvalds test SCB_CONTROL, TAG_ENB jnz await_busfree; 13001da177e4SLinus Torvaldsqueue_disc_scb: 13011da177e4SLinus Torvalds bmov REG0, SCBPTR, 2; 13021da177e4SLinus Torvalds INDEX_DISC_LIST(SAVED_SCSIID, SAVED_LUN); 13031da177e4SLinus Torvalds bmov DINDEX, SINDEX, 2; 13041da177e4SLinus Torvalds bmov DINDIR, REG0, 2; 13051da177e4SLinus Torvalds bmov SCBPTR, REG0, 2; 13061da177e4SLinus Torvalds /* FALLTHROUGH */ 13071da177e4SLinus Torvaldsawait_busfree: 13081da177e4SLinus Torvalds and SIMODE1, ~ENBUSFREE; 13091da177e4SLinus Torvalds if ((ahd->bugs & AHD_BUSFREEREV_BUG) == 0) { 13101da177e4SLinus Torvalds /* 13111da177e4SLinus Torvalds * In the BUSFREEREV_BUG case, the 13121da177e4SLinus Torvalds * busfree status was cleared at the 13131da177e4SLinus Torvalds * beginning of the connection. 13141da177e4SLinus Torvalds */ 13151da177e4SLinus Torvalds mvi CLRSINT1,CLRBUSFREE; 13161da177e4SLinus Torvalds } 13171da177e4SLinus Torvalds mov NONE, SCSIDAT; /* Ack the last byte */ 13181da177e4SLinus Torvalds test MODE_PTR, ~(MK_MODE(M_DFF1, M_DFF1)) 13191da177e4SLinus Torvalds jnz await_busfree_not_m_dff; 13201da177e4SLinus TorvaldsSET_SRC_MODE M_DFF1; 13211da177e4SLinus TorvaldsSET_DST_MODE M_DFF1; 13221da177e4SLinus Torvaldsawait_busfree_clrchn: 13231da177e4SLinus Torvalds mvi DFFSXFRCTL, CLRCHN; 13241da177e4SLinus Torvaldsawait_busfree_not_m_dff: 132511668bb6SHannes Reinecke /* clear target specific flags */ 132611668bb6SHannes Reinecke mvi SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT; 13271da177e4SLinus Torvalds test SSTAT1,REQINIT|BUSFREE jz .; 132811668bb6SHannes Reinecke /* 132911668bb6SHannes Reinecke * We only set BUSFREE status once either a new 133011668bb6SHannes Reinecke * phase has been detected or we are really 133111668bb6SHannes Reinecke * BUSFREE. This allows the driver to know 133211668bb6SHannes Reinecke * that we are active on the bus even though 133311668bb6SHannes Reinecke * no identified transaction exists should a 133411668bb6SHannes Reinecke * timeout occur while awaiting busfree. 133511668bb6SHannes Reinecke */ 133611668bb6SHannes Reinecke mvi LASTPHASE, P_BUSFREE; 13371da177e4SLinus Torvalds test SSTAT1, BUSFREE jnz idle_loop; 13381da177e4SLinus Torvalds SET_SEQINTCODE(MISSED_BUSFREE) 13391da177e4SLinus Torvalds 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds/* 13421da177e4SLinus Torvalds * Save data pointers message: 13431da177e4SLinus Torvalds * Copying RAM values back to SCB, for Save Data Pointers message, but 13441da177e4SLinus Torvalds * only if we've actually been into a data phase to change them. This 13451da177e4SLinus Torvalds * protects against bogus data in scratch ram and the residual counts 13461da177e4SLinus Torvalds * since they are only initialized when we go into data_in or data_out. 13471da177e4SLinus Torvalds * Ack the message as soon as possible. 13481da177e4SLinus Torvalds */ 13491da177e4SLinus TorvaldsSET_SRC_MODE M_DFF1; 13501da177e4SLinus TorvaldsSET_DST_MODE M_DFF1; 13511da177e4SLinus Torvaldsmesgin_sdptrs: 13521da177e4SLinus Torvalds mov NONE,SCSIDAT; /*dummy read from latch to ACK*/ 13531da177e4SLinus Torvalds test SEQ_FLAGS, DPHASE jz ITloop; 13541da177e4SLinus Torvalds call save_pointers; 13551da177e4SLinus Torvalds jmp ITloop; 13561da177e4SLinus Torvalds 13571da177e4SLinus Torvaldssave_pointers: 13581da177e4SLinus Torvalds /* 13591da177e4SLinus Torvalds * If we are asked to save our position at the end of the 13601da177e4SLinus Torvalds * transfer, just mark us at the end rather than perform a 13611da177e4SLinus Torvalds * full save. 13621da177e4SLinus Torvalds */ 13631da177e4SLinus Torvalds test SCB_RESIDUAL_SGPTR[0], SG_LIST_NULL jz save_pointers_full; 13641da177e4SLinus Torvalds or SCB_SGPTR, SG_LIST_NULL ret; 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvaldssave_pointers_full: 13671da177e4SLinus Torvalds /* 13681da177e4SLinus Torvalds * The SCB_DATAPTR becomes the current SHADDR. 13691da177e4SLinus Torvalds * All other information comes directly from our residual 13701da177e4SLinus Torvalds * state. 13711da177e4SLinus Torvalds */ 13721da177e4SLinus Torvalds bmov SCB_DATAPTR, SHADDR, 8; 13731da177e4SLinus Torvalds bmov SCB_DATACNT, SCB_RESIDUAL_DATACNT, 8 ret; 13741da177e4SLinus Torvalds 13751da177e4SLinus Torvalds/* 13761da177e4SLinus Torvalds * Restore pointers message? Data pointers are recopied from the 13771da177e4SLinus Torvalds * SCB anytime we enter a data phase for the first time, so all 13781da177e4SLinus Torvalds * we need to do is clear the DPHASE flag and let the data phase 13791da177e4SLinus Torvalds * code do the rest. We also reset/reallocate the FIFO to make 13801da177e4SLinus Torvalds * sure we have a clean start for the next data or command phase. 13811da177e4SLinus Torvalds */ 13821da177e4SLinus Torvaldsmesgin_rdptrs: 13831da177e4SLinus Torvalds and SEQ_FLAGS, ~DPHASE; 13841da177e4SLinus Torvalds test MODE_PTR, ~(MK_MODE(M_DFF1, M_DFF1)) jnz msgin_rdptrs_get_fifo; 13851da177e4SLinus Torvalds mvi DFFSXFRCTL, RSTCHN|CLRSHCNT; 13861da177e4SLinus Torvalds SET_MODE(M_SCSI, M_SCSI) 13871da177e4SLinus Torvaldsmsgin_rdptrs_get_fifo: 13881da177e4SLinus Torvalds call allocate_fifo; 13891da177e4SLinus Torvalds jmp mesgin_done; 13901da177e4SLinus Torvalds 13911da177e4SLinus Torvaldsphase_lock: 13921da177e4SLinus Torvalds if ((ahd->bugs & AHD_EARLY_REQ_BUG) != 0) { 13931da177e4SLinus Torvalds /* 13941da177e4SLinus Torvalds * Don't ignore persistent REQ assertions just because 13951da177e4SLinus Torvalds * they were asserted within the bus settle delay window. 13961da177e4SLinus Torvalds * This allows us to tolerate devices like the GEM318 13971da177e4SLinus Torvalds * that violate the SCSI spec. We are careful not to 13981da177e4SLinus Torvalds * count REQ while we are waiting for it to fall during 13991da177e4SLinus Torvalds * an async phase due to our asserted ACK. Each 14001da177e4SLinus Torvalds * sequencer instruction takes ~25ns, so the REQ must 14011da177e4SLinus Torvalds * last at least 100ns in order to be counted as a true 14021da177e4SLinus Torvalds * REQ. 14031da177e4SLinus Torvalds */ 14041da177e4SLinus Torvalds test SCSIPHASE, 0xFF jnz phase_locked; 14051da177e4SLinus Torvalds test SCSISIGI, ACKI jnz phase_lock; 14061da177e4SLinus Torvalds test SCSISIGI, REQI jz phase_lock; 14071da177e4SLinus Torvalds test SCSIPHASE, 0xFF jnz phase_locked; 14081da177e4SLinus Torvalds test SCSISIGI, ACKI jnz phase_lock; 14091da177e4SLinus Torvalds test SCSISIGI, REQI jz phase_lock; 14101da177e4SLinus Torvaldsphase_locked: 14111da177e4SLinus Torvalds } else { 14121da177e4SLinus Torvalds test SCSIPHASE, 0xFF jz .; 14131da177e4SLinus Torvalds } 14141da177e4SLinus Torvalds test SSTAT1, SCSIPERR jnz phase_lock; 14151da177e4SLinus Torvaldsphase_lock_latch_phase: 14161da177e4SLinus Torvalds and LASTPHASE, PHASE_MASK, SCSISIGI ret; 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds/* 14191da177e4SLinus Torvalds * Functions to read data in Automatic PIO mode. 14201da177e4SLinus Torvalds * 14211da177e4SLinus Torvalds * An ACK is not sent on input from the target until SCSIDATL is read from. 14221da177e4SLinus Torvalds * So we wait until SCSIDATL is latched (the usual way), then read the data 14231da177e4SLinus Torvalds * byte directly off the bus using SCSIBUSL. When we have pulled the ATN 14241da177e4SLinus Torvalds * line, or we just want to acknowledge the byte, then we do a dummy read 14251da177e4SLinus Torvalds * from SCISDATL. The SCSI spec guarantees that the target will hold the 14261da177e4SLinus Torvalds * data byte on the bus until we send our ACK. 14271da177e4SLinus Torvalds * 14281da177e4SLinus Torvalds * The assumption here is that these are called in a particular sequence, 14291da177e4SLinus Torvalds * and that REQ is already set when inb_first is called. inb_{first,next} 14301da177e4SLinus Torvalds * use the same calling convention as inb. 14311da177e4SLinus Torvalds */ 14321da177e4SLinus Torvaldsinb_next: 14331da177e4SLinus Torvalds mov NONE,SCSIDAT; /*dummy read from latch to ACK*/ 14341da177e4SLinus Torvaldsinb_next_wait: 14351da177e4SLinus Torvalds /* 14361da177e4SLinus Torvalds * If there is a parity error, wait for the kernel to 14371da177e4SLinus Torvalds * see the interrupt and prepare our message response 14381da177e4SLinus Torvalds * before continuing. 14391da177e4SLinus Torvalds */ 14401da177e4SLinus Torvalds test SCSIPHASE, 0xFF jz .; 14411da177e4SLinus Torvalds test SSTAT1, SCSIPERR jnz inb_next_wait; 14421da177e4SLinus Torvaldsinb_next_check_phase: 14431da177e4SLinus Torvalds and LASTPHASE, PHASE_MASK, SCSISIGI; 14441da177e4SLinus Torvalds cmp LASTPHASE, P_MESGIN jne mesgin_phasemis; 14451da177e4SLinus Torvaldsinb_first: 14461da177e4SLinus Torvalds clr DINDEX[1]; 14471da177e4SLinus Torvalds mov DINDEX,SINDEX; 14481da177e4SLinus Torvalds mov DINDIR,SCSIBUS ret; /*read byte directly from bus*/ 14491da177e4SLinus Torvaldsinb_last: 14501da177e4SLinus Torvalds mov NONE,SCSIDAT ret; /*dummy read from latch to ACK*/ 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvaldsmk_mesg: 14531da177e4SLinus Torvalds mvi SCSISIGO, ATNO; 14541da177e4SLinus Torvalds mov MSG_OUT,SINDEX ret; 14551da177e4SLinus Torvalds 14561da177e4SLinus TorvaldsSET_SRC_MODE M_DFF1; 14571da177e4SLinus TorvaldsSET_DST_MODE M_DFF1; 14581da177e4SLinus Torvaldsdisable_ccsgen: 14591da177e4SLinus Torvalds test SG_STATE, FETCH_INPROG jz disable_ccsgen_fetch_done; 14601da177e4SLinus Torvalds clr CCSGCTL; 14611da177e4SLinus Torvaldsdisable_ccsgen_fetch_done: 14621da177e4SLinus Torvalds clr SG_STATE ret; 14631da177e4SLinus Torvalds 14641da177e4SLinus Torvaldsservice_fifo: 14651da177e4SLinus Torvalds /* 14661da177e4SLinus Torvalds * Do we have any prefetch left??? 14671da177e4SLinus Torvalds */ 14681da177e4SLinus Torvalds test SG_STATE, SEGS_AVAIL jnz idle_sg_avail; 14691da177e4SLinus Torvalds 14701da177e4SLinus Torvalds /* 14711da177e4SLinus Torvalds * Can this FIFO have access to the S/G cache yet? 14721da177e4SLinus Torvalds */ 14731da177e4SLinus Torvalds test CCSGCTL, SG_CACHE_AVAIL jz return; 14741da177e4SLinus Torvalds 14751da177e4SLinus Torvalds /* Did we just finish fetching segs? */ 14761da177e4SLinus Torvalds test CCSGCTL, CCSGDONE jnz idle_sgfetch_complete; 14771da177e4SLinus Torvalds 14781da177e4SLinus Torvalds /* Are we actively fetching segments? */ 14791da177e4SLinus Torvalds test CCSGCTL, CCSGENACK jnz return; 14801da177e4SLinus Torvalds 14811da177e4SLinus Torvalds /* 148211668bb6SHannes Reinecke * Should the other FIFO get the S/G cache first? If 148311668bb6SHannes Reinecke * both FIFOs have been allocated since we last checked 148411668bb6SHannes Reinecke * any FIFO, it is important that we service a FIFO 148511668bb6SHannes Reinecke * that is not actively on the bus first. This guarantees 148611668bb6SHannes Reinecke * that a FIFO will be freed to handle snapshot requests for 148711668bb6SHannes Reinecke * any FIFO that is still on the bus. Chips with RTI do not 148811668bb6SHannes Reinecke * perform snapshots, so don't bother with this test there. 148911668bb6SHannes Reinecke */ 149011668bb6SHannes Reinecke if ((ahd->features & AHD_RTI) == 0) { 149111668bb6SHannes Reinecke /* 149211668bb6SHannes Reinecke * If we're not still receiving SCSI data, 149311668bb6SHannes Reinecke * it is safe to allocate the S/G cache to 149411668bb6SHannes Reinecke * this FIFO. 149511668bb6SHannes Reinecke */ 149611668bb6SHannes Reinecke test DFCNTRL, SCSIEN jz idle_sgfetch_start; 149711668bb6SHannes Reinecke 149811668bb6SHannes Reinecke /* 149911668bb6SHannes Reinecke * Switch to the other FIFO. Non-RTI chips 150011668bb6SHannes Reinecke * also have the "set mode" bug, so we must 150111668bb6SHannes Reinecke * disable interrupts during the switch. 150211668bb6SHannes Reinecke */ 150311668bb6SHannes Reinecke mvi SEQINTCTL, INTVEC1DSL; 150411668bb6SHannes Reinecke xor MODE_PTR, MK_MODE(M_DFF1, M_DFF1); 150511668bb6SHannes Reinecke 150611668bb6SHannes Reinecke /* 150711668bb6SHannes Reinecke * If the other FIFO needs loading, then it 150811668bb6SHannes Reinecke * must not have claimed the S/G cache yet 150911668bb6SHannes Reinecke * (SG_CACHE_AVAIL would have been cleared in 1510*25985edcSLucas De Marchi * the original FIFO mode and we test this above). 151111668bb6SHannes Reinecke * Return to the idle loop so we can process the 151211668bb6SHannes Reinecke * FIFO not currently on the bus first. 151311668bb6SHannes Reinecke */ 151411668bb6SHannes Reinecke test SG_STATE, LOADING_NEEDED jz idle_sgfetch_okay; 151511668bb6SHannes Reinecke clr SEQINTCTL ret; 151611668bb6SHannes Reineckeidle_sgfetch_okay: 151711668bb6SHannes Reinecke xor MODE_PTR, MK_MODE(M_DFF1, M_DFF1); 151811668bb6SHannes Reinecke clr SEQINTCTL; 151911668bb6SHannes Reinecke } 152011668bb6SHannes Reinecke 152111668bb6SHannes Reineckeidle_sgfetch_start: 152211668bb6SHannes Reinecke /* 15231da177e4SLinus Torvalds * We fetch a "cacheline aligned" and sized amount of data 1524*25985edcSLucas De Marchi * so we don't end up referencing a non-existent page. 15251da177e4SLinus Torvalds * Cacheline aligned is in quotes because the kernel will 15261da177e4SLinus Torvalds * set the prefetch amount to a reasonable level if the 15271da177e4SLinus Torvalds * cacheline size is unknown. 15281da177e4SLinus Torvalds */ 15291da177e4SLinus Torvalds bmov SGHADDR, SCB_RESIDUAL_SGPTR, 4; 15301da177e4SLinus Torvalds mvi SGHCNT, SG_PREFETCH_CNT; 15311da177e4SLinus Torvalds if ((ahd->bugs & AHD_REG_SLOW_SETTLE_BUG) != 0) { 15321da177e4SLinus Torvalds /* 153311668bb6SHannes Reinecke * Need two instructions between "touches" of SGHADDR. 15341da177e4SLinus Torvalds */ 15351da177e4SLinus Torvalds nop; 15361da177e4SLinus Torvalds } 15371da177e4SLinus Torvalds and SGHADDR[0], SG_PREFETCH_ALIGN_MASK, SCB_RESIDUAL_SGPTR; 15381da177e4SLinus Torvalds mvi CCSGCTL, CCSGEN|CCSGRESET; 15391da177e4SLinus Torvalds or SG_STATE, FETCH_INPROG ret; 15401da177e4SLinus Torvaldsidle_sgfetch_complete: 15411da177e4SLinus Torvalds /* 15421da177e4SLinus Torvalds * Guard against SG_CACHE_AVAIL activating during sg fetch 15431da177e4SLinus Torvalds * request in the other FIFO. 15441da177e4SLinus Torvalds */ 15451da177e4SLinus Torvalds test SG_STATE, FETCH_INPROG jz return; 15461da177e4SLinus Torvalds clr CCSGCTL; 15471da177e4SLinus Torvalds and CCSGADDR, SG_PREFETCH_ADDR_MASK, SCB_RESIDUAL_SGPTR; 15481da177e4SLinus Torvalds mvi SG_STATE, SEGS_AVAIL|LOADING_NEEDED; 15491da177e4SLinus Torvaldsidle_sg_avail: 15501da177e4SLinus Torvalds /* Does the hardware have space for another SG entry? */ 15511da177e4SLinus Torvalds test DFSTATUS, PRELOAD_AVAIL jz return; 15521da177e4SLinus Torvalds /* 15531da177e4SLinus Torvalds * On the A, preloading a segment before HDMAENACK 1554*25985edcSLucas De Marchi * comes true can clobber the shadow address of the 15551da177e4SLinus Torvalds * first segment in the S/G FIFO. Wait until it is 15561da177e4SLinus Torvalds * safe to proceed. 15571da177e4SLinus Torvalds */ 15581da177e4SLinus Torvalds if ((ahd->features & AHD_NEW_DFCNTRL_OPTS) == 0) { 15591da177e4SLinus Torvalds test DFCNTRL, HDMAENACK jz return; 15601da177e4SLinus Torvalds } 15611da177e4SLinus Torvalds if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0) { 15621da177e4SLinus Torvalds bmov HADDR, CCSGRAM, 8; 15631da177e4SLinus Torvalds } else { 15641da177e4SLinus Torvalds bmov HADDR, CCSGRAM, 4; 15651da177e4SLinus Torvalds } 15661da177e4SLinus Torvalds bmov HCNT, CCSGRAM, 3; 15671da177e4SLinus Torvalds bmov SCB_RESIDUAL_DATACNT[3], CCSGRAM, 1; 15681da177e4SLinus Torvalds if ((ahd->flags & AHD_39BIT_ADDRESSING) != 0) { 15691da177e4SLinus Torvalds and HADDR[4], SG_HIGH_ADDR_BITS, SCB_RESIDUAL_DATACNT[3]; 15701da177e4SLinus Torvalds } 15711da177e4SLinus Torvalds if ((ahd->flags & AHD_64BIT_ADDRESSING) != 0) { 15721da177e4SLinus Torvalds /* Skip 4 bytes of pad. */ 15731da177e4SLinus Torvalds add CCSGADDR, 4; 15741da177e4SLinus Torvalds } 15751da177e4SLinus Torvaldssg_advance: 15761da177e4SLinus Torvalds clr A; /* add sizeof(struct scatter) */ 15771da177e4SLinus Torvalds add SCB_RESIDUAL_SGPTR[0],SG_SIZEOF; 15781da177e4SLinus Torvalds adc SCB_RESIDUAL_SGPTR[1],A; 15791da177e4SLinus Torvalds adc SCB_RESIDUAL_SGPTR[2],A; 15801da177e4SLinus Torvalds adc SCB_RESIDUAL_SGPTR[3],A; 15811da177e4SLinus Torvalds mov SINDEX, SCB_RESIDUAL_SGPTR[0]; 15821da177e4SLinus Torvalds test SCB_RESIDUAL_DATACNT[3], SG_LAST_SEG jz . + 3; 15831da177e4SLinus Torvalds or SINDEX, LAST_SEG; 15841da177e4SLinus Torvalds clr SG_STATE; 15851da177e4SLinus Torvalds mov SG_CACHE_PRE, SINDEX; 15861da177e4SLinus Torvalds if ((ahd->features & AHD_NEW_DFCNTRL_OPTS) != 0) { 15871da177e4SLinus Torvalds /* 15881da177e4SLinus Torvalds * Use SCSIENWRDIS so that SCSIEN is never 15891da177e4SLinus Torvalds * modified by this operation. 15901da177e4SLinus Torvalds */ 15911da177e4SLinus Torvalds or DFCNTRL, PRELOADEN|HDMAEN|SCSIENWRDIS; 15921da177e4SLinus Torvalds } else { 15931da177e4SLinus Torvalds or DFCNTRL, PRELOADEN|HDMAEN; 15941da177e4SLinus Torvalds } 15951da177e4SLinus Torvalds /* 15961da177e4SLinus Torvalds * Do we have another segment in the cache? 15971da177e4SLinus Torvalds */ 15981da177e4SLinus Torvalds add NONE, SG_PREFETCH_CNT_LIMIT, CCSGADDR; 15991da177e4SLinus Torvalds jnc return; 16001da177e4SLinus Torvalds and SG_STATE, ~SEGS_AVAIL ret; 16011da177e4SLinus Torvalds 16021da177e4SLinus Torvalds/* 16031da177e4SLinus Torvalds * Initialize the DMA address and counter from the SCB. 16041da177e4SLinus Torvalds */ 16051da177e4SLinus Torvaldsload_first_seg: 16061da177e4SLinus Torvalds bmov HADDR, SCB_DATAPTR, 11; 16071da177e4SLinus Torvalds and REG_ISR, ~SG_FULL_RESID, SCB_SGPTR[0]; 16081da177e4SLinus Torvalds test SCB_DATACNT[3], SG_LAST_SEG jz . + 2; 16091da177e4SLinus Torvalds or REG_ISR, LAST_SEG; 16101da177e4SLinus Torvalds mov SG_CACHE_PRE, REG_ISR; 16111da177e4SLinus Torvalds mvi DFCNTRL, (PRELOADEN|SCSIEN|HDMAEN); 16121da177e4SLinus Torvalds /* 16131da177e4SLinus Torvalds * Since we've are entering a data phase, we will 16141da177e4SLinus Torvalds * rely on the SCB_RESID* fields. Initialize the 16151da177e4SLinus Torvalds * residual and clear the full residual flag. 16161da177e4SLinus Torvalds */ 16171da177e4SLinus Torvalds and SCB_SGPTR[0], ~SG_FULL_RESID; 16181da177e4SLinus Torvalds bmov SCB_RESIDUAL_DATACNT[3], SCB_DATACNT[3], 5; 16191da177e4SLinus Torvalds /* If we need more S/G elements, tell the idle loop */ 16201da177e4SLinus Torvalds test SCB_RESIDUAL_DATACNT[3], SG_LAST_SEG jnz . + 2; 16211da177e4SLinus Torvalds mvi SG_STATE, LOADING_NEEDED ret; 16221da177e4SLinus Torvalds clr SG_STATE ret; 16231da177e4SLinus Torvalds 16241da177e4SLinus Torvaldsp_data_handle_xfer: 16251da177e4SLinus Torvalds call setjmp; 16261da177e4SLinus Torvalds test SG_STATE, LOADING_NEEDED jnz service_fifo; 16271da177e4SLinus Torvaldsp_data_clear_handler: 16281da177e4SLinus Torvalds or LONGJMP_ADDR[1], INVALID_ADDR ret; 16291da177e4SLinus Torvalds 16301da177e4SLinus Torvaldsp_data: 16311da177e4SLinus Torvalds test SEQ_FLAGS, NOT_IDENTIFIED|NO_CDB_SENT jz p_data_allowed; 16321da177e4SLinus Torvalds SET_SEQINTCODE(PROTO_VIOLATION) 16331da177e4SLinus Torvaldsp_data_allowed: 16341da177e4SLinus Torvalds 16351da177e4SLinus Torvalds test SEQ_FLAGS, DPHASE jz data_phase_initialize; 16361da177e4SLinus Torvalds 16371da177e4SLinus Torvalds /* 16381da177e4SLinus Torvalds * If we re-enter the data phase after going through another 16391da177e4SLinus Torvalds * phase, our transfer location has almost certainly been 16401da177e4SLinus Torvalds * corrupted by the interveining, non-data, transfers. Ask 16411da177e4SLinus Torvalds * the host driver to fix us up based on the transfer residual 16421da177e4SLinus Torvalds * unless we already know that we should be bitbucketing. 16431da177e4SLinus Torvalds */ 16441da177e4SLinus Torvalds test SCB_RESIDUAL_SGPTR[0], SG_LIST_NULL jnz p_data_bitbucket; 16451da177e4SLinus Torvalds SET_SEQINTCODE(PDATA_REINIT) 16461da177e4SLinus Torvalds jmp data_phase_inbounds; 16471da177e4SLinus Torvalds 16481da177e4SLinus Torvaldsp_data_bitbucket: 16491da177e4SLinus Torvalds /* 16501da177e4SLinus Torvalds * Turn on `Bit Bucket' mode, wait until the target takes 16511da177e4SLinus Torvalds * us to another phase, and then notify the host. 16521da177e4SLinus Torvalds */ 16531da177e4SLinus Torvalds mov SAVED_MODE, MODE_PTR; 16541da177e4SLinus Torvalds test MODE_PTR, ~(MK_MODE(M_DFF1, M_DFF1)) 16551da177e4SLinus Torvalds jnz bitbucket_not_m_dff; 16561da177e4SLinus Torvalds /* 16571da177e4SLinus Torvalds * Ensure that any FIFO contents are cleared out and the 16581da177e4SLinus Torvalds * FIFO free'd prior to starting the BITBUCKET. BITBUCKET 16591da177e4SLinus Torvalds * doesn't discard data already in the FIFO. 16601da177e4SLinus Torvalds */ 16611da177e4SLinus Torvalds mvi DFFSXFRCTL, RSTCHN|CLRSHCNT; 16621da177e4SLinus Torvalds SET_MODE(M_SCSI, M_SCSI) 16631da177e4SLinus Torvaldsbitbucket_not_m_dff: 16641da177e4SLinus Torvalds or SXFRCTL1,BITBUCKET; 16651da177e4SLinus Torvalds /* Wait for non-data phase. */ 16661da177e4SLinus Torvalds test SCSIPHASE, ~DATA_PHASE_MASK jz .; 16671da177e4SLinus Torvalds and SXFRCTL1, ~BITBUCKET; 16681da177e4SLinus Torvalds RESTORE_MODE(SAVED_MODE) 16691da177e4SLinus TorvaldsSET_SRC_MODE M_DFF1; 16701da177e4SLinus TorvaldsSET_DST_MODE M_DFF1; 16711da177e4SLinus Torvalds SET_SEQINTCODE(DATA_OVERRUN) 16721da177e4SLinus Torvalds jmp ITloop; 16731da177e4SLinus Torvalds 16741da177e4SLinus Torvaldsdata_phase_initialize: 16751da177e4SLinus Torvalds test SCB_SGPTR[0], SG_LIST_NULL jnz p_data_bitbucket; 16761da177e4SLinus Torvalds call load_first_seg; 16771da177e4SLinus Torvaldsdata_phase_inbounds: 16781da177e4SLinus Torvalds /* We have seen a data phase at least once. */ 16791da177e4SLinus Torvalds or SEQ_FLAGS, DPHASE; 16801da177e4SLinus Torvalds mov SAVED_MODE, MODE_PTR; 16811da177e4SLinus Torvalds test SG_STATE, LOADING_NEEDED jz data_group_dma_loop; 16821da177e4SLinus Torvalds call p_data_handle_xfer; 16831da177e4SLinus Torvaldsdata_group_dma_loop: 16841da177e4SLinus Torvalds /* 16851da177e4SLinus Torvalds * The transfer is complete if either the last segment 16861da177e4SLinus Torvalds * completes or the target changes phase. Both conditions 16871da177e4SLinus Torvalds * will clear SCSIEN. 16881da177e4SLinus Torvalds */ 16891da177e4SLinus Torvalds call idle_loop_service_fifos; 16901da177e4SLinus Torvalds call idle_loop_cchan; 16911da177e4SLinus Torvalds call idle_loop_gsfifo; 16921da177e4SLinus Torvalds RESTORE_MODE(SAVED_MODE) 16931da177e4SLinus Torvalds test DFCNTRL, SCSIEN jnz data_group_dma_loop; 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvaldsdata_group_dmafinish: 16961da177e4SLinus Torvalds /* 16971da177e4SLinus Torvalds * The transfer has terminated either due to a phase 16981da177e4SLinus Torvalds * change, and/or the completion of the last segment. 16991da177e4SLinus Torvalds * We have two goals here. Do as much other work 17001da177e4SLinus Torvalds * as possible while the data fifo drains on a read 17011da177e4SLinus Torvalds * and respond as quickly as possible to the standard 17021da177e4SLinus Torvalds * messages (save data pointers/disconnect and command 17031da177e4SLinus Torvalds * complete) that usually follow a data phase. 17041da177e4SLinus Torvalds */ 17051da177e4SLinus Torvalds call calc_residual; 17061da177e4SLinus Torvalds 17071da177e4SLinus Torvalds /* 17081da177e4SLinus Torvalds * Go ahead and shut down the DMA engine now. 17091da177e4SLinus Torvalds */ 17101da177e4SLinus Torvalds test DFCNTRL, DIRECTION jnz data_phase_finish; 17111da177e4SLinus Torvaldsdata_group_fifoflush: 17121da177e4SLinus Torvalds if ((ahd->bugs & AHD_AUTOFLUSH_BUG) != 0) { 17131da177e4SLinus Torvalds or DFCNTRL, FIFOFLUSH; 17141da177e4SLinus Torvalds } 17151da177e4SLinus Torvalds /* 17161da177e4SLinus Torvalds * We have enabled the auto-ack feature. This means 17171da177e4SLinus Torvalds * that the controller may have already transferred 17181da177e4SLinus Torvalds * some overrun bytes into the data FIFO and acked them 17191da177e4SLinus Torvalds * on the bus. The only way to detect this situation is 17201da177e4SLinus Torvalds * to wait for LAST_SEG_DONE to come true on a completed 17211da177e4SLinus Torvalds * transfer and then test to see if the data FIFO is 17221da177e4SLinus Torvalds * non-empty. We know there is more data yet to transfer 17231da177e4SLinus Torvalds * if SG_LIST_NULL is not yet set, thus there cannot be 17241da177e4SLinus Torvalds * an overrun. 17251da177e4SLinus Torvalds */ 17261da177e4SLinus Torvalds test SCB_RESIDUAL_SGPTR[0], SG_LIST_NULL jz data_phase_finish; 17271da177e4SLinus Torvalds test SG_CACHE_SHADOW, LAST_SEG_DONE jz .; 17281da177e4SLinus Torvalds test DFSTATUS, FIFOEMP jnz data_phase_finish; 17291da177e4SLinus Torvalds /* Overrun */ 17301da177e4SLinus Torvalds jmp p_data; 17311da177e4SLinus Torvaldsdata_phase_finish: 17321da177e4SLinus Torvalds /* 17331da177e4SLinus Torvalds * If the target has left us in data phase, loop through 17341da177e4SLinus Torvalds * the dma code again. We will only loop if there is a 17351da177e4SLinus Torvalds * data overrun. 17361da177e4SLinus Torvalds */ 17371da177e4SLinus Torvalds if ((ahd->flags & AHD_TARGETROLE) != 0) { 17381da177e4SLinus Torvalds test SSTAT0, TARGET jnz data_phase_done; 17391da177e4SLinus Torvalds } 17401da177e4SLinus Torvalds if ((ahd->flags & AHD_INITIATORROLE) != 0) { 17411da177e4SLinus Torvalds test SSTAT1, REQINIT jz .; 17421da177e4SLinus Torvalds test SCSIPHASE, DATA_PHASE_MASK jnz p_data; 17431da177e4SLinus Torvalds } 17441da177e4SLinus Torvalds 17451da177e4SLinus Torvaldsdata_phase_done: 17461da177e4SLinus Torvalds /* Kill off any pending prefetch */ 17471da177e4SLinus Torvalds call disable_ccsgen; 17481da177e4SLinus Torvalds or LONGJMP_ADDR[1], INVALID_ADDR; 17491da177e4SLinus Torvalds 17501da177e4SLinus Torvalds if ((ahd->flags & AHD_TARGETROLE) != 0) { 17511da177e4SLinus Torvalds test SEQ_FLAGS, DPHASE_PENDING jz ITloop; 17521da177e4SLinus Torvalds /* 17531da177e4SLinus Torvalds and SEQ_FLAGS, ~DPHASE_PENDING; 17541da177e4SLinus Torvalds * For data-in phases, wait for any pending acks from the 17551da177e4SLinus Torvalds * initiator before changing phase. We only need to 17561da177e4SLinus Torvalds * send Ignore Wide Residue messages for data-in phases. 17571da177e4SLinus Torvalds test DFCNTRL, DIRECTION jz target_ITloop; 17581da177e4SLinus Torvalds test SSTAT1, REQINIT jnz .; 17591da177e4SLinus Torvalds test SCB_TASK_ATTRIBUTE, SCB_XFERLEN_ODD jz target_ITloop; 17601da177e4SLinus Torvalds SET_MODE(M_SCSI, M_SCSI) 17611da177e4SLinus Torvalds test NEGCONOPTS, WIDEXFER jz target_ITloop; 17621da177e4SLinus Torvalds */ 17631da177e4SLinus Torvalds /* 17641da177e4SLinus Torvalds * Issue an Ignore Wide Residue Message. 17651da177e4SLinus Torvalds mvi P_MESGIN|BSYO call change_phase; 17661da177e4SLinus Torvalds mvi MSG_IGN_WIDE_RESIDUE call target_outb; 17671da177e4SLinus Torvalds mvi 1 call target_outb; 17681da177e4SLinus Torvalds jmp target_ITloop; 17691da177e4SLinus Torvalds */ 17701da177e4SLinus Torvalds } else { 17711da177e4SLinus Torvalds jmp ITloop; 17721da177e4SLinus Torvalds } 17731da177e4SLinus Torvalds 17741da177e4SLinus Torvalds/* 17751da177e4SLinus Torvalds * We assume that, even though data may still be 17761da177e4SLinus Torvalds * transferring to the host, that the SCSI side of 17771da177e4SLinus Torvalds * the DMA engine is now in a static state. This 17781da177e4SLinus Torvalds * allows us to update our notion of where we are 17791da177e4SLinus Torvalds * in this transfer. 17801da177e4SLinus Torvalds * 17811da177e4SLinus Torvalds * If, by chance, we stopped before being able 17821da177e4SLinus Torvalds * to fetch additional segments for this transfer, 17831da177e4SLinus Torvalds * yet the last S/G was completely exhausted, 17841da177e4SLinus Torvalds * call our idle loop until it is able to load 17851da177e4SLinus Torvalds * another segment. This will allow us to immediately 17861da177e4SLinus Torvalds * pickup on the next segment on the next data phase. 17871da177e4SLinus Torvalds * 17881da177e4SLinus Torvalds * If we happened to stop on the last segment, then 17891da177e4SLinus Torvalds * our residual information is still correct from 17901da177e4SLinus Torvalds * the idle loop and there is no need to perform 17911da177e4SLinus Torvalds * any fixups. 17921da177e4SLinus Torvalds */ 17931da177e4SLinus Torvaldsresidual_before_last_seg: 17941da177e4SLinus Torvalds test MDFFSTAT, SHVALID jnz sgptr_fixup; 17951da177e4SLinus Torvalds /* 17961da177e4SLinus Torvalds * Can never happen from an interrupt as the packetized 17971da177e4SLinus Torvalds * hardware will only interrupt us once SHVALID or 17981da177e4SLinus Torvalds * LAST_SEG_DONE. 17991da177e4SLinus Torvalds */ 18001da177e4SLinus Torvalds call idle_loop_service_fifos; 18011da177e4SLinus Torvalds RESTORE_MODE(SAVED_MODE) 18021da177e4SLinus Torvalds /* FALLTHROUGH */ 18031da177e4SLinus Torvaldscalc_residual: 18041da177e4SLinus Torvalds test SG_CACHE_SHADOW, LAST_SEG jz residual_before_last_seg; 18051da177e4SLinus Torvalds /* Record if we've consumed all S/G entries */ 18061da177e4SLinus Torvalds test MDFFSTAT, SHVALID jz . + 2; 18071da177e4SLinus Torvalds bmov SCB_RESIDUAL_DATACNT, SHCNT, 3 ret; 18081da177e4SLinus Torvalds or SCB_RESIDUAL_SGPTR[0], SG_LIST_NULL ret; 18091da177e4SLinus Torvalds 18101da177e4SLinus Torvaldssgptr_fixup: 18111da177e4SLinus Torvalds /* 18121da177e4SLinus Torvalds * Fixup the residual next S/G pointer. The S/G preload 18131da177e4SLinus Torvalds * feature of the chip allows us to load two elements 18141da177e4SLinus Torvalds * in addition to the currently active element. We 18151da177e4SLinus Torvalds * store the bottom byte of the next S/G pointer in 18161da177e4SLinus Torvalds * the SG_CACHE_PTR register so we can restore the 18171da177e4SLinus Torvalds * correct value when the DMA completes. If the next 18181da177e4SLinus Torvalds * sg ptr value has advanced to the point where higher 18191da177e4SLinus Torvalds * bytes in the address have been affected, fix them 18201da177e4SLinus Torvalds * too. 18211da177e4SLinus Torvalds */ 18221da177e4SLinus Torvalds test SG_CACHE_SHADOW, 0x80 jz sgptr_fixup_done; 18231da177e4SLinus Torvalds test SCB_RESIDUAL_SGPTR[0], 0x80 jnz sgptr_fixup_done; 18241da177e4SLinus Torvalds add SCB_RESIDUAL_SGPTR[1], -1; 18251da177e4SLinus Torvalds adc SCB_RESIDUAL_SGPTR[2], -1; 18261da177e4SLinus Torvalds adc SCB_RESIDUAL_SGPTR[3], -1; 18271da177e4SLinus Torvaldssgptr_fixup_done: 18281da177e4SLinus Torvalds and SCB_RESIDUAL_SGPTR[0], SG_ADDR_MASK, SG_CACHE_SHADOW; 18291da177e4SLinus Torvalds clr SCB_RESIDUAL_DATACNT[3]; /* We are not the last seg */ 18301da177e4SLinus Torvalds bmov SCB_RESIDUAL_DATACNT, SHCNT, 3 ret; 18311da177e4SLinus Torvalds 18321da177e4SLinus Torvaldsexport timer_isr: 18331da177e4SLinus Torvalds call issue_cmdcmplt; 18341da177e4SLinus Torvalds mvi CLRSEQINTSTAT, CLRSEQ_SWTMRTO; 18351da177e4SLinus Torvalds if ((ahd->bugs & AHD_SET_MODE_BUG) != 0) { 18361da177e4SLinus Torvalds /* 18371da177e4SLinus Torvalds * In H2A4, the mode pointer is not saved 18381da177e4SLinus Torvalds * for intvec2, but is restored on iret. 18391da177e4SLinus Torvalds * This can lead to the restoration of a 18401da177e4SLinus Torvalds * bogus mode ptr. Manually clear the 18411da177e4SLinus Torvalds * intmask bits and do a normal return 18421da177e4SLinus Torvalds * to compensate. 18431da177e4SLinus Torvalds */ 18441da177e4SLinus Torvalds and SEQINTCTL, ~(INTMASK2|INTMASK1) ret; 18451da177e4SLinus Torvalds } else { 18461da177e4SLinus Torvalds or SEQINTCTL, IRET ret; 18471da177e4SLinus Torvalds } 18481da177e4SLinus Torvalds 18491da177e4SLinus Torvaldsexport seq_isr: 18501da177e4SLinus Torvalds if ((ahd->features & AHD_RTI) == 0) { 18511da177e4SLinus Torvalds /* 18521da177e4SLinus Torvalds * On RevA Silicon, if the target returns us to data-out 18531da177e4SLinus Torvalds * after we have already trained for data-out, it is 18541da177e4SLinus Torvalds * possible for us to transition the free running clock to 18551da177e4SLinus Torvalds * data-valid before the required 100ns P1 setup time (8 P1 18561da177e4SLinus Torvalds * assertions in fast-160 mode). This will only happen if 18571da177e4SLinus Torvalds * this L-Q is a continuation of a data transfer for which 18581da177e4SLinus Torvalds * we have already prefetched data into our FIFO (LQ/Data 18591da177e4SLinus Torvalds * followed by LQ/Data for the same write transaction). 18601da177e4SLinus Torvalds * This can cause some target implementations to miss the 18611da177e4SLinus Torvalds * first few data transfers on the bus. We detect this 18621da177e4SLinus Torvalds * situation by noticing that this is the first data transfer 18631da177e4SLinus Torvalds * after an LQ (LQIWORKONLQ true), that the data transfer is 18641da177e4SLinus Torvalds * a continuation of a transfer already setup in our FIFO 18651da177e4SLinus Torvalds * (SAVEPTRS interrupt), and that the transaction is a write 18661da177e4SLinus Torvalds * (DIRECTION set in DFCNTRL). The delay is performed by 18671da177e4SLinus Torvalds * disabling SCSIEN until we see the first REQ from the 18681da177e4SLinus Torvalds * target. 18691da177e4SLinus Torvalds * 18701da177e4SLinus Torvalds * First instruction in an ISR cannot be a branch on 18711da177e4SLinus Torvalds * Rev A. Snapshot LQISTAT2 so the status is not missed 18721da177e4SLinus Torvalds * and deffer the test by one instruction. 18731da177e4SLinus Torvalds */ 18741da177e4SLinus Torvalds mov REG_ISR, LQISTAT2; 18751da177e4SLinus Torvalds test REG_ISR, LQIWORKONLQ jz main_isr; 18761da177e4SLinus Torvalds test SEQINTSRC, SAVEPTRS jz main_isr; 18771da177e4SLinus Torvalds test LONGJMP_ADDR[1], INVALID_ADDR jz saveptr_active_fifo; 18781da177e4SLinus Torvalds /* 18791da177e4SLinus Torvalds * Switch to the active FIFO after clearing the snapshot 18801da177e4SLinus Torvalds * savepointer in the current FIFO. We do this so that 18811da177e4SLinus Torvalds * a pending CTXTDONE or SAVEPTR is visible in the active 18821da177e4SLinus Torvalds * FIFO. This status is the only way we can detect if we 188311668bb6SHannes Reinecke * have lost the race (e.g. host paused us) and our attempts 18841da177e4SLinus Torvalds * to disable the channel occurred after all REQs were 18851da177e4SLinus Torvalds * already seen and acked (REQINIT never comes true). 18861da177e4SLinus Torvalds */ 18871da177e4SLinus Torvalds mvi DFFSXFRCTL, CLRCHN; 18881da177e4SLinus Torvalds xor MODE_PTR, MK_MODE(M_DFF1, M_DFF1); 18891da177e4SLinus Torvalds test DFCNTRL, DIRECTION jz interrupt_return; 18901da177e4SLinus Torvalds and DFCNTRL, ~SCSIEN; 18911da177e4SLinus Torvaldssnapshot_wait_data_valid: 189211668bb6SHannes Reinecke test SEQINTSRC, (CTXTDONE|SAVEPTRS) jnz interrupt_return; 18931da177e4SLinus Torvalds test SSTAT1, REQINIT jz snapshot_wait_data_valid; 18941da177e4SLinus Torvaldssnapshot_data_valid: 18951da177e4SLinus Torvalds or DFCNTRL, SCSIEN; 18961da177e4SLinus Torvalds or SEQINTCTL, IRET ret; 18971da177e4SLinus Torvaldssnapshot_saveptr: 18981da177e4SLinus Torvalds mvi DFFSXFRCTL, CLRCHN; 18991da177e4SLinus Torvalds or SEQINTCTL, IRET ret; 19001da177e4SLinus Torvaldsmain_isr: 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds test SEQINTSRC, CFG4DATA jnz cfg4data_intr; 19031da177e4SLinus Torvalds test SEQINTSRC, CFG4ISTAT jnz cfg4istat_intr; 19041da177e4SLinus Torvalds test SEQINTSRC, SAVEPTRS jnz saveptr_intr; 19051da177e4SLinus Torvalds test SEQINTSRC, CFG4ICMD jnz cfg4icmd_intr; 19061da177e4SLinus Torvalds SET_SEQINTCODE(INVALID_SEQINT) 19071da177e4SLinus Torvalds 19081da177e4SLinus Torvalds/* 19091da177e4SLinus Torvalds * There are two types of save pointers interrupts: 19101da177e4SLinus Torvalds * The first is a snapshot save pointers where the current FIFO is not 19111da177e4SLinus Torvalds * active and contains a snapshot of the current poniter information. 19121da177e4SLinus Torvalds * This happens between packets in a stream for a single L_Q. Since we 19131da177e4SLinus Torvalds * are not performing a pointer save, we can safely clear the channel 19141da177e4SLinus Torvalds * so it can be used for other transactions. On RTI capable controllers, 19151da177e4SLinus Torvalds * where snapshots can, and are, disabled, the code to handle this type 19161da177e4SLinus Torvalds * of snapshot is not active. 19171da177e4SLinus Torvalds * 19181da177e4SLinus Torvalds * The second case is a save pointers on an active FIFO which occurs 19191da177e4SLinus Torvalds * if the target changes to a new L_Q or busfrees/QASes and the transfer 19201da177e4SLinus Torvalds * has a residual. This should occur coincident with a ctxtdone. We 19211da177e4SLinus Torvalds * disable the interrupt and allow our active routine to handle the 19221da177e4SLinus Torvalds * save. 19231da177e4SLinus Torvalds */ 19241da177e4SLinus Torvaldssaveptr_intr: 19251da177e4SLinus Torvalds if ((ahd->features & AHD_RTI) == 0) { 19261da177e4SLinus Torvalds test LONGJMP_ADDR[1], INVALID_ADDR jnz snapshot_saveptr; 19271da177e4SLinus Torvalds } 19281da177e4SLinus Torvaldssaveptr_active_fifo: 19291da177e4SLinus Torvalds and SEQIMODE, ~ENSAVEPTRS; 19301da177e4SLinus Torvalds or SEQINTCTL, IRET ret; 19311da177e4SLinus Torvalds 19321da177e4SLinus Torvaldscfg4data_intr: 19331da177e4SLinus Torvalds test SCB_SGPTR[0], SG_LIST_NULL jnz pkt_handle_overrun_inc_use_count; 19341da177e4SLinus Torvalds call load_first_seg; 19351da177e4SLinus Torvalds call pkt_handle_xfer; 19361da177e4SLinus Torvalds inc SCB_FIFO_USE_COUNT; 19371da177e4SLinus Torvaldsinterrupt_return: 19381da177e4SLinus Torvalds or SEQINTCTL, IRET ret; 19391da177e4SLinus Torvalds 19401da177e4SLinus Torvaldscfg4istat_intr: 19411da177e4SLinus Torvalds call freeze_queue; 19421da177e4SLinus Torvalds add NONE, -13, SCB_CDB_LEN; 19431da177e4SLinus Torvalds jnc cfg4istat_have_sense_addr; 19441da177e4SLinus Torvalds test SCB_CDB_LEN, SCB_CDB_LEN_PTR jnz cfg4istat_have_sense_addr; 19451da177e4SLinus Torvalds /* 19461da177e4SLinus Torvalds * Host sets up address/count and enables transfer. 19471da177e4SLinus Torvalds */ 19481da177e4SLinus Torvalds SET_SEQINTCODE(CFG4ISTAT_INTR) 19491da177e4SLinus Torvalds jmp cfg4istat_setup_handler; 19501da177e4SLinus Torvaldscfg4istat_have_sense_addr: 19511da177e4SLinus Torvalds bmov HADDR, SCB_SENSE_BUSADDR, 4; 19521da177e4SLinus Torvalds mvi HCNT[1], (AHD_SENSE_BUFSIZE >> 8); 19531da177e4SLinus Torvalds mvi SG_CACHE_PRE, LAST_SEG; 19541da177e4SLinus Torvalds mvi DFCNTRL, PRELOADEN|SCSIEN|HDMAEN; 19551da177e4SLinus Torvaldscfg4istat_setup_handler: 19561da177e4SLinus Torvalds /* 19571da177e4SLinus Torvalds * Status pkt is transferring to host. 19581da177e4SLinus Torvalds * Wait in idle loop for transfer to complete. 19591da177e4SLinus Torvalds * If a command completed before an attempted 19601da177e4SLinus Torvalds * task management function completed, notify the host. 19611da177e4SLinus Torvalds */ 19621da177e4SLinus Torvalds test SCB_TASK_MANAGEMENT, 0xFF jz cfg4istat_no_taskmgmt_func; 19631da177e4SLinus Torvalds SET_SEQINTCODE(TASKMGMT_CMD_CMPLT_OKAY) 19641da177e4SLinus Torvaldscfg4istat_no_taskmgmt_func: 19651da177e4SLinus Torvalds call pkt_handle_status; 19661da177e4SLinus Torvalds or SEQINTCTL, IRET ret; 19671da177e4SLinus Torvalds 19681da177e4SLinus Torvaldscfg4icmd_intr: 19691da177e4SLinus Torvalds /* 19701da177e4SLinus Torvalds * In the case of DMAing a CDB from the host, the normal 19711da177e4SLinus Torvalds * CDB buffer is formatted with an 8 byte address followed 19721da177e4SLinus Torvalds * by a 1 byte count. 19731da177e4SLinus Torvalds */ 19741da177e4SLinus Torvalds bmov HADDR[0], SCB_HOST_CDB_PTR, 9; 19751da177e4SLinus Torvalds mvi SG_CACHE_PRE, LAST_SEG; 19761da177e4SLinus Torvalds mvi DFCNTRL, (PRELOADEN|SCSIEN|HDMAEN); 19771da177e4SLinus Torvalds call pkt_handle_cdb; 19781da177e4SLinus Torvalds or SEQINTCTL, IRET ret; 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds/* 19811da177e4SLinus Torvalds * See if the target has gone on in this context creating an 19821da177e4SLinus Torvalds * overrun condition. For the write case, the hardware cannot 19831da177e4SLinus Torvalds * ack bytes until data are provided. So, if the target begins 19841da177e4SLinus Torvalds * another packet without changing contexts, implying we are 19851da177e4SLinus Torvalds * not sitting on a packet boundary, we are in an overrun 19861da177e4SLinus Torvalds * situation. For the read case, the hardware will continue to 19871da177e4SLinus Torvalds * ack bytes into the FIFO, and may even ack the last overrun packet 19881da177e4SLinus Torvalds * into the FIFO. If the FIFO should become non-empty, we are in 19891da177e4SLinus Torvalds * a read overrun case. 19901da177e4SLinus Torvalds */ 19911da177e4SLinus Torvalds#define check_overrun \ 19921da177e4SLinus Torvalds /* Not on a packet boundary. */ \ 19931da177e4SLinus Torvalds test MDFFSTAT, DLZERO jz pkt_handle_overrun; \ 19941da177e4SLinus Torvalds test DFSTATUS, FIFOEMP jz pkt_handle_overrun 19951da177e4SLinus Torvalds 19961da177e4SLinus Torvaldspkt_handle_xfer: 19971da177e4SLinus Torvalds test SG_STATE, LOADING_NEEDED jz pkt_last_seg; 19981da177e4SLinus Torvalds call setjmp; 19991da177e4SLinus Torvalds test SEQINTSRC, SAVEPTRS jnz pkt_saveptrs; 20001da177e4SLinus Torvalds test SCSIPHASE, ~DATA_PHASE_MASK jz . + 2; 20011da177e4SLinus Torvalds test SCSISIGO, ATNO jnz . + 2; 20021da177e4SLinus Torvalds test SSTAT2, NONPACKREQ jz pkt_service_fifo; 20031da177e4SLinus Torvalds /* 20041da177e4SLinus Torvalds * Defer handling of this NONPACKREQ until we 20051da177e4SLinus Torvalds * can be sure it pertains to this FIFO. SAVEPTRS 20061da177e4SLinus Torvalds * will not be asserted if the NONPACKREQ is for us, 2007*25985edcSLucas De Marchi * so we must simulate it if shadow is valid. If 2008*25985edcSLucas De Marchi * shadow is not valid, keep running this FIFO until we 20091da177e4SLinus Torvalds * have satisfied the transfer by loading segments and 2010*25985edcSLucas De Marchi * waiting for either shadow valid or last_seg_done. 20111da177e4SLinus Torvalds */ 20121da177e4SLinus Torvalds test MDFFSTAT, SHVALID jnz pkt_saveptrs; 20131da177e4SLinus Torvaldspkt_service_fifo: 20141da177e4SLinus Torvalds test SG_STATE, LOADING_NEEDED jnz service_fifo; 20151da177e4SLinus Torvaldspkt_last_seg: 20161da177e4SLinus Torvalds call setjmp; 20171da177e4SLinus Torvalds test SEQINTSRC, SAVEPTRS jnz pkt_saveptrs; 20181da177e4SLinus Torvalds test SG_CACHE_SHADOW, LAST_SEG_DONE jnz pkt_last_seg_done; 20191da177e4SLinus Torvalds test SCSIPHASE, ~DATA_PHASE_MASK jz . + 2; 20201da177e4SLinus Torvalds test SCSISIGO, ATNO jnz . + 2; 20211da177e4SLinus Torvalds test SSTAT2, NONPACKREQ jz return; 20221da177e4SLinus Torvalds test MDFFSTAT, SHVALID jz return; 20231da177e4SLinus Torvalds /* FALLTHROUGH */ 20241da177e4SLinus Torvalds 20251da177e4SLinus Torvalds/* 20261da177e4SLinus Torvalds * Either a SAVEPTRS interrupt condition is pending for this FIFO 20271da177e4SLinus Torvalds * or we have a pending NONPACKREQ for this FIFO. We differentiate 20281da177e4SLinus Torvalds * between the two by capturing the state of the SAVEPTRS interrupt 20291da177e4SLinus Torvalds * prior to clearing this status and executing the common code for 20301da177e4SLinus Torvalds * these two cases. 20311da177e4SLinus Torvalds */ 20321da177e4SLinus Torvaldspkt_saveptrs: 20331da177e4SLinus TorvaldsBEGIN_CRITICAL; 20341da177e4SLinus Torvalds if ((ahd->bugs & AHD_AUTOFLUSH_BUG) != 0) { 20351da177e4SLinus Torvalds or DFCNTRL, FIFOFLUSH; 20361da177e4SLinus Torvalds } 20371da177e4SLinus Torvalds mov REG0, SEQINTSRC; 20381da177e4SLinus Torvalds call calc_residual; 20391da177e4SLinus Torvalds call save_pointers; 20401da177e4SLinus Torvalds mvi CLRSEQINTSRC, CLRSAVEPTRS; 20411da177e4SLinus Torvalds call disable_ccsgen; 20421da177e4SLinus Torvalds or SEQIMODE, ENSAVEPTRS; 20431da177e4SLinus Torvalds test DFCNTRL, DIRECTION jnz pkt_saveptrs_check_status; 20441da177e4SLinus Torvalds test DFSTATUS, FIFOEMP jnz pkt_saveptrs_check_status; 20451da177e4SLinus Torvalds /* 20461da177e4SLinus Torvalds * Keep a handler around for this FIFO until it drains 20471da177e4SLinus Torvalds * to the host to guarantee that we don't complete the 20481da177e4SLinus Torvalds * command to the host before the data arrives. 20491da177e4SLinus Torvalds */ 20501da177e4SLinus Torvaldspkt_saveptrs_wait_fifoemp: 20511da177e4SLinus Torvalds call setjmp; 20521da177e4SLinus Torvalds test DFSTATUS, FIFOEMP jz return; 20531da177e4SLinus Torvaldspkt_saveptrs_check_status: 20541da177e4SLinus Torvalds or LONGJMP_ADDR[1], INVALID_ADDR; 20551da177e4SLinus Torvalds test REG0, SAVEPTRS jz unexpected_nonpkt_phase; 20561da177e4SLinus Torvalds dec SCB_FIFO_USE_COUNT; 20571da177e4SLinus Torvalds test SCB_CONTROL, STATUS_RCVD jnz pkt_complete_scb_if_fifos_idle; 20581da177e4SLinus Torvalds mvi DFFSXFRCTL, CLRCHN ret; 20591da177e4SLinus Torvalds 20601da177e4SLinus Torvalds/* 20611da177e4SLinus Torvalds * LAST_SEG_DONE status has been seen in the current FIFO. 20621da177e4SLinus Torvalds * This indicates that all of the allowed data for this 20631da177e4SLinus Torvalds * command has transferred across the SCSI and host buses. 20641da177e4SLinus Torvalds * Check for overrun and see if we can complete this command. 20651da177e4SLinus Torvalds */ 20661da177e4SLinus Torvaldspkt_last_seg_done: 20671da177e4SLinus Torvalds /* 20681da177e4SLinus Torvalds * Mark transfer as completed. 20691da177e4SLinus Torvalds */ 20701da177e4SLinus Torvalds or SCB_SGPTR, SG_LIST_NULL; 20711da177e4SLinus Torvalds 20721da177e4SLinus Torvalds /* 20731da177e4SLinus Torvalds * Wait for the current context to finish to verify that 20741da177e4SLinus Torvalds * no overrun condition has occurred. 20751da177e4SLinus Torvalds */ 20761da177e4SLinus Torvalds test SEQINTSRC, CTXTDONE jnz pkt_ctxt_done; 20771da177e4SLinus Torvalds call setjmp; 20781da177e4SLinus Torvaldspkt_wait_ctxt_done_loop: 20791da177e4SLinus Torvalds test SEQINTSRC, CTXTDONE jnz pkt_ctxt_done; 20801da177e4SLinus Torvalds /* 20811da177e4SLinus Torvalds * A sufficiently large overrun or a NONPACKREQ may 20821da177e4SLinus Torvalds * prevent CTXTDONE from ever asserting, so we must 20831da177e4SLinus Torvalds * poll for these statuses too. 20841da177e4SLinus Torvalds */ 20851da177e4SLinus Torvalds check_overrun; 20861da177e4SLinus Torvalds test SSTAT2, NONPACKREQ jz return; 20871da177e4SLinus Torvalds test SEQINTSRC, CTXTDONE jz unexpected_nonpkt_phase; 20881da177e4SLinus Torvalds /* FALLTHROUGH */ 20891da177e4SLinus Torvalds 20901da177e4SLinus Torvaldspkt_ctxt_done: 20911da177e4SLinus Torvalds check_overrun; 20921da177e4SLinus Torvalds or LONGJMP_ADDR[1], INVALID_ADDR; 20931da177e4SLinus Torvalds /* 20941da177e4SLinus Torvalds * If status has been received, it is safe to skip 20951da177e4SLinus Torvalds * the check to see if another FIFO is active because 20961da177e4SLinus Torvalds * LAST_SEG_DONE has been observed. However, we check 20971da177e4SLinus Torvalds * the FIFO anyway since it costs us only one extra 20981da177e4SLinus Torvalds * instruction to leverage common code to perform the 20991da177e4SLinus Torvalds * SCB completion. 21001da177e4SLinus Torvalds */ 21011da177e4SLinus Torvalds dec SCB_FIFO_USE_COUNT; 21021da177e4SLinus Torvalds test SCB_CONTROL, STATUS_RCVD jnz pkt_complete_scb_if_fifos_idle; 21031da177e4SLinus Torvalds mvi DFFSXFRCTL, CLRCHN ret; 21041da177e4SLinus TorvaldsEND_CRITICAL; 21051da177e4SLinus Torvalds 21061da177e4SLinus Torvalds/* 21071da177e4SLinus Torvalds * Must wait until CDB xfer is over before issuing the 21081da177e4SLinus Torvalds * clear channel. 21091da177e4SLinus Torvalds */ 21101da177e4SLinus Torvaldspkt_handle_cdb: 21111da177e4SLinus Torvalds call setjmp; 21121da177e4SLinus Torvalds test SG_CACHE_SHADOW, LAST_SEG_DONE jz return; 21131da177e4SLinus Torvalds or LONGJMP_ADDR[1], INVALID_ADDR; 21141da177e4SLinus Torvalds mvi DFFSXFRCTL, CLRCHN ret; 21151da177e4SLinus Torvalds 21161da177e4SLinus Torvalds/* 21171da177e4SLinus Torvalds * Watch over the status transfer. Our host sense buffer is 21181da177e4SLinus Torvalds * large enough to take the maximum allowed status packet. 21191da177e4SLinus Torvalds * None-the-less, we must still catch and report overruns to 21201da177e4SLinus Torvalds * the host. Additionally, properly catch unexpected non-packet 21211da177e4SLinus Torvalds * phases that are typically caused by CRC errors in status packet 21221da177e4SLinus Torvalds * transmission. 21231da177e4SLinus Torvalds */ 21241da177e4SLinus Torvaldspkt_handle_status: 21251da177e4SLinus Torvalds call setjmp; 21261da177e4SLinus Torvalds test SG_CACHE_SHADOW, LAST_SEG_DONE jnz pkt_status_check_overrun; 21271da177e4SLinus Torvalds test SEQINTSRC, CTXTDONE jz pkt_status_check_nonpackreq; 21281da177e4SLinus Torvalds test SG_CACHE_SHADOW, LAST_SEG_DONE jnz pkt_status_check_overrun; 21291da177e4SLinus Torvaldspkt_status_IU_done: 21301da177e4SLinus Torvalds if ((ahd->bugs & AHD_AUTOFLUSH_BUG) != 0) { 21311da177e4SLinus Torvalds or DFCNTRL, FIFOFLUSH; 21321da177e4SLinus Torvalds } 21331da177e4SLinus Torvalds test DFSTATUS, FIFOEMP jz return; 21341da177e4SLinus TorvaldsBEGIN_CRITICAL; 21351da177e4SLinus Torvalds or LONGJMP_ADDR[1], INVALID_ADDR; 21361da177e4SLinus Torvalds mvi SCB_SCSI_STATUS, STATUS_PKT_SENSE; 21371da177e4SLinus Torvalds or SCB_CONTROL, STATUS_RCVD; 21381da177e4SLinus Torvalds jmp pkt_complete_scb_if_fifos_idle; 21391da177e4SLinus TorvaldsEND_CRITICAL; 21401da177e4SLinus Torvaldspkt_status_check_overrun: 21411da177e4SLinus Torvalds /* 21421da177e4SLinus Torvalds * Status PKT overruns are uncerimoniously recovered with a 21431da177e4SLinus Torvalds * bus reset. If we've overrun, let the host know so that 21441da177e4SLinus Torvalds * recovery can be performed. 21451da177e4SLinus Torvalds * 21461da177e4SLinus Torvalds * LAST_SEG_DONE has been observed. If either CTXTDONE or 21471da177e4SLinus Torvalds * a NONPACKREQ phase change have occurred and the FIFO is 21481da177e4SLinus Torvalds * empty, there is no overrun. 21491da177e4SLinus Torvalds */ 21501da177e4SLinus Torvalds test DFSTATUS, FIFOEMP jz pkt_status_report_overrun; 21511da177e4SLinus Torvalds test SEQINTSRC, CTXTDONE jz . + 2; 21521da177e4SLinus Torvalds test DFSTATUS, FIFOEMP jnz pkt_status_IU_done; 21531da177e4SLinus Torvalds test SCSIPHASE, ~DATA_PHASE_MASK jz return; 21541da177e4SLinus Torvalds test DFSTATUS, FIFOEMP jnz pkt_status_check_nonpackreq; 21551da177e4SLinus Torvaldspkt_status_report_overrun: 21561da177e4SLinus Torvalds SET_SEQINTCODE(STATUS_OVERRUN) 21571da177e4SLinus Torvalds /* SEQUENCER RESTARTED */ 21581da177e4SLinus Torvaldspkt_status_check_nonpackreq: 21591da177e4SLinus Torvalds /* 21601da177e4SLinus Torvalds * CTXTDONE may be held off if a NONPACKREQ is associated with 21611da177e4SLinus Torvalds * the current context. If a NONPACKREQ is observed, decide 21621da177e4SLinus Torvalds * if it is for the current context. If it is for the current 21631da177e4SLinus Torvalds * context, we must defer NONPACKREQ processing until all data 21641da177e4SLinus Torvalds * has transferred to the host. 21651da177e4SLinus Torvalds */ 21661da177e4SLinus Torvalds test SCSIPHASE, ~DATA_PHASE_MASK jz return; 21671da177e4SLinus Torvalds test SCSISIGO, ATNO jnz . + 2; 21681da177e4SLinus Torvalds test SSTAT2, NONPACKREQ jz return; 21691da177e4SLinus Torvalds test SEQINTSRC, CTXTDONE jnz pkt_status_IU_done; 21701da177e4SLinus Torvalds test DFSTATUS, FIFOEMP jz return; 21711da177e4SLinus Torvalds /* 21721da177e4SLinus Torvalds * The unexpected nonpkt phase handler assumes that any 21731da177e4SLinus Torvalds * data channel use will have a FIFO reference count. It 2174*25985edcSLucas De Marchi * turns out that the status handler doesn't need a references 21751da177e4SLinus Torvalds * count since the status received flag, and thus completion 21761da177e4SLinus Torvalds * processing, cannot be set until the handler is finished. 21771da177e4SLinus Torvalds * We increment the count here to make the nonpkt handler 21781da177e4SLinus Torvalds * happy. 21791da177e4SLinus Torvalds */ 21801da177e4SLinus Torvalds inc SCB_FIFO_USE_COUNT; 21811da177e4SLinus Torvalds /* FALLTHROUGH */ 21821da177e4SLinus Torvalds 21831da177e4SLinus Torvalds/* 21841da177e4SLinus Torvalds * Nonpackreq is a polled status. It can come true in three situations: 21851da177e4SLinus Torvalds * we have received an L_Q, we have sent one or more L_Qs, or there is no 21861da177e4SLinus Torvalds * L_Q context associated with this REQ (REQ occurs immediately after a 21871da177e4SLinus Torvalds * (re)selection). Routines that know that the context responsible for this 21881da177e4SLinus Torvalds * nonpackreq call directly into unexpected_nonpkt_phase. In the case of the 21891da177e4SLinus Torvalds * top level idle loop, we exhaust all active contexts prior to determining that 21901da177e4SLinus Torvalds * we simply do not have the full I_T_L_Q for this phase. 21911da177e4SLinus Torvalds */ 21921da177e4SLinus Torvaldsunexpected_nonpkt_phase_find_ctxt: 21931da177e4SLinus Torvalds /* 21941da177e4SLinus Torvalds * This nonpackreq is most likely associated with one of the tags 21951da177e4SLinus Torvalds * in a FIFO or an outgoing LQ. Only treat it as an I_T only 21961da177e4SLinus Torvalds * nonpackreq if we've cleared out the FIFOs and handled any 21971da177e4SLinus Torvalds * pending SELDO. 21981da177e4SLinus Torvalds */ 21991da177e4SLinus TorvaldsSET_SRC_MODE M_SCSI; 22001da177e4SLinus TorvaldsSET_DST_MODE M_SCSI; 22011da177e4SLinus Torvalds and A, FIFO1FREE|FIFO0FREE, DFFSTAT; 22021da177e4SLinus Torvalds cmp A, FIFO1FREE|FIFO0FREE jne return; 22031da177e4SLinus Torvalds test SSTAT0, SELDO jnz return; 22041da177e4SLinus Torvalds mvi SCBPTR[1], SCB_LIST_NULL; 22051da177e4SLinus Torvaldsunexpected_nonpkt_phase: 22061da177e4SLinus Torvalds test MODE_PTR, ~(MK_MODE(M_DFF1, M_DFF1)) 22071da177e4SLinus Torvalds jnz unexpected_nonpkt_mode_cleared; 22081da177e4SLinus TorvaldsSET_SRC_MODE M_DFF0; 22091da177e4SLinus TorvaldsSET_DST_MODE M_DFF0; 22101da177e4SLinus Torvalds or LONGJMP_ADDR[1], INVALID_ADDR; 22111da177e4SLinus Torvalds dec SCB_FIFO_USE_COUNT; 22121da177e4SLinus Torvalds mvi DFFSXFRCTL, CLRCHN; 22131da177e4SLinus Torvaldsunexpected_nonpkt_mode_cleared: 22141da177e4SLinus Torvalds mvi CLRSINT2, CLRNONPACKREQ; 221553467e63SHannes Reinecke if ((ahd->bugs & AHD_BUSFREEREV_BUG) != 0) { 221653467e63SHannes Reinecke /* 221753467e63SHannes Reinecke * Test to ensure that the bus has not 221853467e63SHannes Reinecke * already gone free prior to clearing 221953467e63SHannes Reinecke * any stale busfree status. This avoids 222053467e63SHannes Reinecke * a window whereby a busfree just after 222153467e63SHannes Reinecke * a selection could be missed. 222253467e63SHannes Reinecke */ 222353467e63SHannes Reinecke test SCSISIGI, BSYI jz . + 2; 222453467e63SHannes Reinecke mvi CLRSINT1,CLRBUSFREE; 222553467e63SHannes Reinecke or SIMODE1, ENBUSFREE; 222653467e63SHannes Reinecke } 22271da177e4SLinus Torvalds test SCSIPHASE, ~(MSG_IN_PHASE|MSG_OUT_PHASE) jnz illegal_phase; 22281da177e4SLinus Torvalds SET_SEQINTCODE(ENTERING_NONPACK) 22291da177e4SLinus Torvalds jmp ITloop; 22301da177e4SLinus Torvalds 22311da177e4SLinus Torvaldsillegal_phase: 22321da177e4SLinus Torvalds SET_SEQINTCODE(ILLEGAL_PHASE) 22331da177e4SLinus Torvalds jmp ITloop; 22341da177e4SLinus Torvalds 22351da177e4SLinus Torvalds/* 22361da177e4SLinus Torvalds * We have entered an overrun situation. If we have working 22371da177e4SLinus Torvalds * BITBUCKET, flip that on and let the hardware eat any overrun 22381da177e4SLinus Torvalds * data. Otherwise use an overrun buffer in the host to simulate 22391da177e4SLinus Torvalds * BITBUCKET. 22401da177e4SLinus Torvalds */ 22411da177e4SLinus Torvaldspkt_handle_overrun_inc_use_count: 22421da177e4SLinus Torvalds inc SCB_FIFO_USE_COUNT; 22431da177e4SLinus Torvaldspkt_handle_overrun: 22441da177e4SLinus Torvalds SET_SEQINTCODE(CFG4OVERRUN) 22451da177e4SLinus Torvalds call freeze_queue; 22461da177e4SLinus Torvalds if ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) == 0) { 22471da177e4SLinus Torvalds or DFFSXFRCTL, DFFBITBUCKET; 22481da177e4SLinus TorvaldsSET_SRC_MODE M_DFF1; 22491da177e4SLinus TorvaldsSET_DST_MODE M_DFF1; 22501da177e4SLinus Torvalds } else { 22511da177e4SLinus Torvalds call load_overrun_buf; 22521da177e4SLinus Torvalds mvi DFCNTRL, (HDMAEN|SCSIEN|PRELOADEN); 22531da177e4SLinus Torvalds } 22541da177e4SLinus Torvalds call setjmp; 22551da177e4SLinus Torvalds if ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) != 0) { 22561da177e4SLinus Torvalds test DFSTATUS, PRELOAD_AVAIL jz overrun_load_done; 22571da177e4SLinus Torvalds call load_overrun_buf; 22581da177e4SLinus Torvalds or DFCNTRL, PRELOADEN; 22591da177e4SLinus Torvaldsoverrun_load_done: 22601da177e4SLinus Torvalds test SEQINTSRC, CTXTDONE jnz pkt_overrun_end; 22611da177e4SLinus Torvalds } else { 22621da177e4SLinus Torvalds test DFFSXFRCTL, DFFBITBUCKET jz pkt_overrun_end; 22631da177e4SLinus Torvalds } 22641da177e4SLinus Torvalds test SSTAT2, NONPACKREQ jz return; 22651da177e4SLinus Torvaldspkt_overrun_end: 22661da177e4SLinus Torvalds or SCB_RESIDUAL_SGPTR, SG_OVERRUN_RESID; 22671da177e4SLinus Torvalds test SEQINTSRC, CTXTDONE jz unexpected_nonpkt_phase; 22681da177e4SLinus Torvalds dec SCB_FIFO_USE_COUNT; 22691da177e4SLinus Torvalds or LONGJMP_ADDR[1], INVALID_ADDR; 22701da177e4SLinus Torvalds test SCB_CONTROL, STATUS_RCVD jnz pkt_complete_scb_if_fifos_idle; 22711da177e4SLinus Torvalds mvi DFFSXFRCTL, CLRCHN ret; 22721da177e4SLinus Torvalds 22731da177e4SLinus Torvaldsif ((ahd->bugs & AHD_PKT_BITBUCKET_BUG) != 0) { 22741da177e4SLinus Torvaldsload_overrun_buf: 22751da177e4SLinus Torvalds /* 22761da177e4SLinus Torvalds * Load a dummy segment if preload space is available. 22771da177e4SLinus Torvalds */ 22781da177e4SLinus Torvalds mov HADDR[0], SHARED_DATA_ADDR; 22791da177e4SLinus Torvalds add HADDR[1], PKT_OVERRUN_BUFOFFSET, SHARED_DATA_ADDR[1]; 22801da177e4SLinus Torvalds mov ACCUM_SAVE, A; 22811da177e4SLinus Torvalds clr A; 22821da177e4SLinus Torvalds adc HADDR[2], A, SHARED_DATA_ADDR[2]; 22831da177e4SLinus Torvalds adc HADDR[3], A, SHARED_DATA_ADDR[3]; 22841da177e4SLinus Torvalds mov A, ACCUM_SAVE; 22851da177e4SLinus Torvalds bmov HADDR[4], ALLZEROS, 4; 22861da177e4SLinus Torvalds /* PKT_OVERRUN_BUFSIZE is a multiple of 256 */ 22871da177e4SLinus Torvalds clr HCNT[0]; 22881da177e4SLinus Torvalds mvi HCNT[1], ((PKT_OVERRUN_BUFSIZE >> 8) & 0xFF); 22891da177e4SLinus Torvalds clr HCNT[2] ret; 22901da177e4SLinus Torvalds} 2291