Lines Matching refs:we
85 * If we have completions stalled waiting for the qfreeze
109 * ENSELO is cleared by a SELDO, so we must test for SELDO
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.
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
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
627 * case nicely as we will not return to the
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
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
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
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.
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
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
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
1380 * sure we have a clean start for the next data or command phase.
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
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.
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 */
1816 * the SG_CACHE_PTR register so we can restore the
1853 * after we have already trained for data-out, it is
1858 * we have already prefetched data into our FIFO (LQ/Data
1867 * disabling SCSIEN until we see the first REQ from the
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
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
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