Lines Matching full:we
85 * If we have completions stalled waiting for the qfreeze
109 * ENSELO is cleared by a SELDO, so we must test for SELDO
149 * We have received good status for this transaction. There may
169 * Since this status did not consume a FIFO, we have to
170 * be a bit more dilligent in how we check for FIFOs pertaining
178 * count in the SCB. In this case, we allow the routine servicing
183 * we detect case 1, we will properly defer the post of the SCB
222 * bad SCSI status (currently only for underruns), we
223 * queue the SCB for normal completion. Otherwise, we
258 * If we have relatively few commands outstanding, don't
303 * one byte of lun information we support.
328 * list updates. We also record the SCB's
329 * flags so that we can refer to them even
362 * immediately. If the queue is not empty, we must
367 * To simplify the implementation, we stop pulling
376 * order is preserved even if we batch.
419 * if select-outs are currently frozen or we have
432 * Keep track of the SCBs we are dmaing just
457 * PCI-X mode, we do this to avoid split transactions since
499 * top of the stack. Since we want the latter
500 * (we use setjmp to register a handler from an
502 * until we return to our idle loop), use a
555 * CURRSCB nor LASTSCB can be trusted. We must
560 * handling, we initialize LASTSCB prior to enabling
561 * selection so we can rely on it even for case #1 above.
569 * If we want to send a message to the device, ensure
570 * we are selecting with atn regardless of our packetized
584 * In RevA hardware, both FIFOs must be free before we
612 * We have been reselected as an initiator
627 * case nicely as we will not return to the
653 * We have successfully selected out.
680 * case nicely as we will not return to the
690 * the assertion of SELDO. If we are non-packetized,
698 * If we see LQOBUSFREE, return to the idle loop.
699 * Once we are out of the select_out critical section,
700 * the kernel will cleanup the LQOBUSFREE and we will
715 * but MAXCMDCNT is accurate. If we stop part way through
752 * We know that neither the per-TID list nor the list of
804 * we have selected out with ATN asserted and the target
838 * As soon as we get a successful selection, the target
839 * should go into the message out phase since we have ATN
906 * before all data are sent, we have left over acks
910 * out before we can test SDONE, we'll think that
915 * successfully, SCSIEN should fall *long* before we
916 * see a phase change. We thus treat any phasemiss
955 * associated with this target is set, we will also interrupt the host,
1041 * we perform the phase_lock before checking to see
1042 * if we should exit the loop and skip the phase_lock
1108 * Here we "snoop" the bus looking for a SIMPLE QUEUE TAG message.
1109 * If we get one, we use the tag returned to find the proper
1170 * We received a "command complete" message. Put the SCB on the complete
1173 * other than STATUS_GOOD (0). In either of these conditions, we upload the
1179 * If ATN is raised, we still want to give the target a message.
1182 * and then attempt to complete the command again. We should use a
1184 * for this command and setting ATN while we are still processing
1190 * If we are identified and have successfully sent the CDB,
1203 * If we recevied good status but never successfully sent the
1211 * See if we attempted to deliver a message but the target ingnored us.
1262 * Restore SCB TAG since we reuse this field
1263 * in the sequencer. We don't want to corrupt
1288 * If ATN is raised, we still want to give the target a message.
1290 * or we want to abort this command. Either way, the target
1329 * We only set BUSFREE status once either a new
1330 * phase has been detected or we are really
1332 * that we are active on the bus even though
1344 * only if we've actually been into a data phase to change them. This
1346 * since they are only initialized when we go into data_in or data_out.
1359 * If we are asked to save our position at the end of the
1377 * SCB anytime we enter a data phase for the first time, so all
1378 * we need to do is clear the DPHASE flag and let the data phase
1379 * code do the rest. We also reset/reallocate the FIFO to make
1380 * sure we have a clean start for the next data or command phase.
1397 * that violate the SCSI spec. We are careful not to
1398 * count REQ while we are waiting for it to fall during
1422 * So we wait until SCSIDATL is latched (the usual way), then read the data
1423 * byte directly off the bus using SCSIBUSL. When we have pulled the ATN
1424 * line, or we just want to acknowledge the byte, then we do a dummy read
1426 * data byte on the bus until we send our ACK.
1466 * Do we have any prefetch left???
1475 /* Did we just finish fetching segs? */
1478 /* Are we actively fetching segments? */
1483 * both FIFOs have been allocated since we last checked
1484 * any FIFO, it is important that we service a FIFO
1492 * If we're not still receiving SCSI data,
1500 * also have the "set mode" bug, so we must
1510 * the original FIFO mode and we test this above).
1511 * Return to the idle loop so we can process the
1523 * We fetch a "cacheline aligned" and sized amount of data
1524 * so we don't end up referencing a non-existent page.
1596 * Do we have another segment in the cache?
1613 * Since we've are entering a data phase, we will
1619 /* If we need more S/G elements, tell the idle loop */
1638 * If we re-enter the data phase after going through another
1642 * unless we already know that we should be bitbucketing.
1678 /* We have seen a data phase at least once. */
1699 * We have two goals here. Do as much other work
1716 * We have enabled the auto-ack feature. This means
1722 * non-empty. We know there is more data yet to transfer
1734 * the dma code again. We will only loop if there is a
1755 * initiator before changing phase. We only need to
1775 * We assume that, even though data may still be
1778 * allows us to update our notion of where we are
1781 * If, by chance, we stopped before being able
1788 * If we happened to stop on the last segment, then
1805 /* Record if we've consumed all S/G entries */
1814 * in addition to the currently active element. We
1816 * the SG_CACHE_PTR register so we can restore the
1829 clr SCB_RESIDUAL_DATACNT[3]; /* We are not the last seg */
1853 * after we have already trained for data-out, it is
1858 * we have already prefetched data into our FIFO (LQ/Data
1861 * first few data transfers on the bus. We detect this
1867 * disabling SCSIEN until we see the first REQ from the
1880 * savepointer in the current FIFO. We do this so that
1882 * FIFO. This status is the only way we can detect if we
1912 * This happens between packets in a stream for a single L_Q. Since we
1913 * are not performing a pointer save, we can safely clear the channel
1920 * has a residual. This should occur coincident with a ctxtdone. We
1984 * another packet without changing contexts, implying we are
1985 * not sitting on a packet boundary, we are in an overrun
1988 * into the FIFO. If the FIFO should become non-empty, we are in
2004 * Defer handling of this NONPACKREQ until we
2007 * so we must simulate it if shadow is valid. If
2008 * shadow is not valid, keep running this FIFO until we
2027 * or we have a pending NONPACKREQ for this FIFO. We differentiate
2047 * to the host to guarantee that we don't complete the
2064 * Check for overrun and see if we can complete this command.
2082 * prevent CTXTDONE from ever asserting, so we must
2096 * LAST_SEG_DONE has been observed. However, we check
2119 * None-the-less, we must still catch and report overruns to
2143 * bus reset. If we've overrun, let the host know so that
2163 * context, we must defer NONPACKREQ processing until all data
2177 * We increment the count here to make the nonpkt handler
2185 * we have received an L_Q, we have sent one or more L_Qs, or there is no
2189 * top level idle loop, we exhaust all active contexts prior to determining that
2190 * we simply do not have the full I_T_L_Q for this phase.
2196 * nonpackreq if we've cleared out the FIFOs and handled any
2236 * We have entered an overrun situation. If we have working