Lines Matching refs:we
74 * ENSELO is cleared by a SELDO, so we must test for SELDO
130 * Since this status did not consume a FIFO, we have to
131 * be a bit more dilligent in how we check for FIFOs pertaining
139 * count in the SCB. In this case, we allow the routine servicing
144 * we detect case 1, we will properly defer the post of the SCB
180 * bad SCSI status (currently only for underruns), we
181 * queue the SCB for normal completion. Otherwise, we
223 * If we have relatively few commands outstanding, don't
269 * one byte of lun information we support.
290 * to a target and we will see the MK_MESSAGE flag.
324 * Keep track of the SCBs we are dmaing just
435 * handling, we initialize LASTSCB prior to enabling
436 * selection so we can rely on it even for case #1 above.
444 * If we want to send a message to the device, ensure
445 * we are selecting with atn irregardless of our packetized
459 * In RevA hardware, both FIFOs must be free before we
534 * the assertion of SELDO. If we are non-packetized,
542 * If we see LQOBUSFREE, return to the idle loop.
543 * Once we are out of the select_out critical section,
544 * the kernel will cleanup the LQOBUSFREE and we will
559 * but MAXCMDCNT is accurate. If we stop part way through
609 * unless we were queued independently due to our need to
637 * we have selected out with ATN asserted and the target
670 * As soon as we get a successful selection, the target
671 * should go into the message out phase since we have ATN
762 * associated with this target is set, we will also interrupt the host,
848 * we perform the phase_lock before checking to see
849 * if we should exit the loop and skip the phase_lock
915 * Here we "snoop" the bus looking for a SIMPLE QUEUE TAG message.
916 * If we get one, we use the tag returned to find the proper
981 * In either of these conditions, we upload the SCB back to the host so it can
982 * process this information. In the case of a non zero status byte, we
992 * If ATN is raised, we still want to give the target a message.
997 * for this command and setting ATN while we are still processing
1003 * If we are identified and have successfully sent the CDB,
1016 * If we recevied good status but never successfully sent the
1024 * See if we attempted to deliver a message but the target ingnored us.
1071 * Restore SCB TAG since we reuse this field
1088 * If ATN is raised, we still want to give the target a message.
1090 * or we want to abort this command. Either way, the target
1134 * only if we've actually been into a data phase to change them. This
1136 * since they are only initialized when we go into data_in or data_out.
1149 * If we are asked to save our position at the end of the
1167 * SCB anytime we enter a data phase for the first time, so all
1168 * we need to do is clear the DPHASE flag and let the data phase
1170 * sure we have a clean start for the next data or command phase.
1193 * count REQ while we are waiting for it to fall during
1217 * So we wait until SCSIDATL is latched (the usual way), then read the data
1218 * byte directly off the bus using SCSIBUSL. When we have pulled the ATN
1219 * line, or we just want to acknowledge the byte, then we do a dummy read
1221 * data byte on the bus until we send our ACK.
1261 * Do we have any prefetch left???
1270 /* Did we just finish fetching segs? */
1273 /* Are we actively fetching segments? */
1278 * so we don't end up referencing a non-existant page.
1350 * Do we have another segment in the cache?
1367 * Since we've are entering a data phase, we will
1373 /* If we need more S/G elements, tell the idle loop */
1392 * If we re-enter the data phase after going through another
1396 * unless we already know that we should be bitbucketing.
1532 * allows us to update our notion of where we are
1535 * If, by chance, we stopped before being able
1542 * If we happened to stop on the last segment, then
1559 /* Record if we've consumed all S/G entries */
1570 * the SG_CACHE_PTR register so we can restore the
1607 * after we have already trained for data-out, it is
1612 * we have already prefetched data into our FIFO (LQ/Data
1621 * disabling SCSIEN until we see the first REQ from the
1636 * FIFO. This status is the only way we can detect if we
1666 * This happens between packets in a stream for a single L_Q. Since we
1667 * are not performing a pointer save, we can safely clear the channel
1738 * another packet without changing contexts, implying we are
1739 * not sitting on a packet boundary, we are in an overrun
1742 * into the FIFO. If the FIFO should become non-empty, we are in
1758 * Defer handling of this NONPACKREQ until we
1761 * so we must simulate it if shaddow is valid. If
1762 * shaddow is not valid, keep running this FIFO until we
1781 * or we have a pending NONPACKREQ for this FIFO. We differentiate
1801 * to the host to guarantee that we don't complete the
1819 * Check for overrun and see if we can complete this command.
1838 * prevent CTXTDONE from ever asserting, so we must
1852 * LAST_SEG_DONE has been observed. However, we check
1875 * None-the-less, we must still catch and report overruns to
1899 * bus reset. If we've overrun, let the host know so that
1919 * context, we must defer NONPACKREQ processing until all data
1941 * we have received an L_Q, we have sent one or more L_Qs, or there is no
1945 * top level idle loop, we exhaust all active contexts prior to determining that
1946 * we simply do not have the full I_T_L_Q for this phase.
1952 * nonpackreq if we've cleared out the FIFOs and handled any
1978 * We have entered an overrun situation. If we have working