taglinefilesource code
SCpnt741drivers/scsi/AM53C974.cint AM53C974_command(Scsi_Cmnd *SCpnt)
SCpnt290drivers/scsi/AM53C974.hint AM53C974_command(Scsi_Cmnd *SCpnt);
SCpnt647drivers/scsi/NCR53c406a.cstatic void internal_done(Scsi_Cmnd *SCpnt) {
SCpnt648drivers/scsi/NCR53c406a.cinternal_done_errcode = SCpnt->result;
SCpnt670drivers/scsi/NCR53c406a.cint NCR53c406a_command(Scsi_Cmnd *SCpnt){
SCpnt672drivers/scsi/NCR53c406a.cNCR53c406a_queue(SCpnt, internal_done);
SCpnt685drivers/scsi/NCR53c406a.cNCR53c406a_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)){
SCpnt691drivers/scsi/NCR53c406a.cSCpnt->cmnd[0],
SCpnt692drivers/scsi/NCR53c406a.cSCpnt->cmd_len,
SCpnt693drivers/scsi/NCR53c406a.cSCpnt->target, 
SCpnt694drivers/scsi/NCR53c406a.cSCpnt->lun,  
SCpnt695drivers/scsi/NCR53c406a.cSCpnt->request_bufflen));
SCpnt698drivers/scsi/NCR53c406a.cVDEB(for(i=0; i<SCpnt->cmd_len; i++)
SCpnt699drivers/scsi/NCR53c406a.cprintk("cmd[%d]=%02x  ", i, SCpnt->cmnd[i]));
SCpnt703drivers/scsi/NCR53c406a.ccurrent_SC = SCpnt;
SCpnt712drivers/scsi/NCR53c406a.coutb(SCpnt->target, DEST_ID); /* set destination */
SCpnt715drivers/scsi/NCR53c406a.cfor(i=0; i<SCpnt->cmd_len; i++){
SCpnt716drivers/scsi/NCR53c406a.coutb(SCpnt->cmnd[i], SCSI_FIFO);
SCpnt726drivers/scsi/NCR53c406a.cNCR53c406a_abort(Scsi_Cmnd *SCpnt){
SCpnt732drivers/scsi/NCR53c406a.cNCR53c406a_reset(Scsi_Cmnd *SCpnt){
SCpnt868drivers/scsi/aha152x.cint aha152x_queue(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt870drivers/scsi/aha152x.cstruct Scsi_Host *shpnt = SCpnt->host;
SCpnt886drivers/scsi/aha152x.cSCpnt->target, SCpnt->lun);
SCpnt887drivers/scsi/aha152x.cprint_command(SCpnt->cmnd);
SCpnt889drivers/scsi/aha152x.cSCpnt->cmd_len, SCpnt->use_sg, SCpnt->request_bufflen);
SCpnt894drivers/scsi/aha152x.cSCpnt->scsi_done =       done;
SCpnt902drivers/scsi/aha152x.cSCpnt->SCp.phase = not_issued;
SCpnt903drivers/scsi/aha152x.cif (SCpnt->use_sg)
SCpnt905drivers/scsi/aha152x.cSCpnt->SCp.buffer =
SCpnt906drivers/scsi/aha152x.c(struct scatterlist *) SCpnt->request_buffer;
SCpnt907drivers/scsi/aha152x.cSCpnt->SCp.ptr              = SCpnt->SCp.buffer->address;
SCpnt908drivers/scsi/aha152x.cSCpnt->SCp.this_residual    = SCpnt->SCp.buffer->length;
SCpnt909drivers/scsi/aha152x.cSCpnt->SCp.buffers_residual = SCpnt->use_sg - 1;
SCpnt913drivers/scsi/aha152x.cSCpnt->SCp.ptr              = (char *)SCpnt->request_buffer;
SCpnt914drivers/scsi/aha152x.cSCpnt->SCp.this_residual    = SCpnt->request_bufflen;
SCpnt915drivers/scsi/aha152x.cSCpnt->SCp.buffer           = NULL;
SCpnt916drivers/scsi/aha152x.cSCpnt->SCp.buffers_residual = 0;
SCpnt919drivers/scsi/aha152x.cSCpnt->SCp.Status              = CHECK_CONDITION;
SCpnt920drivers/scsi/aha152x.cSCpnt->SCp.Message             = 0;
SCpnt921drivers/scsi/aha152x.cSCpnt->SCp.have_data_in        = 0;
SCpnt922drivers/scsi/aha152x.cSCpnt->SCp.sent_command        = 0;
SCpnt935drivers/scsi/aha152x.cappend_SC(&ISSUE_SC, SCpnt);
SCpnt955drivers/scsi/aha152x.cint aha152x_command(Scsi_Cmnd *SCpnt)
SCpnt965drivers/scsi/aha152x.cint aha152x_abort(Scsi_Cmnd *SCpnt)
SCpnt967drivers/scsi/aha152x.cstruct Scsi_Host *shpnt = SCpnt->host;
SCpnt977drivers/scsi/aha152x.cprintk("aha152x: abort(), SCpnt=0x%08x, ", (unsigned int) SCpnt);
SCpnt984drivers/scsi/aha152x.cptr && ptr!=SCpnt;
SCpnt1005drivers/scsi/aha152x.cif (TESTLO(SSTAT1, BUSFREE) || (CURRENT_SC && CURRENT_SC!=SCpnt))
SCpnt1030drivers/scsi/aha152x.cptr && ptr!=SCpnt;
SCpnt1122drivers/scsi/aha152x.cint aha152x_reset(Scsi_Cmnd *SCpnt)
SCpnt1124drivers/scsi/aha152x.cstruct Scsi_Host *shpnt = SCpnt->host;
SCpnt510drivers/scsi/aha1542.cint aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt514drivers/scsi/aha1542.cunchar *cmd = (unchar *) SCpnt->cmnd;
SCpnt515drivers/scsi/aha1542.cunchar target = SCpnt->target;
SCpnt516drivers/scsi/aha1542.cunchar lun = SCpnt->lun;
SCpnt518drivers/scsi/aha1542.cvoid *buff = SCpnt->request_buffer;
SCpnt519drivers/scsi/aha1542.cint bufflen = SCpnt->request_bufflen;
SCpnt526drivers/scsi/aha1542.cmb = HOSTDATA(SCpnt->host)->mb;
SCpnt527drivers/scsi/aha1542.cccb = HOSTDATA(SCpnt->host)->ccb;
SCpnt530drivers/scsi/aha1542.cSCpnt->result = DID_TIME_OUT << 16;
SCpnt531drivers/scsi/aha1542.cdone(SCpnt); return 0;});
SCpnt535drivers/scsi/aha1542.cif (bufflen != sizeof(SCpnt->sense_buffer)) {
SCpnt539drivers/scsi/aha1542.cSCpnt->result = 0;
SCpnt540drivers/scsi/aha1542.cdone(SCpnt); 
SCpnt557drivers/scsi/aha1542.cfor (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
SCpnt567drivers/scsi/aha1542.cmbo = HOSTDATA(SCpnt->host)->aha1542_last_mbo_used + 1;
SCpnt571drivers/scsi/aha1542.cif(mb[mbo].status == 0 && HOSTDATA(SCpnt->host)->SCint[mbo] == NULL)
SCpnt575drivers/scsi/aha1542.c} while (mbo != HOSTDATA(SCpnt->host)->aha1542_last_mbo_used);
SCpnt577drivers/scsi/aha1542.cif(mb[mbo].status || HOSTDATA(SCpnt->host)->SCint[mbo])
SCpnt580drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->SCint[mbo] = SCpnt;  /* This will effectively prevent someone else from
SCpnt583drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->aha1542_last_mbo_used = mbo;    
SCpnt594drivers/scsi/aha1542.cccb[mbo].cdblen = SCpnt->cmd_len;
SCpnt604drivers/scsi/aha1542.cif (SCpnt->use_sg) {
SCpnt612drivers/scsi/aha1542.cSCpnt->host_scribble = (unsigned char *) scsi_malloc(512);
SCpnt613drivers/scsi/aha1542.csgpnt = (struct scatterlist *) SCpnt->request_buffer;
SCpnt614drivers/scsi/aha1542.ccptr = (struct chain *) SCpnt->host_scribble; 
SCpnt616drivers/scsi/aha1542.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt617drivers/scsi/aha1542.cif(sgpnt[i].length == 0 || SCpnt->use_sg > 16 || 
SCpnt620drivers/scsi/aha1542.cprintk("Bad segment list supplied to aha1542.c (%d, %d)\n",SCpnt->use_sg,i);
SCpnt621drivers/scsi/aha1542.cfor(i=0;i<SCpnt->use_sg;i++){
SCpnt634drivers/scsi/aha1542.cany2scsi(ccb[mbo].datalen, SCpnt->use_sg * sizeof(struct chain));
SCpnt643drivers/scsi/aha1542.cSCpnt->host_scribble = NULL;
SCpnt663drivers/scsi/aha1542.cSCpnt->scsi_done = done;
SCpnt665drivers/scsi/aha1542.caha1542_out(SCpnt->host->io_port, &ahacmd, 1);    /* start scsi command */
SCpnt676drivers/scsi/aha1542.cstatic void internal_done(Scsi_Cmnd * SCpnt)
SCpnt678drivers/scsi/aha1542.cSCpnt->SCp.Status++;
SCpnt681drivers/scsi/aha1542.cint aha1542_command(Scsi_Cmnd * SCpnt)
SCpnt685drivers/scsi/aha1542.caha1542_queuecommand(SCpnt, internal_done);
SCpnt687drivers/scsi/aha1542.cSCpnt->SCp.Status = 0;
SCpnt688drivers/scsi/aha1542.cwhile (!SCpnt->SCp.Status)
SCpnt690drivers/scsi/aha1542.creturn SCpnt->result;
SCpnt1109drivers/scsi/aha1542.cint aha1542_abort(Scsi_Cmnd * SCpnt)
SCpnt1118drivers/scsi/aha1542.cinb(STATUS(SCpnt->host->io_port)),
SCpnt1119drivers/scsi/aha1542.cinb(INTRFLAGS(SCpnt->host->io_port)));
SCpnt1123drivers/scsi/aha1542.cmb = HOSTDATA(SCpnt->host)->mb;
SCpnt1124drivers/scsi/aha1542.cmbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1;
SCpnt1131drivers/scsi/aha1542.c} while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used);
SCpnt1136drivers/scsi/aha1542.cSCpnt->host->irq);
SCpnt1137drivers/scsi/aha1542.caha1542_intr_handle(SCpnt->host->irq, NULL);
SCpnt1145drivers/scsi/aha1542.cif(HOSTDATA(SCpnt->host)->SCint[i])
SCpnt1147drivers/scsi/aha1542.cif(HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
SCpnt1149drivers/scsi/aha1542.ckdevname(SCpnt->request.rq_dev));
SCpnt1150drivers/scsi/aha1542.cif (HOSTDATA(SCpnt->host)->mb[i].status) {
SCpnt1152drivers/scsi/aha1542.caha1542_out(SCpnt->host->io_port, &ahacmd, 1);
SCpnt1156drivers/scsi/aha1542.ckdevname(SCpnt->request.rq_dev));
SCpnt1166drivers/scsi/aha1542.cif (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]){
SCpnt1168drivers/scsi/aha1542.caha1542_out(SCpnt->host->io_port, &ahacmd, 1); /* start scsi command */
SCpnt1182drivers/scsi/aha1542.cint aha1542_reset(Scsi_Cmnd * SCpnt, unsigned int reset_flags)
SCpnt1198drivers/scsi/aha1542.coutb(HRST | SCRST, CONTROL(SCpnt->host->io_port));
SCpnt1207drivers/scsi/aha1542.cWAIT(STATUS(SCpnt->host->io_port), 
SCpnt1214drivers/scsi/aha1542.csetup_mailboxes(SCpnt->host->io_port, SCpnt->host);
SCpnt1222drivers/scsi/aha1542.cprintk("Sent BUS RESET to scsi host %d\n", SCpnt->host->host_no);
SCpnt1225drivers/scsi/aha1542.cif(HOSTDATA(SCpnt->host)->SCint[i] != NULL)
SCpnt1228drivers/scsi/aha1542.cSCtmp = HOSTDATA(SCpnt->host)->SCint[i];
SCpnt1231drivers/scsi/aha1542.cprintk("Sending DID_RESET for target %d\n", SCpnt->target);
SCpnt1232drivers/scsi/aha1542.cSCtmp->scsi_done(SCpnt);
SCpnt1234drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->SCint[i] = NULL;
SCpnt1235drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->mb[i].status = 0;
SCpnt1255drivers/scsi/aha1542.cif(HOSTDATA(SCpnt->host)->SCint[i] == SCpnt)
SCpnt1257drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->ccb[i].op = 0x81;  /* BUS DEVICE RESET */
SCpnt1259drivers/scsi/aha1542.caha1542_out(SCpnt->host->io_port, &ahacmd, 1);
SCpnt1265drivers/scsi/aha1542.cprintk("Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
SCpnt1271drivers/scsi/aha1542.cif(HOSTDATA(SCpnt->host)->SCint[i] &&
SCpnt1272drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target)
SCpnt1275drivers/scsi/aha1542.cSCtmp = HOSTDATA(SCpnt->host)->SCint[i];
SCpnt1278drivers/scsi/aha1542.cprintk("Sending DID_RESET for target %d\n", SCpnt->target);
SCpnt1279drivers/scsi/aha1542.cSCtmp->scsi_done(SCpnt);
SCpnt1281drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->SCint[i] = NULL;
SCpnt1282drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->mb[i].status = 0;
SCpnt206drivers/scsi/aha1740.cSCtmp = ecbptr->SCpnt;
SCpnt252drivers/scsi/aha1740.cint aha1740_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt255drivers/scsi/aha1740.cunchar *cmd = (unchar *) SCpnt->cmnd;
SCpnt256drivers/scsi/aha1740.cunchar target = SCpnt->target;
SCpnt258drivers/scsi/aha1740.cvoid *buff = SCpnt->request_buffer;
SCpnt259drivers/scsi/aha1740.cint bufflen = SCpnt->request_bufflen;
SCpnt266drivers/scsi/aha1740.cif (bufflen != sizeof(SCpnt->sense_buffer))
SCpnt270drivers/scsi/aha1740.cSCpnt->result = 0;
SCpnt271drivers/scsi/aha1740.cdone(SCpnt); 
SCpnt284drivers/scsi/aha1740.cfor (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
SCpnt314drivers/scsi/aha1740.cecb[ecbno].cdblen = SCpnt->cmd_len;  /* SCSI Command Descriptor Block Length */
SCpnt324drivers/scsi/aha1740.cif (SCpnt->use_sg)
SCpnt333drivers/scsi/aha1740.cSCpnt->host_scribble = (unsigned char *) scsi_malloc(512);
SCpnt334drivers/scsi/aha1740.csgpnt = (struct scatterlist *) SCpnt->request_buffer;
SCpnt335drivers/scsi/aha1740.ccptr = (struct aha1740_chain *) SCpnt->host_scribble; 
SCpnt337drivers/scsi/aha1740.cfor(i=0; i<SCpnt->use_sg; i++)
SCpnt342drivers/scsi/aha1740.cecb[ecbno].datalen = SCpnt->use_sg * sizeof(struct aha1740_chain);
SCpnt352drivers/scsi/aha1740.cSCpnt->host_scribble = NULL;
SCpnt356drivers/scsi/aha1740.cecb[ecbno].lun = SCpnt->lun;
SCpnt364drivers/scsi/aha1740.cecb[ecbno].SCpnt = SCpnt;
SCpnt415drivers/scsi/aha1740.cstatic void internal_done(Scsi_Cmnd * SCpnt)
SCpnt417drivers/scsi/aha1740.cinternal_done_errcode = SCpnt->result;
SCpnt421drivers/scsi/aha1740.cint aha1740_command(Scsi_Cmnd * SCpnt)
SCpnt423drivers/scsi/aha1740.caha1740_queuecommand(SCpnt, internal_done);
SCpnt492drivers/scsi/aha1740.cint aha1740_abort(Scsi_Cmnd * SCpnt)
SCpnt502drivers/scsi/aha1740.cint aha1740_reset(Scsi_Cmnd * SCpnt)
SCpnt143drivers/scsi/aha1740.hScsi_Cmnd *SCpnt;    /* Link to the SCSI Command Block */
SCpnt376drivers/scsi/constants.cvoid print_sense(const char * devclass, Scsi_Cmnd * SCpnt)
SCpnt380drivers/scsi/constants.cunsigned char * sense_buffer = SCpnt->sense_buffer;
SCpnt389drivers/scsi/constants.cif(s > sizeof(SCpnt->sense_buffer)) s = sizeof(SCpnt->sense_buffer);
SCpnt413drivers/scsi/constants.ckdevname(SCpnt->request.rq_dev), snstext[sense_buffer[2] & 0x0f]);
SCpnt416drivers/scsi/constants.ckdevname(SCpnt->request.rq_dev), sense_buffer[0], sense_buffer[2]);
SCpnt445drivers/scsi/constants.ckdevname(SCpnt->request.rq_dev), snstext[sense_buffer[0] & 0x0f]);
SCpnt449drivers/scsi/constants.ckdevname(SCpnt->request.rq_dev), sense_buffer[0], sense_buffer[2]);
SCpnt264drivers/scsi/eata.cScsi_Cmnd *SCpnt;           /* Address set in cp */
SCpnt291drivers/scsi/eata.cScsi_Cmnd *SCpnt;     /* Address to be returned is sp */
SCpnt593drivers/scsi/eata.cstatic inline void build_sg_list(struct mscp *cpp, Scsi_Cmnd *SCpnt) {
SCpnt597drivers/scsi/eata.csgpnt = (struct scatterlist *) SCpnt->request_buffer;
SCpnt599drivers/scsi/eata.cfor (k = 0; k < SCpnt->use_sg; k++) {
SCpnt605drivers/scsi/eata.ccpp->data_len = htonl((SCpnt->use_sg * sizeof(struct sg_list)));
SCpnt608drivers/scsi/eata.cint eata2x_queuecommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) {
SCpnt622drivers/scsi/eata.cj = ((struct hostdata *) SCpnt->host->hostdata)->board_number;
SCpnt624drivers/scsi/eata.cif (!done) panic("%s: qcomm, pid %ld, null done.\n", BN(j), SCpnt->pid);
SCpnt645drivers/scsi/eata.celse if (eata2x_reset(SCpnt, SCSI_RESET_SUGGEST_BUS_RESET)
SCpnt649drivers/scsi/eata.cSCpnt->result = DID_BUS_BUSY << 16; 
SCpnt650drivers/scsi/eata.cSCpnt->host_scribble = NULL;
SCpnt651drivers/scsi/eata.cprintk("%s: qcomm, pid %ld, DID_BUS_BUSY, done.\n", BN(j), SCpnt->pid);
SCpnt653drivers/scsi/eata.cdone(SCpnt);    
SCpnt670drivers/scsi/eata.cSCpnt->scsi_done = done;
SCpnt672drivers/scsi/eata.cSCpnt->host_scribble = (unsigned char *) &cpp->index;
SCpnt675drivers/scsi/eata.cBN(j), i, SCpnt->target, SCpnt->pid);
SCpnt678drivers/scsi/eata.cif (SCpnt->cmnd[0] == data_out_cmds[k]) {
SCpnt687drivers/scsi/eata.ccpp->target = SCpnt->target;
SCpnt688drivers/scsi/eata.ccpp->lun = SCpnt->lun;  
SCpnt689drivers/scsi/eata.ccpp->SCpnt = SCpnt;
SCpnt690drivers/scsi/eata.ccpp->sense_addr = htonl((unsigned int) SCpnt->sense_buffer); 
SCpnt691drivers/scsi/eata.ccpp->sense_len = sizeof SCpnt->sense_buffer;
SCpnt693drivers/scsi/eata.cif (SCpnt->use_sg) {
SCpnt695drivers/scsi/eata.cbuild_sg_list(cpp, SCpnt);
SCpnt698drivers/scsi/eata.ccpp->data_address = htonl((unsigned int) SCpnt->request_buffer);
SCpnt699drivers/scsi/eata.ccpp->data_len = htonl(SCpnt->request_bufflen);
SCpnt702drivers/scsi/eata.cmemcpy(cpp->cdb, SCpnt->cmnd, SCpnt->cmd_len);
SCpnt706drivers/scsi/eata.cSCpnt->result = DID_ERROR << 16; 
SCpnt707drivers/scsi/eata.cSCpnt->host_scribble = NULL;
SCpnt709drivers/scsi/eata.cBN(j), SCpnt->target, SCpnt->pid);
SCpnt711drivers/scsi/eata.cdone(SCpnt);    
SCpnt756drivers/scsi/eata.cif (SCarg != HD(j)->cp[i].SCpnt)
SCpnt758drivers/scsi/eata.cBN(j), i, SCarg, HD(j)->cp[i].SCpnt);
SCpnt782drivers/scsi/eata.cScsi_Cmnd *SCpnt;
SCpnt819drivers/scsi/eata.cSCpnt = HD(j)->cp[i].SCpnt;
SCpnt822drivers/scsi/eata.cBN(j), i, SCpnt->pid);
SCpnt824drivers/scsi/eata.cif (SCpnt == NULL)
SCpnt827drivers/scsi/eata.cif (SCpnt->host_scribble == NULL)
SCpnt830drivers/scsi/eata.cif (*(unsigned int *)SCpnt->host_scribble != i) 
SCpnt833drivers/scsi/eata.cif (SCpnt->scsi_done == NULL) 
SCpnt836drivers/scsi/eata.cif (SCpnt == SCarg) arg_done = TRUE;
SCpnt863drivers/scsi/eata.cSCpnt = HD(j)->cp[i].SCpnt;
SCpnt864drivers/scsi/eata.cSCpnt->result = DID_RESET << 16;
SCpnt865drivers/scsi/eata.cSCpnt->host_scribble = NULL;
SCpnt871drivers/scsi/eata.cBN(j), i, SCpnt->pid);
SCpnt873drivers/scsi/eata.cSCpnt->scsi_done(SCpnt);
SCpnt892drivers/scsi/eata.cScsi_Cmnd *SCpnt;
SCpnt958drivers/scsi/eata.cSCpnt = spp->SCpnt;
SCpnt960drivers/scsi/eata.cif (SCpnt == NULL)
SCpnt963drivers/scsi/eata.cif (SCpnt != cpp->SCpnt)
SCpnt965drivers/scsi/eata.cBN(j), i, SCpnt, cpp->SCpnt);
SCpnt967drivers/scsi/eata.cif (SCpnt->host_scribble == NULL)
SCpnt969drivers/scsi/eata.cBN(j), i, SCpnt->pid, SCpnt);
SCpnt971drivers/scsi/eata.cif (*(unsigned int *)SCpnt->host_scribble != i) 
SCpnt973drivers/scsi/eata.c" irq %d.\n", BN(j), i, SCpnt->pid, 
SCpnt974drivers/scsi/eata.c*(unsigned int *)SCpnt->host_scribble, irq);
SCpnt982drivers/scsi/eata.cif (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE) 
SCpnt987drivers/scsi/eata.c&& SCpnt->device->type == TYPE_DISK
SCpnt988drivers/scsi/eata.c&& HD(j)->target_reset[SCpnt->target])
SCpnt993drivers/scsi/eata.c&& SCpnt->device->type == TYPE_DISK
SCpnt994drivers/scsi/eata.c&& (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
SCpnt1001drivers/scsi/eata.cHD(j)->target_reset[SCpnt->target] = FALSE;
SCpnt1003drivers/scsi/eata.cif (spp->target_status && SCpnt->device->type == TYPE_DISK)
SCpnt1006drivers/scsi/eata.cSCpnt->target, SCpnt->lun, SCpnt->pid,
SCpnt1007drivers/scsi/eata.cspp->target_status, SCpnt->sense_buffer[2]);
SCpnt1009drivers/scsi/eata.cHD(j)->target_time_out[SCpnt->target] = 0;
SCpnt1015drivers/scsi/eata.cif (HD(j)->target_time_out[SCpnt->target] > 1)
SCpnt1019drivers/scsi/eata.cHD(j)->target_time_out[SCpnt->target]++;
SCpnt1026drivers/scsi/eata.cif (SCpnt->device->type != TYPE_TAPE)
SCpnt1048drivers/scsi/eata.cSCpnt->result = status | spp->target_status;
SCpnt1054drivers/scsi/eata.cif (SCpnt->result || do_trace)
SCpnt1064drivers/scsi/eata.cSCpnt->target, SCpnt->lun, SCpnt->pid, HD(j)->iocount);
SCpnt1067drivers/scsi/eata.cSCpnt->host_scribble = NULL;
SCpnt1070drivers/scsi/eata.cSCpnt->scsi_done(SCpnt);
SCpnt1706drivers/scsi/fdomain.cint fdomain_16x0_queue( Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt1713drivers/scsi/fdomain.cSCpnt->target,
SCpnt1714drivers/scsi/fdomain.c*(unsigned char *)SCpnt->cmnd,
SCpnt1715drivers/scsi/fdomain.cSCpnt->use_sg,
SCpnt1716drivers/scsi/fdomain.cSCpnt->request_bufflen );
SCpnt1721drivers/scsi/fdomain.ccurrent_SC            = SCpnt; /* Save this for the done function */
SCpnt1764drivers/scsi/fdomain.cstatic void internal_done( Scsi_Cmnd *SCpnt )
SCpnt1766drivers/scsi/fdomain.cinternal_done_errcode = SCpnt->result;
SCpnt1770drivers/scsi/fdomain.cint fdomain_16x0_command( Scsi_Cmnd *SCpnt )
SCpnt1772drivers/scsi/fdomain.cfdomain_16x0_queue( SCpnt, internal_done );
SCpnt1782drivers/scsi/fdomain.cvoid print_info( Scsi_Cmnd *SCpnt )
SCpnt1788drivers/scsi/fdomain.cif (!SCpnt || !SCpnt->host) {
SCpnt1792drivers/scsi/fdomain.cprintk( "%s\n", fdomain_16x0_info( SCpnt->host ) );
SCpnt1793drivers/scsi/fdomain.cprint_banner( SCpnt->host );
SCpnt1794drivers/scsi/fdomain.cswitch (SCpnt->SCp.phase) {
SCpnt1802drivers/scsi/fdomain.cSCpnt->SCp.phase,
SCpnt1803drivers/scsi/fdomain.cSCpnt->target,
SCpnt1804drivers/scsi/fdomain.c*(unsigned char *)SCpnt->cmnd,
SCpnt1805drivers/scsi/fdomain.cSCpnt->use_sg,
SCpnt1806drivers/scsi/fdomain.cSCpnt->request_bufflen );
SCpnt1808drivers/scsi/fdomain.cSCpnt->SCp.sent_command,
SCpnt1809drivers/scsi/fdomain.cSCpnt->SCp.have_data_in,
SCpnt1810drivers/scsi/fdomain.cSCpnt->timeout );
SCpnt1851drivers/scsi/fdomain.cint fdomain_16x0_abort( Scsi_Cmnd *SCpnt)
SCpnt1869drivers/scsi/fdomain.cprint_info( SCpnt );
SCpnt1886drivers/scsi/fdomain.cint fdomain_16x0_reset( Scsi_Cmnd *SCpnt )
SCpnt1893drivers/scsi/fdomain.cif (SCpnt) printk( "fdomain: SCSI Bus Reset\n" );
SCpnt418drivers/scsi/in2000.cint in2000_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt421drivers/scsi/in2000.cunchar *cmd = (unchar *) SCpnt->cmnd;
SCpnt422drivers/scsi/in2000.cunchar target = SCpnt->target;
SCpnt423drivers/scsi/in2000.cvoid *buff = SCpnt->request_buffer;
SCpnt425drivers/scsi/in2000.cint bufflen = SCpnt->request_bufflen;
SCpnt452drivers/scsi/in2000.cfor (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
SCpnt458drivers/scsi/in2000.csize = SCpnt->cmd_len;  /* CDB length */ 
SCpnt497drivers/scsi/in2000.cSCpnt->result = DID_TIME_OUT << 16;
SCpnt498drivers/scsi/in2000.c(*done)(SCpnt);
SCpnt502drivers/scsi/in2000.cin2000_nsegment = SCpnt->use_sg;
SCpnt504drivers/scsi/in2000.cif(SCpnt->use_sg){
SCpnt514drivers/scsi/in2000.cin2000_SCptr = SCpnt;
SCpnt522drivers/scsi/in2000.coutb(SCpnt->lun & 7,INDATA);
SCpnt523drivers/scsi/in2000.cSCpnt->host_scribble = NULL;
SCpnt567drivers/scsi/in2000.cstatic void internal_done(Scsi_Cmnd * SCpnt)
SCpnt569drivers/scsi/in2000.cinternal_done_errcode = SCpnt->result;
SCpnt573drivers/scsi/in2000.cint in2000_command(Scsi_Cmnd * SCpnt)
SCpnt575drivers/scsi/in2000.cin2000_queuecommand(SCpnt, internal_done);
SCpnt656drivers/scsi/in2000.cint in2000_abort(Scsi_Cmnd * SCpnt)
SCpnt673drivers/scsi/in2000.cint in2000_reset(Scsi_Cmnd * SCpnt)
SCpnt690drivers/scsi/in2000.cif(SCpnt) SCpnt->flags |= NEEDS_JUMPSTART;
SCpnt84drivers/scsi/scsi.cstatic void scsi_done (Scsi_Cmnd *SCpnt);
SCpnt87drivers/scsi/scsi.cstatic void scsi_times_out (Scsi_Cmnd * SCpnt);
SCpnt89drivers/scsi/scsi.cScsi_Device ** SDpnt, Scsi_Cmnd * SCpnt,
SCpnt371drivers/scsi/scsi.cstatic void scan_scsis_done (Scsi_Cmnd * SCpnt)
SCpnt375drivers/scsi/scsi.cprintk ("scan_scsis_done(%p, %06x)\n", SCpnt->host, SCpnt->result);
SCpnt377drivers/scsi/scsi.cSCpnt->request.rq_status = RQ_SCSI_DONE;
SCpnt379drivers/scsi/scsi.cif (SCpnt->request.sem != NULL)
SCpnt380drivers/scsi/scsi.cup(SCpnt->request.sem);
SCpnt411drivers/scsi/scsi.cScsi_Cmnd *SCpnt;
SCpnt413drivers/scsi/scsi.cSCpnt = (Scsi_Cmnd *) scsi_init_malloc (sizeof (Scsi_Cmnd), GFP_ATOMIC | GFP_DMA);
SCpnt415drivers/scsi/scsi.cmemset (SCpnt, 0, sizeof (Scsi_Cmnd));
SCpnt429drivers/scsi/scsi.cshpnt->host_queue->prev = SCpnt;
SCpnt430drivers/scsi/scsi.cSCpnt->next = shpnt->host_queue;
SCpnt431drivers/scsi/scsi.cSCpnt->prev = NULL;
SCpnt432drivers/scsi/scsi.cshpnt->host_queue = SCpnt;
SCpnt445drivers/scsi/scsi.c&SDpnt, SCpnt, shpnt, scsi_result);
SCpnt480drivers/scsi/scsi.c&SDpnt, SCpnt, shpnt, scsi_result))
SCpnt492drivers/scsi/scsi.cfor(hqptr = shpnt->host_queue; hqptr != SCpnt; hqptr = hqptr->next) ;
SCpnt508drivers/scsi/scsi.cif (SCpnt != NULL)
SCpnt509drivers/scsi/scsi.cscsi_init_free ((char *) SCpnt, sizeof (Scsi_Cmnd));
SCpnt523drivers/scsi/scsi.cScsi_Device **SDpnt2, Scsi_Cmnd * SCpnt, struct Scsi_Host * shpnt, 
SCpnt557drivers/scsi/scsi.cSCpnt->host = SDpnt->host;
SCpnt558drivers/scsi/scsi.cSCpnt->device = SDpnt;
SCpnt559drivers/scsi/scsi.cSCpnt->target = SDpnt->id;
SCpnt560drivers/scsi/scsi.cSCpnt->lun = SDpnt->lun;
SCpnt561drivers/scsi/scsi.cSCpnt->channel = SDpnt->channel;
SCpnt564drivers/scsi/scsi.cSCpnt->request.sem = &sem;
SCpnt565drivers/scsi/scsi.cSCpnt->request.rq_status = RQ_SCSI_BUSY;
SCpnt566drivers/scsi/scsi.cscsi_do_cmd (SCpnt, (void *) scsi_cmd,
SCpnt574drivers/scsi/scsi.cdev, lun, SCpnt->result);
SCpnt575drivers/scsi/scsi.cprint_driverbyte(SCpnt->result); print_hostbyte(SCpnt->result);
SCpnt579drivers/scsi/scsi.cif (SCpnt->result) {
SCpnt580drivers/scsi/scsi.cif (((driver_byte (SCpnt->result) & DRIVER_SENSE) ||
SCpnt581drivers/scsi/scsi.c(status_byte (SCpnt->result) & CHECK_CONDITION)) &&
SCpnt582drivers/scsi/scsi.c((SCpnt->sense_buffer[0] & 0x70) >> 4) == 7) {
SCpnt583drivers/scsi/scsi.cif (((SCpnt->sense_buffer[2] & 0xf) != NOT_READY) &&
SCpnt584drivers/scsi/scsi.c((SCpnt->sense_buffer[2] & 0xf) != UNIT_ATTENTION) &&
SCpnt585drivers/scsi/scsi.c((SCpnt->sense_buffer[2] & 0xf) != ILLEGAL_REQUEST || lun > 0))
SCpnt604drivers/scsi/scsi.cSCpnt->cmd_len = 0;
SCpnt607drivers/scsi/scsi.cSCpnt->request.sem = &sem;
SCpnt608drivers/scsi/scsi.cSCpnt->request.rq_status = RQ_SCSI_BUSY;
SCpnt609drivers/scsi/scsi.cscsi_do_cmd (SCpnt, (void *) scsi_cmd,
SCpnt617drivers/scsi/scsi.cSCpnt->result ? "failed" : "successful", SCpnt->result);
SCpnt620drivers/scsi/scsi.cif (SCpnt->result)
SCpnt753drivers/scsi/scsi.cSCpnt->cmd_len = 0;
SCpnt756drivers/scsi/scsi.cSCpnt->request.rq_status = RQ_SCSI_BUSY;
SCpnt757drivers/scsi/scsi.cSCpnt->request.sem = &sem;
SCpnt758drivers/scsi/scsi.cscsi_do_cmd (SCpnt, (void *) scsi_cmd,
SCpnt825drivers/scsi/scsi.cstatic void scsi_times_out (Scsi_Cmnd * SCpnt)
SCpnt828drivers/scsi/scsi.cswitch (SCpnt->internal_timeout & (IN_ABORT | IN_RESET | IN_RESET2))
SCpnt837drivers/scsi/scsi.cif (!scsi_abort (SCpnt, DID_TIME_OUT))
SCpnt841drivers/scsi/scsi.cSCpnt->host->host_no, SCpnt->pid);
SCpnt842drivers/scsi/scsi.cif (!scsi_reset (SCpnt, SCSI_RESET_ASYNCHRONOUS))
SCpnt851drivers/scsi/scsi.cSCpnt->host->host_no, SCpnt->pid);
SCpnt852drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_RESET;
SCpnt853drivers/scsi/scsi.cSCpnt->internal_timeout |= IN_RESET2;
SCpnt854drivers/scsi/scsi.cscsi_reset (SCpnt,
SCpnt860drivers/scsi/scsi.cSCpnt->host->host_no, SCpnt->pid);
SCpnt878drivers/scsi/scsi.cScsi_Cmnd * SCpnt = NULL;
SCpnt896drivers/scsi/scsi.cSCpnt = device->device_queue;
SCpnt897drivers/scsi/scsi.cwhile(SCpnt){
SCpnt898drivers/scsi/scsi.cif(SCpnt->request.rq_status == RQ_INACTIVE) break;
SCpnt899drivers/scsi/scsi.cSCpnt = SCpnt->device_next;
SCpnt902drivers/scsi/scsi.cSCpnt = device->host->host_queue;
SCpnt903drivers/scsi/scsi.cwhile(SCpnt){
SCpnt904drivers/scsi/scsi.cif(SCpnt->channel == device->channel 
SCpnt905drivers/scsi/scsi.c&& SCpnt->target == device->id) {
SCpnt906drivers/scsi/scsi.cif (SCpnt->lun == device->lun) {
SCpnt908drivers/scsi/scsi.c&& SCpnt->request.rq_status == RQ_INACTIVE) 
SCpnt910drivers/scsi/scsi.cfound=SCpnt;
SCpnt913drivers/scsi/scsi.cif(SCpnt->request.rq_status != RQ_INACTIVE) {
SCpnt922drivers/scsi/scsi.cSCpnt = SCpnt->next;
SCpnt924drivers/scsi/scsi.cSCpnt = found;
SCpnt927drivers/scsi/scsi.cif (!SCpnt) return NULL;
SCpnt932drivers/scsi/scsi.cmemcpy(&SCpnt->request, req, sizeof(struct request));
SCpnt949drivers/scsi/scsi.cSCpnt->request.bhtail = bh;
SCpnt955drivers/scsi/scsi.cSCpnt->request.nr_sectors -= req->nr_sectors;
SCpnt958drivers/scsi/scsi.cSCpnt->request.sem = NULL; /* Wait until whole thing done */
SCpnt964drivers/scsi/scsi.cSCpnt->request.rq_status = RQ_SCSI_BUSY;  /* Busy, but no request */
SCpnt965drivers/scsi/scsi.cSCpnt->request.sem = NULL;   /* And no one is waiting for the device 
SCpnt969drivers/scsi/scsi.cSCpnt->use_sg = 0;               /* Reset the scatter-gather flag */
SCpnt970drivers/scsi/scsi.cSCpnt->old_use_sg  = 0;
SCpnt971drivers/scsi/scsi.cSCpnt->transfersize = 0;
SCpnt972drivers/scsi/scsi.cSCpnt->underflow = 0;
SCpnt973drivers/scsi/scsi.cSCpnt->cmd_len = 0;
SCpnt978drivers/scsi/scsi.cSCpnt->channel = device->channel;
SCpnt979drivers/scsi/scsi.cSCpnt->lun = device->lun;
SCpnt980drivers/scsi/scsi.cSCpnt->target = device->id;
SCpnt982drivers/scsi/scsi.creturn SCpnt;
SCpnt1004drivers/scsi/scsi.cScsi_Cmnd * SCpnt = NULL;
SCpnt1026drivers/scsi/scsi.cSCpnt = device->device_queue;
SCpnt1027drivers/scsi/scsi.cwhile(SCpnt){
SCpnt1028drivers/scsi/scsi.cSCwait = SCpnt;
SCpnt1029drivers/scsi/scsi.cif(SCpnt->request.rq_status == RQ_INACTIVE) break;
SCpnt1030drivers/scsi/scsi.cSCpnt = SCpnt->device_next;
SCpnt1033drivers/scsi/scsi.cSCpnt = device->host->host_queue;
SCpnt1034drivers/scsi/scsi.cwhile(SCpnt){
SCpnt1035drivers/scsi/scsi.cif(SCpnt->channel == device->channel 
SCpnt1036drivers/scsi/scsi.c&& SCpnt->target == device->id) {
SCpnt1037drivers/scsi/scsi.cif (SCpnt->lun == device->lun) {
SCpnt1038drivers/scsi/scsi.cSCwait = SCpnt;
SCpnt1040drivers/scsi/scsi.c&& SCpnt->request.rq_status == RQ_INACTIVE) 
SCpnt1042drivers/scsi/scsi.cfound=SCpnt;
SCpnt1045drivers/scsi/scsi.cif(SCpnt->request.rq_status != RQ_INACTIVE) {
SCpnt1055drivers/scsi/scsi.cSCpnt = SCpnt->next;
SCpnt1057drivers/scsi/scsi.cSCpnt = found;
SCpnt1068drivers/scsi/scsi.cif (!SCpnt || SCpnt->request.rq_status != RQ_INACTIVE)  /* Might have changed */
SCpnt1098drivers/scsi/scsi.cmemcpy(&SCpnt->request, req, sizeof(struct request));
SCpnt1115drivers/scsi/scsi.cSCpnt->request.bhtail = bh;
SCpnt1120drivers/scsi/scsi.cSCpnt->request.nr_sectors -= req->nr_sectors;
SCpnt1123drivers/scsi/scsi.cSCpnt->request.sem = NULL; /* Wait until whole thing done*/
SCpnt1132drivers/scsi/scsi.cSCpnt->request.rq_status = RQ_SCSI_BUSY;
SCpnt1133drivers/scsi/scsi.cSCpnt->request.sem = NULL;   /* And no one is waiting for this 
SCpnt1141drivers/scsi/scsi.cSCpnt->use_sg = 0;            /* Reset the scatter-gather flag */
SCpnt1142drivers/scsi/scsi.cSCpnt->old_use_sg  = 0;
SCpnt1143drivers/scsi/scsi.cSCpnt->transfersize = 0;      /* No default transfer size */
SCpnt1144drivers/scsi/scsi.cSCpnt->cmd_len = 0;
SCpnt1146drivers/scsi/scsi.cSCpnt->underflow = 0;         /* Do not flag underflow conditions */
SCpnt1151drivers/scsi/scsi.cSCpnt->channel = device->channel;
SCpnt1152drivers/scsi/scsi.cSCpnt->lun = device->lun;
SCpnt1153drivers/scsi/scsi.cSCpnt->target = device->id;
SCpnt1155drivers/scsi/scsi.creturn SCpnt;
SCpnt1162drivers/scsi/scsi.cinline void internal_cmnd (Scsi_Cmnd * SCpnt)
SCpnt1171drivers/scsi/scsi.chost = SCpnt->host;
SCpnt1181drivers/scsi/scsi.cSCpnt->serial_number = serial_number;
SCpnt1187drivers/scsi/scsi.cupdate_timeout(SCpnt, SCpnt->timeout_per_command);
SCpnt1196drivers/scsi/scsi.cSCpnt->host->host_no, SCpnt->channel, SCpnt->target, SCpnt->cmnd, 
SCpnt1197drivers/scsi/scsi.cSCpnt->buffer, SCpnt->bufflen, SCpnt->done);
SCpnt1215drivers/scsi/scsi.cif(!intr_count && SCpnt->host->irq)
SCpnt1216drivers/scsi/scsi.cdisable_irq(SCpnt->host->irq);
SCpnt1218drivers/scsi/scsi.chost->hostt->queuecommand (SCpnt, scsi_done);
SCpnt1220drivers/scsi/scsi.cif(!intr_count && SCpnt->host->irq)
SCpnt1221drivers/scsi/scsi.cenable_irq(SCpnt->host->irq);
SCpnt1229drivers/scsi/scsi.ctemp=host->hostt->command (SCpnt);
SCpnt1230drivers/scsi/scsi.cSCpnt->result = temp;
SCpnt1237drivers/scsi/scsi.cscsi_done(SCpnt);
SCpnt1244drivers/scsi/scsi.cstatic void scsi_request_sense (Scsi_Cmnd * SCpnt)
SCpnt1250drivers/scsi/scsi.cSCpnt->flags |= WAS_SENSE | ASKED_FOR_SENSE;
SCpnt1251drivers/scsi/scsi.cupdate_timeout(SCpnt, SENSE_TIMEOUT);
SCpnt1255drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd , (void *) generic_sense, 
SCpnt1258drivers/scsi/scsi.cSCpnt->cmnd[1] = SCpnt->lun << 5;
SCpnt1259drivers/scsi/scsi.cSCpnt->cmnd[4] = sizeof(SCpnt->sense_buffer);
SCpnt1261drivers/scsi/scsi.cSCpnt->request_buffer = &SCpnt->sense_buffer;
SCpnt1262drivers/scsi/scsi.cSCpnt->request_bufflen = sizeof(SCpnt->sense_buffer);
SCpnt1263drivers/scsi/scsi.cSCpnt->use_sg = 0;
SCpnt1264drivers/scsi/scsi.cSCpnt->cmd_len = COMMAND_SIZE(SCpnt->cmnd[0]);
SCpnt1265drivers/scsi/scsi.cinternal_cmnd (SCpnt);
SCpnt1277drivers/scsi/scsi.cvoid scsi_do_cmd (Scsi_Cmnd * SCpnt, const void *cmnd ,
SCpnt1282drivers/scsi/scsi.cstruct Scsi_Host * host = SCpnt->host;
SCpnt1287drivers/scsi/scsi.cint target = SCpnt->target;
SCpnt1291drivers/scsi/scsi.c"command : " , host->host_no, SCpnt->channel, target, buffer, 
SCpnt1315drivers/scsi/scsi.cSCpnt->pid = scsi_pid++;
SCpnt1335drivers/scsi/scsi.cmemcpy ((void *) SCpnt->data_cmnd , (const void *) cmnd, 12);
SCpnt1337drivers/scsi/scsi.cSCpnt->host = host;
SCpnt1338drivers/scsi/scsi.cSCpnt->channel = channel;
SCpnt1339drivers/scsi/scsi.cSCpnt->target = target;
SCpnt1340drivers/scsi/scsi.cSCpnt->lun = (SCpnt->data_cmnd[1] >> 5);
SCpnt1342drivers/scsi/scsi.cSCpnt->reset_chain = NULL;
SCpnt1343drivers/scsi/scsi.cSCpnt->serial_number = 0;
SCpnt1344drivers/scsi/scsi.cSCpnt->bufflen = bufflen;
SCpnt1345drivers/scsi/scsi.cSCpnt->buffer = buffer;
SCpnt1346drivers/scsi/scsi.cSCpnt->flags=0;
SCpnt1347drivers/scsi/scsi.cSCpnt->retries=0;
SCpnt1348drivers/scsi/scsi.cSCpnt->allowed=retries;
SCpnt1349drivers/scsi/scsi.cSCpnt->done = done;
SCpnt1350drivers/scsi/scsi.cSCpnt->timeout_per_command = timeout;
SCpnt1352drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd , (const void *) cmnd, 12);
SCpnt1356drivers/scsi/scsi.cmemset ((void *) SCpnt->sense_buffer, 0, sizeof SCpnt->sense_buffer);
SCpnt1357drivers/scsi/scsi.cSCpnt->request_buffer = buffer;
SCpnt1358drivers/scsi/scsi.cSCpnt->request_bufflen = bufflen;
SCpnt1359drivers/scsi/scsi.cSCpnt->old_use_sg = SCpnt->use_sg;
SCpnt1360drivers/scsi/scsi.cif (SCpnt->cmd_len == 0)
SCpnt1361drivers/scsi/scsi.cSCpnt->cmd_len = COMMAND_SIZE(SCpnt->cmnd[0]);
SCpnt1362drivers/scsi/scsi.cSCpnt->old_cmd_len = SCpnt->cmd_len;
SCpnt1366drivers/scsi/scsi.cSCpnt->internal_timeout = 0;
SCpnt1367drivers/scsi/scsi.cSCpnt->abort_reason = 0;
SCpnt1368drivers/scsi/scsi.cinternal_cmnd (SCpnt);
SCpnt1375drivers/scsi/scsi.cstatic int check_sense (Scsi_Cmnd * SCpnt)
SCpnt1381drivers/scsi/scsi.cif (((SCpnt->sense_buffer[0] & 0x70) >> 4) != 7) {
SCpnt1382drivers/scsi/scsi.cif(!(SCpnt->flags & ASKED_FOR_SENSE))
SCpnt1388drivers/scsi/scsi.cSCpnt->flags &= ~ASKED_FOR_SENSE;
SCpnt1391drivers/scsi/scsi.cprintk("scsi%d, channel%d : ", SCpnt->host->host_no, SCpnt->channel);
SCpnt1392drivers/scsi/scsi.cprint_sense("", SCpnt);
SCpnt1395drivers/scsi/scsi.cif (SCpnt->sense_buffer[2] & 0xe0)
SCpnt1398drivers/scsi/scsi.cswitch (SCpnt->sense_buffer[2] & 0xf)
SCpnt1415drivers/scsi/scsi.cif( SCpnt->device->expecting_cc_ua )
SCpnt1417drivers/scsi/scsi.cSCpnt->device->expecting_cc_ua = 0;
SCpnt1459drivers/scsi/scsi.cstatic void scsi_done (Scsi_Cmnd * SCpnt)
SCpnt1465drivers/scsi/scsi.cstruct Scsi_Host * host = SCpnt->host;
SCpnt1466drivers/scsi/scsi.cint result = SCpnt->result;
SCpnt1467drivers/scsi/scsi.cSCpnt->serial_number = 0;
SCpnt1468drivers/scsi/scsi.coldto = update_timeout(SCpnt, 0);
SCpnt1472drivers/scsi/scsi.cresult, SCpnt->target, SCpnt->lun);
SCpnt1478drivers/scsi/scsi.cif(host_byte(result) == DID_ABORT && SCpnt->abort_reason)
SCpnt1479drivers/scsi/scsi.cSCpnt->result = result = (result & 0xff00ffff) |
SCpnt1480drivers/scsi/scsi.c(SCpnt->abort_reason << 16);
SCpnt1492drivers/scsi/scsi.cif(SCpnt->flags & WAS_SENSE)
SCpnt1494drivers/scsi/scsi.cSCpnt->use_sg = SCpnt->old_use_sg;
SCpnt1495drivers/scsi/scsi.cSCpnt->cmd_len = SCpnt->old_cmd_len;
SCpnt1501drivers/scsi/scsi.cif (status_byte(result) && (SCpnt->flags & WAS_SENSE))
SCpnt1504drivers/scsi/scsi.cSCpnt->flags &= ~WAS_SENSE;
SCpnt1506drivers/scsi/scsi.cSCpnt->internal_timeout &= ~SENSE_TIMEOUT;
SCpnt1509drivers/scsi/scsi.cif (!(SCpnt->flags & WAS_RESET))
SCpnt1513drivers/scsi/scsi.cSCpnt->host->host_no, SCpnt->channel, SCpnt->target, 
SCpnt1514drivers/scsi/scsi.cSCpnt->lun);
SCpnt1515drivers/scsi/scsi.cscsi_reset(SCpnt, SCSI_RESET_SYNCHRONOUS);
SCpnt1530drivers/scsi/scsi.cif (SCpnt->flags & WAS_SENSE)
SCpnt1535drivers/scsi/scsi.cSCpnt->flags &= ~WAS_SENSE;
SCpnt1537drivers/scsi/scsi.cSCpnt->internal_timeout &= ~SENSE_TIMEOUT;
SCpnt1540drivers/scsi/scsi.cswitch (checked = check_sense(SCpnt))
SCpnt1547drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1583drivers/scsi/scsi.cswitch (check_sense(SCpnt))
SCpnt1586drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1599drivers/scsi/scsi.cscsi_request_sense (SCpnt);
SCpnt1611drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1617drivers/scsi/scsi.c" reset.\n", SCpnt->host->host_no, SCpnt->channel);
SCpnt1618drivers/scsi/scsi.cscsi_reset(SCpnt, SCSI_RESET_SYNCHRONOUS);
SCpnt1642drivers/scsi/scsi.cif (SCpnt->flags & WAS_TIMEDOUT)
SCpnt1651drivers/scsi/scsi.cif (SCpnt->cmnd[0] != TEST_UNIT_READY &&
SCpnt1652drivers/scsi/scsi.cSCpnt->cmnd[0] != INQUIRY)
SCpnt1661drivers/scsi/scsi.cSCpnt->flags  |= WAS_TIMEDOUT;
SCpnt1662drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_ABORT;
SCpnt1685drivers/scsi/scsi.cif (SCpnt->flags & IS_RESETTING)
SCpnt1687drivers/scsi/scsi.cSCpnt->flags &= ~IS_RESETTING;
SCpnt1694drivers/scsi/scsi.cswitch (check_sense(SCpnt)) {
SCpnt1696drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1709drivers/scsi/scsi.cscsi_request_sense (SCpnt);
SCpnt1730drivers/scsi/scsi.cSCpnt->allowed, SCpnt->retries);
SCpnt1732drivers/scsi/scsi.cif ((++SCpnt->retries) < SCpnt->allowed)
SCpnt1734drivers/scsi/scsi.cif ((SCpnt->retries >= (SCpnt->allowed >> 1))
SCpnt1735drivers/scsi/scsi.c&& !(jiffies < SCpnt->host->last_reset + MIN_RESET_PERIOD)
SCpnt1736drivers/scsi/scsi.c&& !(SCpnt->flags & WAS_RESET))
SCpnt1739drivers/scsi/scsi.cSCpnt->host->host_no, SCpnt->channel);
SCpnt1740drivers/scsi/scsi.cscsi_reset(SCpnt, SCSI_RESET_SYNCHRONOUS);
SCpnt1754drivers/scsi/scsi.cif (SCpnt->flags & WAS_SENSE)
SCpnt1755drivers/scsi/scsi.cscsi_request_sense(SCpnt);
SCpnt1758drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd,
SCpnt1759drivers/scsi/scsi.c(void*) SCpnt->data_cmnd,
SCpnt1760drivers/scsi/scsi.csizeof(SCpnt->data_cmnd));
SCpnt1761drivers/scsi/scsi.cSCpnt->request_buffer = SCpnt->buffer;
SCpnt1762drivers/scsi/scsi.cSCpnt->request_bufflen = SCpnt->bufflen;
SCpnt1763drivers/scsi/scsi.cSCpnt->use_sg = SCpnt->old_use_sg;
SCpnt1764drivers/scsi/scsi.cSCpnt->cmd_len = SCpnt->old_cmd_len;
SCpnt1765drivers/scsi/scsi.cinternal_cmnd (SCpnt);
SCpnt1774drivers/scsi/scsi.cprintk("Calling done function - at address %p\n", SCpnt->done);
SCpnt1782drivers/scsi/scsi.cif (MAJOR(SCpnt->request.rq_dev) != SCSI_DISK_MAJOR &&
SCpnt1783drivers/scsi/scsi.cMAJOR(SCpnt->request.rq_dev) != SCSI_CDROM_MAJOR) {
SCpnt1793drivers/scsi/scsi.cSCpnt->result = result | ((exit & 0xff) << 24);
SCpnt1794drivers/scsi/scsi.cSCpnt->use_sg = SCpnt->old_use_sg;
SCpnt1795drivers/scsi/scsi.cSCpnt->cmd_len = SCpnt->old_cmd_len;
SCpnt1796drivers/scsi/scsi.cSCpnt->done (SCpnt);
SCpnt1821drivers/scsi/scsi.cint scsi_abort (Scsi_Cmnd * SCpnt, int why)
SCpnt1825drivers/scsi/scsi.cstruct Scsi_Host * host = SCpnt->host;
SCpnt1836drivers/scsi/scsi.cif (SCpnt->serial_number != SCpnt->serial_number_at_timeout) {
SCpnt1841drivers/scsi/scsi.cif (SCpnt->internal_timeout & IN_ABORT)
SCpnt1844drivers/scsi/scsi.cwhile (SCpnt->internal_timeout & IN_ABORT)
SCpnt1849drivers/scsi/scsi.cSCpnt->internal_timeout |= IN_ABORT;
SCpnt1850drivers/scsi/scsi.coldto = update_timeout(SCpnt, ABORT_TIMEOUT);
SCpnt1852drivers/scsi/scsi.cif ((SCpnt->flags & IS_RESETTING) && SCpnt->device->soft_reset) {
SCpnt1858drivers/scsi/scsi.cSCpnt->channel, SCpnt->target, SCpnt->lun);
SCpnt1863drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_ABORT;
SCpnt1864drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1869drivers/scsi/scsi.cSCpnt->pid, SCpnt->host->host_no, (int) SCpnt->channel, 
SCpnt1870drivers/scsi/scsi.c(int) SCpnt->target, (int) SCpnt->lun);
SCpnt1871drivers/scsi/scsi.cprint_command (SCpnt->cmnd);
SCpnt1872drivers/scsi/scsi.cif (SCpnt->serial_number != SCpnt->serial_number_at_timeout)
SCpnt1874drivers/scsi/scsi.cSCpnt->abort_reason = why;
SCpnt1875drivers/scsi/scsi.cswitch(host->hostt->abort(SCpnt)) {
SCpnt1887drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_ABORT;
SCpnt1888drivers/scsi/scsi.cif(SCpnt->flags & WAS_TIMEDOUT) {
SCpnt1895drivers/scsi/scsi.cSCpnt->flags |= WAS_TIMEDOUT;
SCpnt1896drivers/scsi/scsi.coldto = SCpnt->timeout_per_command;
SCpnt1897drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1906drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1914drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_ABORT;
SCpnt1917drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_ABORT;
SCpnt1918drivers/scsi/scsi.cupdate_timeout(SCpnt, 0);
SCpnt1922drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_ABORT;
SCpnt1943drivers/scsi/scsi.cScsi_Cmnd *SCpnt;
SCpnt1944drivers/scsi/scsi.cfor (SCpnt = Host->host_queue; SCpnt; SCpnt = SCpnt->next)
SCpnt1945drivers/scsi/scsi.cscsi_mark_device_reset(SCpnt->device);
SCpnt1953drivers/scsi/scsi.cScsi_Cmnd *SCpnt;
SCpnt1954drivers/scsi/scsi.cfor (SCpnt = Host->host_queue; SCpnt; SCpnt = SCpnt->next)
SCpnt1955drivers/scsi/scsi.cif (SCpnt->channel == channel)
SCpnt1956drivers/scsi/scsi.cscsi_mark_device_reset(SCpnt->device);
SCpnt1960drivers/scsi/scsi.cint scsi_reset (Scsi_Cmnd * SCpnt, unsigned int reset_flags)
SCpnt1965drivers/scsi/scsi.cstruct Scsi_Host * host = SCpnt->host;
SCpnt1978drivers/scsi/scsi.cSCpnt->host->suggest_bus_reset = FALSE;
SCpnt2014drivers/scsi/scsi.cSCpnt->host->suggest_bus_reset = TRUE;
SCpnt2026drivers/scsi/scsi.cif (SCpnt->serial_number != SCpnt->serial_number_at_timeout) {
SCpnt2031drivers/scsi/scsi.cif (SCpnt->internal_timeout & IN_RESET)
SCpnt2034drivers/scsi/scsi.cwhile (SCpnt->internal_timeout & IN_RESET)
SCpnt2039drivers/scsi/scsi.cSCpnt->internal_timeout |= IN_RESET;
SCpnt2040drivers/scsi/scsi.cupdate_timeout(SCpnt, RESET_TIMEOUT);
SCpnt2059drivers/scsi/scsi.ctemp = host->hostt->reset(SCpnt, reset_flags);
SCpnt2067drivers/scsi/scsi.cSCpnt->flags |= (WAS_RESET | IS_RESETTING);
SCpnt2068drivers/scsi/scsi.ctemp = host->hostt->reset(SCpnt, reset_flags);
SCpnt2091drivers/scsi/scsi.cscsi_mark_bus_reset(host, SCpnt->channel);
SCpnt2092drivers/scsi/scsi.celse scsi_mark_device_reset(SCpnt->device);
SCpnt2095drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_RESET;
SCpnt2102drivers/scsi/scsi.cscsi_mark_bus_reset(host, SCpnt->channel);
SCpnt2103drivers/scsi/scsi.celse scsi_mark_device_reset(SCpnt->device);
SCpnt2107drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_RESET;
SCpnt2108drivers/scsi/scsi.cscsi_request_sense (SCpnt);
SCpnt2114drivers/scsi/scsi.cscsi_mark_bus_reset(host, SCpnt->channel);
SCpnt2115drivers/scsi/scsi.celse scsi_mark_device_reset(SCpnt->device);
SCpnt2116drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_RESET;
SCpnt2117drivers/scsi/scsi.cscsi_request_sense (SCpnt);
SCpnt2127drivers/scsi/scsi.cif( SCpnt->request.rq_status != RQ_INACTIVE
SCpnt2128drivers/scsi/scsi.c&& SCpnt1 != SCpnt)
SCpnt2129drivers/scsi/scsi.cscsi_request_sense (SCpnt);
SCpnt2142drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_RESET;
SCpnt2143drivers/scsi/scsi.cupdate_timeout(SCpnt, 0);
SCpnt2166drivers/scsi/scsi.cScsi_Cmnd * SCpnt = NULL;
SCpnt2179drivers/scsi/scsi.cfor (SCpnt = host->host_queue; SCpnt; SCpnt = SCpnt->next)
SCpnt2180drivers/scsi/scsi.cif (SCpnt->timeout == -1)
SCpnt2182drivers/scsi/scsi.cSCpnt->timeout = 0;
SCpnt2183drivers/scsi/scsi.cSCpnt->serial_number_at_timeout = SCpnt->serial_number;
SCpnt2189drivers/scsi/scsi.cfor (SCpnt = host->host_queue; SCpnt; SCpnt = SCpnt->next)
SCpnt2190drivers/scsi/scsi.cif (SCpnt->serial_number_at_timeout > 0 &&
SCpnt2191drivers/scsi/scsi.cSCpnt->serial_number_at_timeout == SCpnt->serial_number)
SCpnt2194drivers/scsi/scsi.cscsi_times_out(SCpnt);
SCpnt2195drivers/scsi/scsi.cSCpnt->serial_number_at_timeout = 0;
SCpnt2217drivers/scsi/scsi.cScsi_Cmnd * SCpnt = NULL;
SCpnt2265drivers/scsi/scsi.cfor(SCpnt = host->host_queue; SCpnt; SCpnt = SCpnt->next)
SCpnt2266drivers/scsi/scsi.cif (SCpnt->timeout > 0) {
SCpnt2267drivers/scsi/scsi.cif (SCpnt != SCset)
SCpnt2268drivers/scsi/scsi.cSCpnt->timeout -= used;
SCpnt2269drivers/scsi/scsi.cif(SCpnt->timeout <= 0) SCpnt->timeout = -1;
SCpnt2270drivers/scsi/scsi.cif(SCpnt->timeout > 0 && SCpnt->timeout < least)
SCpnt2271drivers/scsi/scsi.cleast = SCpnt->timeout;
SCpnt2413drivers/scsi/scsi.cScsi_Cmnd * SCpnt;                 
SCpnt2420drivers/scsi/scsi.cSCpnt = (Scsi_Cmnd *)
SCpnt2424drivers/scsi/scsi.cSCpnt->host = host;
SCpnt2425drivers/scsi/scsi.cSCpnt->device = SDpnt;
SCpnt2426drivers/scsi/scsi.cSCpnt->target = SDpnt->id;
SCpnt2427drivers/scsi/scsi.cSCpnt->lun = SDpnt->lun;
SCpnt2428drivers/scsi/scsi.cSCpnt->channel = SDpnt->channel;
SCpnt2429drivers/scsi/scsi.cSCpnt->request.rq_status = RQ_INACTIVE;
SCpnt2430drivers/scsi/scsi.cSCpnt->use_sg = 0;
SCpnt2431drivers/scsi/scsi.cSCpnt->old_use_sg = 0;
SCpnt2432drivers/scsi/scsi.cSCpnt->old_cmd_len = 0;
SCpnt2433drivers/scsi/scsi.cSCpnt->timeout = 0;
SCpnt2434drivers/scsi/scsi.cSCpnt->underflow = 0;
SCpnt2435drivers/scsi/scsi.cSCpnt->transfersize = 0;
SCpnt2436drivers/scsi/scsi.cSCpnt->serial_number = 0;
SCpnt2437drivers/scsi/scsi.cSCpnt->serial_number_at_timeout = 0;
SCpnt2438drivers/scsi/scsi.cSCpnt->host_scribble = NULL;
SCpnt2440drivers/scsi/scsi.chost->host_queue->prev = SCpnt;
SCpnt2441drivers/scsi/scsi.cSCpnt->next = host->host_queue;
SCpnt2442drivers/scsi/scsi.cSCpnt->prev = NULL;
SCpnt2443drivers/scsi/scsi.chost->host_queue = SCpnt;
SCpnt2444drivers/scsi/scsi.cSCpnt->device_next = SDpnt->device_queue;
SCpnt2445drivers/scsi/scsi.cSDpnt->device_queue = SCpnt;
SCpnt2578drivers/scsi/scsi.cScsi_Cmnd *SCpnt;
SCpnt2720drivers/scsi/scsi.cfor(SCpnt=scd->host->host_queue; SCpnt; SCpnt = SCpnt->next){
SCpnt2721drivers/scsi/scsi.cif(SCpnt->device == scd) {
SCpnt2722drivers/scsi/scsi.cif(SCpnt->prev != NULL)
SCpnt2723drivers/scsi/scsi.cSCpnt->prev->next = SCpnt->next;
SCpnt2724drivers/scsi/scsi.cif(SCpnt->next != NULL)
SCpnt2725drivers/scsi/scsi.cSCpnt->next->prev = SCpnt->prev;
SCpnt2726drivers/scsi/scsi.cif(SCpnt == scd->host->host_queue)
SCpnt2727drivers/scsi/scsi.cscd->host->host_queue = SCpnt->next;
SCpnt2728drivers/scsi/scsi.cscsi_init_free((char *) SCpnt, sizeof(*SCpnt));
SCpnt2981drivers/scsi/scsi.cScsi_Cmnd * SCpnt;
SCpnt2997drivers/scsi/scsi.cfor(SCpnt = shpnt->host_queue; SCpnt; SCpnt = SCpnt->next)
SCpnt3001drivers/scsi/scsi.cif(SCpnt->request.rq_status != RQ_INACTIVE) {
SCpnt3003drivers/scsi/scsi.cfor(SCpnt = shpnt->host_queue; SCpnt; SCpnt = SCpnt->next)
SCpnt3004drivers/scsi/scsi.cif(SCpnt->request.rq_status == RQ_SCSI_DISCONNECTING)
SCpnt3005drivers/scsi/scsi.cSCpnt->request.rq_status = RQ_INACTIVE;
SCpnt3009drivers/scsi/scsi.cSCpnt->request.rq_status = RQ_SCSI_DISCONNECTING;  /* Mark as busy */
SCpnt3032drivers/scsi/scsi.cSCpnt = sdpnt->host->host_queue->next;
SCpnt3034drivers/scsi/scsi.csdpnt->host->host_queue = SCpnt;
SCpnt3035drivers/scsi/scsi.cif (SCpnt) SCpnt->prev = NULL;
SCpnt3181drivers/scsi/scsi.cScsi_Cmnd * SCpnt;
SCpnt3202drivers/scsi/scsi.cfor(SCpnt = SDpnt->host->host_queue; SCpnt; SCpnt = SCpnt->next)
SCpnt3204drivers/scsi/scsi.cif(SCpnt->device == SDpnt)
SCpnt3206drivers/scsi/scsi.cif(SCpnt->prev != NULL)
SCpnt3207drivers/scsi/scsi.cSCpnt->prev->next = SCpnt->next;
SCpnt3208drivers/scsi/scsi.cif(SCpnt->next != NULL)
SCpnt3209drivers/scsi/scsi.cSCpnt->next->prev = SCpnt->prev;
SCpnt3210drivers/scsi/scsi.cif(SCpnt == SDpnt->host->host_queue)
SCpnt3211drivers/scsi/scsi.cSDpnt->host->host_queue = SCpnt->next;
SCpnt3212drivers/scsi/scsi.cscsi_init_free((char *) SCpnt, sizeof(*SCpnt));
SCpnt3295drivers/scsi/scsi.cScsi_Cmnd * SCpnt;
SCpnt3299drivers/scsi/scsi.cfor(SCpnt=shpnt->host_queue; SCpnt; SCpnt = SCpnt->next)
SCpnt3303drivers/scsi/scsi.ci++, SCpnt->host->host_no,
SCpnt3304drivers/scsi/scsi.cSCpnt->channel,
SCpnt3305drivers/scsi/scsi.cSCpnt->target,
SCpnt3306drivers/scsi/scsi.cSCpnt->lun,
SCpnt3307drivers/scsi/scsi.ckdevname(SCpnt->request.rq_dev),
SCpnt3308drivers/scsi/scsi.cSCpnt->request.sector,
SCpnt3309drivers/scsi/scsi.cSCpnt->request.nr_sectors,
SCpnt3310drivers/scsi/scsi.cSCpnt->request.current_nr_sectors,
SCpnt3311drivers/scsi/scsi.cSCpnt->use_sg,
SCpnt3312drivers/scsi/scsi.cSCpnt->retries,
SCpnt3313drivers/scsi/scsi.cSCpnt->allowed,
SCpnt3314drivers/scsi/scsi.cSCpnt->flags,
SCpnt3315drivers/scsi/scsi.cSCpnt->timeout_per_command,
SCpnt3316drivers/scsi/scsi.cSCpnt->timeout,
SCpnt3317drivers/scsi/scsi.cSCpnt->internal_timeout,
SCpnt3318drivers/scsi/scsi.cSCpnt->cmnd[0],
SCpnt3319drivers/scsi/scsi.cSCpnt->sense_buffer[2],
SCpnt3320drivers/scsi/scsi.cSCpnt->result);
SCpnt491drivers/scsi/scsi.hstatic Scsi_Cmnd * end_scsi_request(Scsi_Cmnd * SCpnt, int uptodate, int sectors)
SCpnt496drivers/scsi/scsi.hreq = &SCpnt->request;
SCpnt523drivers/scsi/scsi.hreturn SCpnt;
SCpnt530drivers/scsi/scsi.hif (SCpnt->host->block) {
SCpnt533drivers/scsi/scsi.hfor (next = SCpnt->host->block; next != SCpnt->host;
SCpnt540drivers/scsi/scsi.hwake_up(&SCpnt->device->device_wait);
SCpnt84drivers/scsi/scsi_debug.cif ((MINOR(SCpnt->request.rq_dev) & 0xf) != 0) start = starts[(MINOR(SCpnt->request.rq_dev) & 0xf) - 1];        \
SCpnt91drivers/scsi/scsi_debug.cif (bh->b_dev != SCpnt->request.rq_dev)  \
SCpnt96drivers/scsi/scsi_debug.cif (bufflen != 1024 && (!SCpnt->use_sg)) {printk("%x %d\n ",bufflen, SCpnt->use_sg); panic("Bad bufflen");};    \
SCpnt98drivers/scsi/scsi_debug.cif ((MINOR(SCpnt->request.rq_dev) & 0xf) > npart) panic ("Bad partition");    \
SCpnt99drivers/scsi/scsi_debug.cif ((MINOR(SCpnt->request.rq_dev) & 0xf) != 0) start = starts[(MINOR(SCpnt->request.rq_dev) & 0xf) - 1];        \
SCpnt100drivers/scsi/scsi_debug.cif (SCpnt->request.cmd != RW) panic ("Wrong  operation");       \
SCpnt101drivers/scsi/scsi_debug.cif (SCpnt->request.sector + start != block) panic("Wrong block.");  \
SCpnt102drivers/scsi/scsi_debug.cif (SCpnt->request.current_nr_sectors != 2 && (!SCpnt->use_sg)) panic ("Wrong # blocks");   \
SCpnt103drivers/scsi/scsi_debug.cif (SCpnt->request.bh){                         \
SCpnt104drivers/scsi/scsi_debug.cif (SCpnt->request.bh->b_size != 1024) panic ("Wrong bh size"); \
SCpnt105drivers/scsi/scsi_debug.cif ((SCpnt->request.bh->b_blocknr << 1) + start != block)           \
SCpnt106drivers/scsi/scsi_debug.c{   printk("Wrong bh block# %d %d ",SCpnt->request.bh->b_blocknr, block);  \
SCpnt109drivers/scsi/scsi_debug.cif (SCpnt->request.bh->b_dev != SCpnt->request.rq_dev) \
SCpnt128drivers/scsi/scsi_debug.cstatic void scsi_dump(Scsi_Cmnd * SCpnt, int flag){
SCpnt135drivers/scsi/scsi_debug.cprintk("use_sg: %d",SCpnt->use_sg);
SCpnt136drivers/scsi/scsi_debug.cif (SCpnt->use_sg){
SCpnt137drivers/scsi/scsi_debug.csgpnt = (struct scatterlist *) SCpnt->buffer;
SCpnt138drivers/scsi/scsi_debug.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt144drivers/scsi/scsi_debug.cprintk("nosg: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
SCpnt145drivers/scsi/scsi_debug.cSCpnt->bufflen);
SCpnt146drivers/scsi/scsi_debug.clpnt = (int *) SCpnt->request.buffer;
SCpnt149drivers/scsi/scsi_debug.clpnt = (unsigned int *) SCpnt;
SCpnt173drivers/scsi/scsi_debug.cint scsi_debug_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt175drivers/scsi/scsi_debug.cunchar *cmd = (unchar *) SCpnt->cmnd;
SCpnt183drivers/scsi/scsi_debug.cint target = SCpnt->target;
SCpnt184drivers/scsi/scsi_debug.cint bufflen = SCpnt->request_bufflen;
SCpnt190drivers/scsi/scsi_debug.cDEB(if (target > 1) { SCpnt->result = DID_TIME_OUT << 16;done(SCpnt);return 0;});
SCpnt192drivers/scsi/scsi_debug.cbuff = (unsigned char *) SCpnt->request_buffer;
SCpnt194drivers/scsi/scsi_debug.cif(target>=1 || SCpnt->lun != 0) {
SCpnt195drivers/scsi/scsi_debug.cSCpnt->result =  DID_NO_CONNECT << 16;
SCpnt196drivers/scsi/scsi_debug.cdone(SCpnt);
SCpnt203drivers/scsi/scsi_debug.cmemset(SCpnt->sense_buffer, 0, sizeof(SCpnt->sense_buffer));
SCpnt204drivers/scsi/scsi_debug.cSCpnt->sense_buffer[0] = 0x70;
SCpnt205drivers/scsi/scsi_debug.cSCpnt->sense_buffer[2] = UNIT_ATTENTION;
SCpnt206drivers/scsi/scsi_debug.cSCpnt->result = (CHECK_CONDITION << 1);
SCpnt207drivers/scsi/scsi_debug.cdone(SCpnt);         
SCpnt215drivers/scsi/scsi_debug.cprintk("scsi_debug: Requesting sense buffer (%x %x %x %d):", SCpnt, buff, done, bufflen);
SCpnt223drivers/scsi/scsi_debug.cSCpnt->result = 0;
SCpnt224drivers/scsi/scsi_debug.cdone(SCpnt); 
SCpnt251drivers/scsi/scsi_debug.cif(NR_REAL < 0) NR_REAL = (MINOR(SCpnt->request.rq_dev) >> 4) & 0x0f;
SCpnt276drivers/scsi/scsi_debug.cusec = (SCpnt->request.nr_sectors << 9) * 1.0e6 / SCSI_DATARATE;
SCpnt283drivers/scsi/scsi_debug.cprintk("(r%d)",SCpnt->request.nr_sectors);
SCpnt286drivers/scsi/scsi_debug.cif(SCpnt->use_sg){
SCpnt291drivers/scsi/scsi_debug.cbh = SCpnt->request.bh;
SCpnt318drivers/scsi/scsi_debug.cif (SCpnt->use_sg) printk("Block %x (%d %d)\n",block, SCpnt->request.nr_sectors,
SCpnt319drivers/scsi/scsi_debug.cSCpnt->request.current_nr_sectors);
SCpnt348drivers/scsi/scsi_debug.cmemcpy(buff+64, SCpnt, sizeof(Scsi_Cmnd));
SCpnt351drivers/scsi/scsi_debug.cif(SCpnt->use_sg){
SCpnt366drivers/scsi/scsi_debug.cSCpnt->result = 0;
SCpnt367drivers/scsi/scsi_debug.c(done)(SCpnt);
SCpnt370drivers/scsi/scsi_debug.cif (SCpnt->use_sg && !scsi_debug_errsts)
SCpnt371drivers/scsi/scsi_debug.cif(bh) scsi_dump(SCpnt, 0);
SCpnt384drivers/scsi/scsi_debug.cif (SCpnt->use_sg){
SCpnt385drivers/scsi/scsi_debug.cif ((bufflen >> 9) != SCpnt->request.nr_sectors)
SCpnt393drivers/scsi/scsi_debug.cscsi_dump(SCpnt,1);
SCpnt401drivers/scsi/scsi_debug.cSCpnt->result =  DID_NO_CONNECT << 16;
SCpnt402drivers/scsi/scsi_debug.cdone(SCpnt);
SCpnt415drivers/scsi/scsi_debug.cSCint[i] = SCpnt;
SCpnt430drivers/scsi/scsi_debug.cSCpnt->result = scsi_debug_errsts;
SCpnt443drivers/scsi/scsi_debug.cSCpnt->result = scsi_debug_errsts;
SCpnt456drivers/scsi/scsi_debug.cstatic void internal_done(Scsi_Cmnd * SCpnt)
SCpnt458drivers/scsi/scsi_debug.cinternal_done_errcode = SCpnt->result;
SCpnt462drivers/scsi/scsi_debug.cint scsi_debug_command(Scsi_Cmnd * SCpnt)
SCpnt465drivers/scsi/scsi_debug.cscsi_debug_queuecommand(SCpnt, internal_done);
SCpnt563drivers/scsi/scsi_debug.cint scsi_debug_abort(Scsi_Cmnd * SCpnt)
SCpnt571drivers/scsi/scsi_debug.cSCpnt->result = SCpnt->abort_reason << 16;
SCpnt573drivers/scsi/scsi_debug.cif(SCpnt == SCint[j]) {
SCpnt575drivers/scsi/scsi_debug.cmy_done(SCpnt);
SCpnt597drivers/scsi/scsi_debug.cint scsi_debug_reset(Scsi_Cmnd * SCpnt)
SCpnt603drivers/scsi/scsi_debug.cprintk("Bus unlocked by reset(%d)\n", SCpnt->host->suggest_bus_reset);
SCpnt92drivers/scsi/scsi_ioctl.cstatic void scsi_ioctl_done (Scsi_Cmnd * SCpnt)
SCpnt96drivers/scsi/scsi_ioctl.creq = &SCpnt->request;
SCpnt107drivers/scsi/scsi_ioctl.cScsi_Cmnd * SCpnt;
SCpnt109drivers/scsi/scsi_ioctl.cSCpnt = allocate_device(NULL, dev, 1);
SCpnt112drivers/scsi/scsi_ioctl.cSCpnt->request.sem = &sem;
SCpnt113drivers/scsi/scsi_ioctl.cscsi_do_cmd(SCpnt,  cmd, NULL,  0,
SCpnt119drivers/scsi/scsi_ioctl.cif(driver_byte(SCpnt->result) != 0)
SCpnt120drivers/scsi/scsi_ioctl.cswitch(SCpnt->sense_buffer[2] & 0xf) {
SCpnt133drivers/scsi/scsi_ioctl.cSCpnt->result = 0; /* This is no longer considered an error */
SCpnt142drivers/scsi/scsi_ioctl.cSCpnt->result);
SCpnt144drivers/scsi/scsi_ioctl.csense_class(SCpnt->sense_buffer[0]),
SCpnt145drivers/scsi/scsi_ioctl.csense_error(SCpnt->sense_buffer[0]),
SCpnt146drivers/scsi/scsi_ioctl.cSCpnt->sense_buffer[2] & 0xf);
SCpnt150drivers/scsi/scsi_ioctl.cresult = SCpnt->result;
SCpnt151drivers/scsi/scsi_ioctl.cSCpnt->request.rq_status = RQ_INACTIVE;
SCpnt153drivers/scsi/scsi_ioctl.cif(SCpnt->device->scsi_request_fn)
SCpnt154drivers/scsi/scsi_ioctl.c(*SCpnt->device->scsi_request_fn)();
SCpnt156drivers/scsi/scsi_ioctl.cwake_up(&SCpnt->device->device_wait);
SCpnt170drivers/scsi/scsi_ioctl.cScsi_Cmnd * SCpnt;
SCpnt244drivers/scsi/scsi_ioctl.cSCpnt = allocate_device(NULL, dev, 1);
SCpnt248drivers/scsi/scsi_ioctl.cSCpnt->request.sem = &sem;
SCpnt249drivers/scsi/scsi_ioctl.cscsi_do_cmd(SCpnt,  cmd,  buf, needed,  scsi_ioctl_done,  MAX_TIMEOUT, 
SCpnt257drivers/scsi/scsi_ioctl.cif(SCpnt->result) {
SCpnt260drivers/scsi/scsi_ioctl.csizeof(SCpnt->sense_buffer));
SCpnt263drivers/scsi/scsi_ioctl.cSCpnt->sense_buffer, 
SCpnt264drivers/scsi/scsi_ioctl.csizeof(SCpnt->sense_buffer));
SCpnt270drivers/scsi/scsi_ioctl.cresult = SCpnt->result;
SCpnt272drivers/scsi/scsi_ioctl.cSCpnt->request.rq_status = RQ_INACTIVE;
SCpnt276drivers/scsi/scsi_ioctl.cif(SCpnt->device->scsi_request_fn)
SCpnt277drivers/scsi/scsi_ioctl.c(*SCpnt->device->scsi_request_fn)();
SCpnt279drivers/scsi/scsi_ioctl.cwake_up(&SCpnt->device->device_wait);
SCpnt38drivers/scsi/scsi_syms.cextern void print_sense(const char * devclass, Scsi_Cmnd * SCpnt);
SCpnt79drivers/scsi/sd.cstatic void requeue_sd_request (Scsi_Cmnd * SCpnt);
SCpnt216drivers/scsi/sd.cstatic void rw_intr (Scsi_Cmnd *SCpnt)
SCpnt218drivers/scsi/sd.cint result = SCpnt->result;
SCpnt219drivers/scsi/sd.cint this_count = SCpnt->bufflen >> 9;
SCpnt222drivers/scsi/sd.cprintk("sd%c : rw_intr(%d, %d)\n", 'a' + MINOR(SCpnt->request.rq_dev), 
SCpnt223drivers/scsi/sd.cSCpnt->host->host_no, result);
SCpnt235drivers/scsi/sd.cprintk("sd%c : %d sectors remain.\n", 'a' + MINOR(SCpnt->request.rq_dev),
SCpnt236drivers/scsi/sd.cSCpnt->request.nr_sectors);
SCpnt237drivers/scsi/sd.cprintk("use_sg is %d\n ",SCpnt->use_sg);
SCpnt239drivers/scsi/sd.cif (SCpnt->use_sg) {
SCpnt242drivers/scsi/sd.csgpnt = (struct scatterlist *) SCpnt->buffer;
SCpnt243drivers/scsi/sd.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt249drivers/scsi/sd.cif (SCpnt->request.cmd == READ)
SCpnt257drivers/scsi/sd.cscsi_free(SCpnt->buffer, SCpnt->sglist_len);  
SCpnt259drivers/scsi/sd.cif (SCpnt->buffer != SCpnt->request.buffer) {
SCpnt261drivers/scsi/sd.cprintk("nosg: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
SCpnt262drivers/scsi/sd.cSCpnt->bufflen);
SCpnt264drivers/scsi/sd.cif (SCpnt->request.cmd == READ)
SCpnt265drivers/scsi/sd.cmemcpy(SCpnt->request.buffer, SCpnt->buffer,
SCpnt266drivers/scsi/sd.cSCpnt->bufflen);
SCpnt267drivers/scsi/sd.cscsi_free(SCpnt->buffer, SCpnt->bufflen);
SCpnt275drivers/scsi/sd.cif (SCpnt->request.nr_sectors > this_count)
SCpnt277drivers/scsi/sd.cSCpnt->request.errors = 0;
SCpnt279drivers/scsi/sd.cif (!SCpnt->request.bh)
SCpnt283drivers/scsi/sd.c'a' + MINOR(SCpnt->request.rq_dev));
SCpnt290drivers/scsi/sd.cSCpnt->request.sector, this_count);
SCpnt293drivers/scsi/sd.cSCpnt = end_scsi_request(SCpnt, 1, this_count);
SCpnt294drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt299drivers/scsi/sd.cif (SCpnt->use_sg) {
SCpnt302drivers/scsi/sd.csgpnt = (struct scatterlist *) SCpnt->buffer;
SCpnt303drivers/scsi/sd.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt305drivers/scsi/sd.cprintk("err: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
SCpnt306drivers/scsi/sd.cSCpnt->bufflen);
SCpnt312drivers/scsi/sd.cscsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
SCpnt315drivers/scsi/sd.cprintk("nosgerr: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
SCpnt316drivers/scsi/sd.cSCpnt->bufflen);
SCpnt318drivers/scsi/sd.cif (SCpnt->buffer != SCpnt->request.buffer)
SCpnt319drivers/scsi/sd.cscsi_free(SCpnt->buffer, SCpnt->bufflen);
SCpnt335drivers/scsi/sd.cif rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].remap
SCpnt343drivers/scsi/sd.cif ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
SCpnt344drivers/scsi/sd.cif ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
SCpnt345drivers/scsi/sd.cif(rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->removable) {
SCpnt349drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->changed = 1;
SCpnt350drivers/scsi/sd.cSCpnt = end_scsi_request(SCpnt, 0, this_count);
SCpnt351drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt361drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt375drivers/scsi/sd.cif (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
SCpnt376drivers/scsi/sd.cif (rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].ten) {
SCpnt377drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].ten = 0;
SCpnt378drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt387drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->host->host_no,
SCpnt388drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->channel,
SCpnt389drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->id,
SCpnt390drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->lun, result);
SCpnt393drivers/scsi/sd.cprint_sense("sd", SCpnt);
SCpnt394drivers/scsi/sd.cSCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
SCpnt395drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt408drivers/scsi/sd.cScsi_Cmnd * SCpnt = NULL;
SCpnt459drivers/scsi/sd.cSCpnt = allocate_device(&CURRENT,
SCpnt461drivers/scsi/sd.celse SCpnt = NULL;
SCpnt479drivers/scsi/sd.cif (!SCpnt && sd_template.nr_dev > 1){
SCpnt485drivers/scsi/sd.cSCpnt = request_queueable(req, rscsi_disks[DEVICE_NR(req->rq_dev)].device);
SCpnt486drivers/scsi/sd.cif(SCpnt) break;
SCpnt490drivers/scsi/sd.cif (SCpnt && req->rq_status == RQ_INACTIVE) {
SCpnt499drivers/scsi/sd.cif (!SCpnt) return; /* Could not find anything to do */
SCpnt502drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt506drivers/scsi/sd.cstatic void requeue_sd_request (Scsi_Cmnd * SCpnt)
SCpnt517drivers/scsi/sd.cif(!SCpnt || SCpnt->request.rq_status == RQ_INACTIVE) {
SCpnt522drivers/scsi/sd.cdevm =  MINOR(SCpnt->request.rq_dev);
SCpnt523drivers/scsi/sd.cdev = DEVICE_NR(SCpnt->request.rq_dev);
SCpnt525drivers/scsi/sd.cblock = SCpnt->request.sector;
SCpnt534drivers/scsi/sd.cblock + SCpnt->request.nr_sectors > sd[devm].nr_sects)
SCpnt536drivers/scsi/sd.cSCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt549drivers/scsi/sd.cSCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt570drivers/scsi/sd.cif((block & 1) || (SCpnt->request.nr_sectors & 1)) {
SCpnt572drivers/scsi/sd.cSCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt576drivers/scsi/sd.cswitch (SCpnt->request.cmd)
SCpnt581drivers/scsi/sd.cSCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt590drivers/scsi/sd.cpanic ("Unknown sd command %d\n", SCpnt->request.cmd);
SCpnt593drivers/scsi/sd.cSCpnt->this_count = 0;
SCpnt598drivers/scsi/sd.ccontiguous = (!CLUSTERABLE_DEVICE(SCpnt) ? 0 :1);
SCpnt600drivers/scsi/sd.cbounce_size = (SCpnt->request.nr_sectors << 9);
SCpnt606drivers/scsi/sd.cif (contiguous && SCpnt->request.bh &&
SCpnt607drivers/scsi/sd.c((long) SCpnt->request.bh->b_data) 
SCpnt608drivers/scsi/sd.c+ (SCpnt->request.nr_sectors << 9) - 1 > ISA_DMA_THRESHOLD 
SCpnt609drivers/scsi/sd.c&& SCpnt->host->unchecked_isa_dma) {
SCpnt610drivers/scsi/sd.cif(((long) SCpnt->request.bh->b_data) > ISA_DMA_THRESHOLD)
SCpnt615drivers/scsi/sd.cif(contiguous && SCpnt->request.bh && SCpnt->request.bh->b_reqnext)
SCpnt616drivers/scsi/sd.cfor(bh = SCpnt->request.bh, bhp = bh->b_reqnext; bhp; bh = bhp, 
SCpnt624drivers/scsi/sd.cif (!SCpnt->request.bh || contiguous) {
SCpnt627drivers/scsi/sd.cthis_count = SCpnt->request.nr_sectors;
SCpnt628drivers/scsi/sd.cbuff = SCpnt->request.buffer;
SCpnt629drivers/scsi/sd.cSCpnt->use_sg = 0;
SCpnt631drivers/scsi/sd.c} else if (SCpnt->host->sg_tablesize == 0 ||
SCpnt641drivers/scsi/sd.cif (SCpnt->host->sg_tablesize != 0 &&
SCpnt646drivers/scsi/sd.cthis_count = SCpnt->request.current_nr_sectors;
SCpnt647drivers/scsi/sd.cbuff = SCpnt->request.buffer;
SCpnt648drivers/scsi/sd.cSCpnt->use_sg = 0;
SCpnt657drivers/scsi/sd.cbh = SCpnt->request.bh;
SCpnt665drivers/scsi/sd.c!CLUSTERABLE_DEVICE(SCpnt) ||
SCpnt666drivers/scsi/sd.c(SCpnt->host->unchecked_isa_dma &&
SCpnt668drivers/scsi/sd.cif (count < SCpnt->host->sg_tablesize) count++;
SCpnt676drivers/scsi/sd.cif(SCpnt->host->unchecked_isa_dma &&
SCpnt677drivers/scsi/sd.c((unsigned int) SCpnt->request.bh->b_data-1) == ISA_DMA_THRESHOLD) count--;
SCpnt679drivers/scsi/sd.cSCpnt->use_sg = count;  /* Number of chains */
SCpnt681drivers/scsi/sd.cwhile( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
SCpnt683drivers/scsi/sd.cSCpnt->sglist_len = count;
SCpnt685drivers/scsi/sd.cif(SCpnt->host->sg_tablesize < max_sg) 
SCpnt686drivers/scsi/sd.cmax_sg = SCpnt->host->sg_tablesize;
SCpnt690drivers/scsi/sd.cSCpnt->use_sg = 0;    /* No memory left - bail out */
SCpnt691drivers/scsi/sd.cthis_count = SCpnt->request.current_nr_sectors;
SCpnt692drivers/scsi/sd.cbuff = SCpnt->request.buffer;
SCpnt699drivers/scsi/sd.cfor(count = 0, bh = SCpnt->request.bh, bhp = bh->b_reqnext;
SCpnt700drivers/scsi/sd.ccount < SCpnt->use_sg && bh; 
SCpnt710drivers/scsi/sd.cISA_DMA_THRESHOLD && (SCpnt->host->unchecked_isa_dma) &&
SCpnt737drivers/scsi/sd.cthis_count = SCpnt->request.current_nr_sectors;
SCpnt738drivers/scsi/sd.cbuff = SCpnt->request.buffer;
SCpnt739drivers/scsi/sd.cSCpnt->use_sg = 0;
SCpnt740drivers/scsi/sd.cscsi_free(sgpnt, SCpnt->sglist_len);
SCpnt742drivers/scsi/sd.cSCpnt->use_sg = count;
SCpnt754drivers/scsi/sd.c&& CLUSTERABLE_DEVICE(SCpnt)) {
SCpnt759drivers/scsi/sd.c(SCpnt->host->unchecked_isa_dma) &&
SCpnt768drivers/scsi/sd.cmax_sg = SCpnt->use_sg;
SCpnt781drivers/scsi/sd.cif (SCpnt->use_sg < max_sg) SCpnt->use_sg++;
SCpnt788drivers/scsi/sd.cif(count < SCpnt->use_sg || SCpnt->use_sg 
SCpnt789drivers/scsi/sd.c> SCpnt->host->sg_tablesize){
SCpnt790drivers/scsi/sd.cbh = SCpnt->request.bh;
SCpnt792drivers/scsi/sd.cSCpnt->use_sg, count, dma_free_sectors);
SCpnt799drivers/scsi/sd.cif(SCpnt->use_sg < 16)
SCpnt800drivers/scsi/sd.cfor(count=0; count<SCpnt->use_sg; count++)
SCpnt808drivers/scsi/sd.cif (SCpnt->request.cmd == WRITE)
SCpnt809drivers/scsi/sd.cfor(count=0; count<SCpnt->use_sg; count++)
SCpnt818drivers/scsi/sd.cif(SCpnt->use_sg == 0){
SCpnt820drivers/scsi/sd.c(SCpnt->host->unchecked_isa_dma)) {
SCpnt826drivers/scsi/sd.cthis_count = SCpnt->request.current_nr_sectors;
SCpnt830drivers/scsi/sd.cif (SCpnt->request.cmd == WRITE)
SCpnt831drivers/scsi/sd.cmemcpy(buff, (char *)SCpnt->request.buffer, this_count << 9);
SCpnt837drivers/scsi/sd.c(SCpnt->request.cmd == WRITE) ? "writing" : "reading",
SCpnt838drivers/scsi/sd.cthis_count, SCpnt->request.nr_sectors);
SCpnt841drivers/scsi/sd.ccmd[1] = (SCpnt->lun << 5) & 0xe0;
SCpnt887drivers/scsi/sd.cSCpnt->transfersize = rscsi_disks[dev].sector_size;
SCpnt888drivers/scsi/sd.cSCpnt->underflow = this_count << 9; 
SCpnt889drivers/scsi/sd.cscsi_do_cmd (SCpnt, (void *) cmd, buff, 
SCpnt892drivers/scsi/sd.c(SCpnt->device->type == TYPE_DISK ? 
SCpnt940drivers/scsi/sd.cstatic void sd_init_done (Scsi_Cmnd * SCpnt)
SCpnt944drivers/scsi/sd.creq = &SCpnt->request;
SCpnt958drivers/scsi/sd.cScsi_Cmnd * SCpnt;
SCpnt965drivers/scsi/sd.cSCpnt = allocate_device(NULL, rscsi_disks[i].device, 1);
SCpnt979drivers/scsi/sd.cSCpnt->cmd_len = 0;
SCpnt980drivers/scsi/sd.cSCpnt->sense_buffer[0] = 0;
SCpnt981drivers/scsi/sd.cSCpnt->sense_buffer[2] = 0;
SCpnt986drivers/scsi/sd.cSCpnt->request.rq_status = RQ_SCSI_BUSY;
SCpnt987drivers/scsi/sd.cSCpnt->request.sem = &sem;
SCpnt988drivers/scsi/sd.cscsi_do_cmd (SCpnt,
SCpnt995drivers/scsi/sd.cthe_result = SCpnt->result;
SCpnt998drivers/scsi/sd.c|| SCpnt->sense_buffer[2] != UNIT_ATTENTION)
SCpnt1005drivers/scsi/sd.cSCpnt->sense_buffer[2] == NOT_READY) {
SCpnt1014drivers/scsi/sd.cSCpnt->cmd_len = 0;
SCpnt1015drivers/scsi/sd.cSCpnt->sense_buffer[0] = 0;
SCpnt1016drivers/scsi/sd.cSCpnt->sense_buffer[2] = 0;
SCpnt1021drivers/scsi/sd.cSCpnt->request.rq_status = RQ_SCSI_BUSY; 
SCpnt1022drivers/scsi/sd.cSCpnt->request.sem = &sem;
SCpnt1023drivers/scsi/sd.cscsi_do_cmd (SCpnt,
SCpnt1053drivers/scsi/sd.cSCpnt->cmd_len = 0;
SCpnt1054drivers/scsi/sd.cSCpnt->sense_buffer[0] = 0;
SCpnt1055drivers/scsi/sd.cSCpnt->sense_buffer[2] = 0;
SCpnt1060drivers/scsi/sd.cSCpnt->request.rq_status = RQ_SCSI_BUSY;
SCpnt1061drivers/scsi/sd.cSCpnt->request.sem = &sem;
SCpnt1062drivers/scsi/sd.cscsi_do_cmd (SCpnt,
SCpnt1069drivers/scsi/sd.cthe_result = SCpnt->result;
SCpnt1074drivers/scsi/sd.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1076drivers/scsi/sd.cwake_up(&SCpnt->device->device_wait); 
SCpnt1106drivers/scsi/sd.c'a' + i, SCpnt->sense_buffer[2] & 0xf);
SCpnt1118drivers/scsi/sd.cSCpnt->sense_buffer[2] == NOT_READY)
SCpnt1207drivers/scsi/sd.cSCpnt->cmd_len = 0;
SCpnt1208drivers/scsi/sd.cSCpnt->sense_buffer[0] = 0;
SCpnt1209drivers/scsi/sd.cSCpnt->sense_buffer[2] = 0;
SCpnt1214drivers/scsi/sd.cSCpnt->request.rq_status = RQ_SCSI_BUSY;  /* Mark as really busy again */
SCpnt1215drivers/scsi/sd.cSCpnt->request.sem = &sem;
SCpnt1216drivers/scsi/sd.cscsi_do_cmd (SCpnt,
SCpnt1223drivers/scsi/sd.cthe_result = SCpnt->result;
SCpnt1224drivers/scsi/sd.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1225drivers/scsi/sd.cwake_up(&SCpnt->device->device_wait); 
SCpnt552drivers/scsi/seagate.cint seagate_st0x_queue_command (Scsi_Cmnd * SCpnt,  void (*done)(Scsi_Cmnd *))
SCpnt558drivers/scsi/seagate.ccurrent_target = SCpnt->target;
SCpnt559drivers/scsi/seagate.ccurrent_lun = SCpnt->lun;
SCpnt560drivers/scsi/seagate.c(const void *) current_cmnd = SCpnt->cmnd;
SCpnt561drivers/scsi/seagate.ccurrent_data = (unsigned char *) SCpnt->request_buffer;
SCpnt562drivers/scsi/seagate.ccurrent_bufflen = SCpnt->request_bufflen;
SCpnt563drivers/scsi/seagate.cSCint = SCpnt;
SCpnt574drivers/scsi/seagate.ccurrent_cmnd[SCpnt->cmd_len] |= 0x01;
SCpnt613drivers/scsi/seagate.cint seagate_st0x_command (Scsi_Cmnd * SCpnt) {
SCpnt614drivers/scsi/seagate.creturn internal_command (SCpnt->target, SCpnt->lun, SCpnt->cmnd, SCpnt->request_buffer,
SCpnt615drivers/scsi/seagate.cSCpnt->request_bufflen, 
SCpnt1589drivers/scsi/seagate.cint seagate_st0x_abort (Scsi_Cmnd * SCpnt)
SCpnt1600drivers/scsi/seagate.cint seagate_st0x_reset (Scsi_Cmnd * SCpnt)
SCpnt263drivers/scsi/sg.cstatic void sg_command_done(Scsi_Cmnd * SCpnt)
SCpnt265drivers/scsi/sg.cint dev = MINOR(SCpnt->request.rq_dev);
SCpnt270drivers/scsi/sg.cSCpnt->request.rq_status = RQ_INACTIVE;
SCpnt278drivers/scsi/sg.cmemcpy(device->header.sense_buffer, SCpnt->sense_buffer, sizeof(SCpnt->sense_buffer));
SCpnt279drivers/scsi/sg.cif (SCpnt->sense_buffer[0])
SCpnt284drivers/scsi/sg.cdevice->header.result=SCpnt->result;
SCpnt291drivers/scsi/sg.cSCpnt->request.rq_status = RQ_INACTIVE;
SCpnt304drivers/scsi/sg.cScsi_Cmnd    * SCpnt;
SCpnt404drivers/scsi/sg.cif (!(SCpnt=allocate_device(NULL,device->device, !(filp->f_flags & O_NONBLOCK))))
SCpnt416drivers/scsi/sg.cSCpnt->request.rq_dev = devt;
SCpnt417drivers/scsi/sg.cSCpnt->request.rq_status = RQ_ACTIVE;
SCpnt418drivers/scsi/sg.cSCpnt->sense_buffer[0]=0;
SCpnt419drivers/scsi/sg.cSCpnt->cmd_len = size;
SCpnt448drivers/scsi/sg.cscsi_do_cmd (SCpnt,(void *) cmnd,
SCpnt66drivers/scsi/sr.cvoid requeue_sr_request (Scsi_Cmnd * SCpnt);
SCpnt150drivers/scsi/sr.cstatic void rw_intr (Scsi_Cmnd * SCpnt)
SCpnt152drivers/scsi/sr.cint result = SCpnt->result;
SCpnt153drivers/scsi/sr.cint this_count = SCpnt->this_count;
SCpnt156drivers/scsi/sr.cprintk("sr.c done: %x %x\n",result, SCpnt->request.bh->b_data);
SCpnt160drivers/scsi/sr.cif (SCpnt->use_sg == 0) {
SCpnt161drivers/scsi/sr.cif (SCpnt->buffer != SCpnt->request.buffer)
SCpnt164drivers/scsi/sr.coffset = (SCpnt->request.sector % 4) << 9;
SCpnt165drivers/scsi/sr.cmemcpy((char *)SCpnt->request.buffer, 
SCpnt166drivers/scsi/sr.c(char *)SCpnt->buffer + offset, 
SCpnt173drivers/scsi/sr.cSCpnt->request.nr_sectors > this_count && 
SCpnt174drivers/scsi/sr.cSCpnt->request.bh &&
SCpnt175drivers/scsi/sr.cSCpnt->request.bh->b_reqnext &&
SCpnt176drivers/scsi/sr.cSCpnt->request.bh->b_reqnext->b_size == 1024) {
SCpnt177drivers/scsi/sr.cmemcpy((char *)SCpnt->request.bh->b_reqnext->b_data, 
SCpnt178drivers/scsi/sr.c(char *)SCpnt->buffer + 1024, 
SCpnt183drivers/scsi/sr.cscsi_free(SCpnt->buffer, 2048);
SCpnt188drivers/scsi/sr.csgpnt = (struct scatterlist *) SCpnt->buffer;
SCpnt189drivers/scsi/sr.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt197drivers/scsi/sr.cscsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
SCpnt198drivers/scsi/sr.cif(SCpnt->request.sector % 4) this_count -= 2;
SCpnt200drivers/scsi/sr.cif(this_count > SCpnt->request.nr_sectors)
SCpnt205drivers/scsi/sr.cprintk("(%x %x %x) ",SCpnt->request.bh, SCpnt->request.nr_sectors, 
SCpnt208drivers/scsi/sr.cif (SCpnt->request.nr_sectors > this_count)
SCpnt210drivers/scsi/sr.cSCpnt->request.errors = 0;
SCpnt211drivers/scsi/sr.cif (!SCpnt->request.bh)
SCpnt213drivers/scsi/sr.cSCpnt->request.sector, this_count);
SCpnt216drivers/scsi/sr.cSCpnt = end_scsi_request(SCpnt, 1, this_count);  /* All done */
SCpnt217drivers/scsi/sr.crequeue_sr_request(SCpnt);
SCpnt224drivers/scsi/sr.cif (SCpnt->use_sg) {
SCpnt227drivers/scsi/sr.csgpnt = (struct scatterlist *) SCpnt->buffer;
SCpnt228drivers/scsi/sr.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt233drivers/scsi/sr.cscsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
SCpnt235drivers/scsi/sr.cif (SCpnt->buffer != SCpnt->request.buffer)
SCpnt236drivers/scsi/sr.cscsi_free(SCpnt->buffer, SCpnt->bufflen);
SCpnt240drivers/scsi/sr.cif ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
SCpnt241drivers/scsi/sr.cif ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
SCpnt245drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->changed = 1;
SCpnt246drivers/scsi/sr.cSCpnt = end_scsi_request(SCpnt, 0, this_count);
SCpnt247drivers/scsi/sr.crequeue_sr_request(SCpnt);
SCpnt252drivers/scsi/sr.cif (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
SCpnt254drivers/scsi/sr.cprint_sense("sr", SCpnt);
SCpnt256drivers/scsi/sr.cprint_command(SCpnt->cmnd);
SCpnt257drivers/scsi/sr.cif (scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].ten) {
SCpnt258drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].ten = 0;
SCpnt259drivers/scsi/sr.crequeue_sr_request(SCpnt);
SCpnt263drivers/scsi/sr.cSCpnt = end_scsi_request(SCpnt, 0, this_count);
SCpnt264drivers/scsi/sr.crequeue_sr_request(SCpnt); /* Do next request */
SCpnt270drivers/scsi/sr.cif (SCpnt->sense_buffer[2] == NOT_READY) {
SCpnt272drivers/scsi/sr.cSCpnt = end_scsi_request(SCpnt, 0, this_count);
SCpnt273drivers/scsi/sr.crequeue_sr_request(SCpnt); /* Do next request */
SCpnt281drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->host->host_no, 
SCpnt282drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->id,
SCpnt283drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->lun,
SCpnt287drivers/scsi/sr.cprint_sense("sr", SCpnt);
SCpnt289drivers/scsi/sr.cSCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
SCpnt290drivers/scsi/sr.crequeue_sr_request(SCpnt);
SCpnt561drivers/scsi/sr.cScsi_Cmnd * SCpnt = NULL;
SCpnt600drivers/scsi/sr.cSCpnt = allocate_device(&CURRENT,
SCpnt602drivers/scsi/sr.celse SCpnt = NULL;
SCpnt612drivers/scsi/sr.cif (!SCpnt && sr_template.nr_dev > 1){
SCpnt619drivers/scsi/sr.cSCpnt = request_queueable(req,
SCpnt621drivers/scsi/sr.cif(SCpnt) break;
SCpnt625drivers/scsi/sr.cif (SCpnt && req->rq_status == RQ_INACTIVE) {
SCpnt634drivers/scsi/sr.cif (!SCpnt)
SCpnt640drivers/scsi/sr.crequeue_sr_request(SCpnt);
SCpnt644drivers/scsi/sr.cvoid requeue_sr_request (Scsi_Cmnd * SCpnt)
SCpnt653drivers/scsi/sr.cif(!SCpnt || SCpnt->request.rq_status == RQ_INACTIVE) {
SCpnt658drivers/scsi/sr.cdev =  MINOR(SCpnt->request.rq_dev);
SCpnt659drivers/scsi/sr.cblock = SCpnt->request.sector;  
SCpnt665drivers/scsi/sr.cSCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt672drivers/scsi/sr.cSCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt683drivers/scsi/sr.cSCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt688drivers/scsi/sr.cswitch (SCpnt->request.cmd)
SCpnt691drivers/scsi/sr.cSCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt698drivers/scsi/sr.cpanic ("Unknown sr command %d\n", SCpnt->request.cmd);
SCpnt701drivers/scsi/sr.ccmd[1] = (SCpnt->lun << 5) & 0xe0;
SCpnt720drivers/scsi/sr.cSCpnt->use_sg = 0;
SCpnt722drivers/scsi/sr.cif (SCpnt->host->sg_tablesize > 0 &&
SCpnt728drivers/scsi/sr.cbh = SCpnt->request.bh;
SCpnt734drivers/scsi/sr.cthis_count = SCpnt->request.sector % 4;
SCpnt736drivers/scsi/sr.cwhile(bh && count < SCpnt->host->sg_tablesize) {
SCpnt745drivers/scsi/sr.cif (count < SCpnt->host->sg_tablesize) {
SCpnt754drivers/scsi/sr.cSCpnt->use_sg = count;  /* Number of chains */
SCpnt756drivers/scsi/sr.cwhile( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
SCpnt758drivers/scsi/sr.cSCpnt->sglist_len = count;
SCpnt762drivers/scsi/sr.cSCpnt->use_sg = 0;  /* No memory left - bail out */
SCpnt766drivers/scsi/sr.cbh = SCpnt->request.bh;
SCpnt767drivers/scsi/sr.cif(SCpnt->request.sector % 4) {
SCpnt768drivers/scsi/sr.csgpnt[count].length = (SCpnt->request.sector % 4) << 9;
SCpnt775drivers/scsi/sr.cfor(bh = SCpnt->request.bh; count < SCpnt->use_sg; 
SCpnt786drivers/scsi/sr.cif (count+1 != SCpnt->use_sg) panic("Bad sr request list");
SCpnt790drivers/scsi/sr.cSCpnt->host->unchecked_isa_dma) {
SCpnt811drivers/scsi/sr.cSCpnt->use_sg = 0;
SCpnt812drivers/scsi/sr.cscsi_free(buffer, SCpnt->sglist_len);
SCpnt818drivers/scsi/sr.cprintk("SR: %d %d %d %d %d *** ",SCpnt->use_sg, SCpnt->request.sector,
SCpnt820drivers/scsi/sr.cSCpnt->request.current_nr_sectors,
SCpnt821drivers/scsi/sr.cSCpnt->request.nr_sectors);
SCpnt822drivers/scsi/sr.cfor(count=0; count<SCpnt->use_sg; count++)
SCpnt831drivers/scsi/sr.cif (SCpnt->use_sg == 0){
SCpnt833drivers/scsi/sr.cif (!SCpnt->request.bh)    
SCpnt834drivers/scsi/sr.cthis_count = SCpnt->request.nr_sectors;
SCpnt836drivers/scsi/sr.cthis_count = (SCpnt->request.bh->b_size >> 9);
SCpnt852drivers/scsi/sr.cbuffer = (unsigned char *) SCpnt->request.buffer;
SCpnt854drivers/scsi/sr.cSCpnt->host->unchecked_isa_dma)
SCpnt904drivers/scsi/sr.cprintk("Use sg: %d\n", SCpnt->use_sg);
SCpnt921drivers/scsi/sr.cSCpnt->transfersize = (scsi_CDs[dev].sector_size > 1024) ?
SCpnt924drivers/scsi/sr.cSCpnt->this_count = this_count;
SCpnt925drivers/scsi/sr.cscsi_do_cmd (SCpnt, (void *) cmd, buffer, 
SCpnt967drivers/scsi/sr.cstatic void sr_init_done (Scsi_Cmnd * SCpnt)
SCpnt971drivers/scsi/sr.creq = &SCpnt->request;
SCpnt983drivers/scsi/sr.cScsi_Cmnd * SCpnt;
SCpnt986drivers/scsi/sr.cSCpnt = allocate_device(NULL, scsi_CDs[i].device, 1);
SCpnt993drivers/scsi/sr.cSCpnt->request.rq_status = RQ_SCSI_BUSY;  /* Mark as really busy */
SCpnt994drivers/scsi/sr.cSCpnt->cmd_len = 0;
SCpnt1001drivers/scsi/sr.cSCpnt->request.sem = &sem;
SCpnt1002drivers/scsi/sr.cscsi_do_cmd (SCpnt,
SCpnt1009drivers/scsi/sr.cthe_result = SCpnt->result;
SCpnt1014drivers/scsi/sr.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1016drivers/scsi/sr.cwake_up(&SCpnt->device->device_wait); 
SCpnt25drivers/scsi/sr_ioctl.cstatic void sr_ioctl_done(Scsi_Cmnd * SCpnt)
SCpnt29drivers/scsi/sr_ioctl.creq = &SCpnt->request;
SCpnt43drivers/scsi/sr_ioctl.cScsi_Cmnd * SCpnt;
SCpnt46drivers/scsi/sr_ioctl.cSCpnt = allocate_device(NULL, scsi_CDs[target].device, 1);
SCpnt49drivers/scsi/sr_ioctl.cSCpnt->request.sem = &sem;
SCpnt50drivers/scsi/sr_ioctl.cscsi_do_cmd(SCpnt,
SCpnt56drivers/scsi/sr_ioctl.cresult = SCpnt->result;
SCpnt60drivers/scsi/sr_ioctl.cswitch(SCpnt->sense_buffer[2] & 0xf) {
SCpnt78drivers/scsi/sr_ioctl.csense_class(SCpnt->sense_buffer[0]), 
SCpnt79drivers/scsi/sr_ioctl.csense_error(SCpnt->sense_buffer[0]),
SCpnt80drivers/scsi/sr_ioctl.cSCpnt->sense_buffer[2] & 0xf);
SCpnt84drivers/scsi/sr_ioctl.cresult = SCpnt->result;
SCpnt85drivers/scsi/sr_ioctl.cSCpnt->request.rq_status = RQ_INACTIVE; /* Deallocate */
SCpnt86drivers/scsi/sr_ioctl.cwake_up(&SCpnt->device->device_wait);
SCpnt114drivers/scsi/st.cst_chk_result(Scsi_Cmnd * SCpnt)
SCpnt116drivers/scsi/st.cint dev = TAPE_NR(SCpnt->request.rq_dev);
SCpnt117drivers/scsi/st.cint result = SCpnt->result;
SCpnt118drivers/scsi/st.cunsigned char * sense = SCpnt->sense_buffer, scode;
SCpnt129drivers/scsi/st.cSCpnt->data_cmnd[0], SCpnt->data_cmnd[1], SCpnt->data_cmnd[2],
SCpnt130drivers/scsi/st.cSCpnt->data_cmnd[3], SCpnt->data_cmnd[4], SCpnt->data_cmnd[5],
SCpnt131drivers/scsi/st.cSCpnt->request_bufflen);
SCpnt133drivers/scsi/st.cprint_sense("st", SCpnt);
SCpnt146drivers/scsi/st.cSCpnt->data_cmnd[0] != MODE_SENSE &&
SCpnt147drivers/scsi/st.cSCpnt->data_cmnd[0] != TEST_UNIT_READY)) { /* Abnormal conditions for tape */
SCpnt151drivers/scsi/st.cprint_sense("st", SCpnt);
SCpnt161drivers/scsi/st.c&& SCpnt->data_cmnd[0] != WRITE_6
SCpnt162drivers/scsi/st.c&& SCpnt->data_cmnd[0] != WRITE_FILEMARKS
SCpnt169drivers/scsi/st.cif (SCpnt->data_cmnd[0] == READ_6)
SCpnt171drivers/scsi/st.celse if (SCpnt->data_cmnd[0] == WRITE_6)
SCpnt188drivers/scsi/st.cst_sleep_done (Scsi_Cmnd * SCpnt)
SCpnt194drivers/scsi/st.cif ((st_nbr = TAPE_NR(SCpnt->request.rq_dev)) < st_template.nr_dev) {
SCpnt197drivers/scsi/st.c(SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
SCpnt198drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x40)) {
SCpnt200drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x80) != 0)
SCpnt201drivers/scsi/st.cremainder = (SCpnt->sense_buffer[3] << 24) |
SCpnt202drivers/scsi/st.c(SCpnt->sense_buffer[4] << 16) |
SCpnt203drivers/scsi/st.c(SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
SCpnt206drivers/scsi/st.cif ((SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW ||
SCpnt208drivers/scsi/st.c(STp->buffer)->last_result = SCpnt->result; /* Error */
SCpnt213drivers/scsi/st.c(STp->buffer)->last_result = SCpnt->result;
SCpnt216drivers/scsi/st.c(STp->buffer)->last_result_fatal = st_chk_result(SCpnt);
SCpnt217drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;
SCpnt220drivers/scsi/st.cSCpnt->request.rq_status = RQ_SCSI_DONE;
SCpnt225drivers/scsi/st.cup(SCpnt->request.sem);
SCpnt236drivers/scsi/st.cst_do_scsi(Scsi_Cmnd *SCpnt, Scsi_Tape *STp, unsigned char *cmd, int bytes,
SCpnt239drivers/scsi/st.cif (SCpnt == NULL)
SCpnt240drivers/scsi/st.cif ((SCpnt = allocate_device(NULL, STp->device, 1)) == NULL) {
SCpnt245drivers/scsi/st.ccmd[1] |= (SCpnt->lun << 5) & 0xe0;
SCpnt247drivers/scsi/st.cSCpnt->request.sem = &(STp->sem);
SCpnt248drivers/scsi/st.cSCpnt->request.rq_status = RQ_SCSI_BUSY;
SCpnt249drivers/scsi/st.cSCpnt->request.rq_dev = STp->devt;
SCpnt251drivers/scsi/st.cscsi_do_cmd(SCpnt, (void *)cmd, (STp->buffer)->b_data, bytes,
SCpnt254drivers/scsi/st.cdown(SCpnt->request.sem);
SCpnt256drivers/scsi/st.c(STp->buffer)->last_result_fatal = st_chk_result(SCpnt);
SCpnt258drivers/scsi/st.creturn SCpnt;
SCpnt301drivers/scsi/st.cScsi_Cmnd *SCpnt;
SCpnt309drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_TIMEOUT, MAX_RETRIES);
SCpnt310drivers/scsi/st.cif (!SCpnt)
SCpnt313drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;
SCpnt332drivers/scsi/st.cScsi_Cmnd *SCpnt;
SCpnt371drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, transfer, ST_TIMEOUT, MAX_WRITE_RETRIES);
SCpnt372drivers/scsi/st.cif (!SCpnt)
SCpnt377drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
SCpnt378drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x40) &&
SCpnt379drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) != VOLUME_OVERFLOW) {
SCpnt394drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt464drivers/scsi/st.cScsi_Cmnd * SCpnt;
SCpnt530drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_LONG_TIMEOUT, MAX_READY_RETRIES);
SCpnt531drivers/scsi/st.cif (!SCpnt)
SCpnt534drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
SCpnt535drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) == UNIT_ATTENTION) { /* New media? */
SCpnt540drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, 0, ST_LONG_TIMEOUT, MAX_READY_RETRIES);
SCpnt549drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
SCpnt550drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) == NO_TAPE) {
SCpnt558drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt574drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, 6, ST_TIMEOUT, MAX_READY_RETRIES);
SCpnt576drivers/scsi/st.cif (!SCpnt->result && !SCpnt->sense_buffer[0]) {
SCpnt599drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, 12, ST_TIMEOUT, MAX_READY_RETRIES);
SCpnt644drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt727drivers/scsi/st.cScsi_Cmnd * SCpnt;
SCpnt754drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, 0, ST_TIMEOUT, MAX_WRITE_RETRIES);
SCpnt755drivers/scsi/st.cif (!SCpnt)
SCpnt758drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt813drivers/scsi/st.cScsi_Cmnd * SCpnt = NULL;
SCpnt965drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, transfer, ST_TIMEOUT, MAX_WRITE_RETRIES);
SCpnt966drivers/scsi/st.cif (!SCpnt)
SCpnt974drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
SCpnt975drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x40)) {
SCpnt976drivers/scsi/st.cif (STp->block_size != 0 && (SCpnt->sense_buffer[0] & 0x80) != 0)
SCpnt977drivers/scsi/st.ctransfer = (SCpnt->sense_buffer[3] << 24) |
SCpnt978drivers/scsi/st.c(SCpnt->sense_buffer[4] << 16) |
SCpnt979drivers/scsi/st.c(SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
SCpnt981drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW)
SCpnt1019drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1049drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;
SCpnt1057drivers/scsi/st.cif (!SCpnt) {
SCpnt1058drivers/scsi/st.cSCpnt = allocate_device(NULL, STp->device, 1);
SCpnt1059drivers/scsi/st.cif (!SCpnt)
SCpnt1078drivers/scsi/st.cSCpnt->request.sem = &(STp->sem);
SCpnt1079drivers/scsi/st.cSCpnt->request.rq_status = RQ_SCSI_BUSY;
SCpnt1080drivers/scsi/st.cSCpnt->request.rq_dev = STp->devt;
SCpnt1085drivers/scsi/st.cscsi_do_cmd (SCpnt,
SCpnt1090drivers/scsi/st.celse if (SCpnt != NULL)
SCpnt1091drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1105drivers/scsi/st.cScsi_Cmnd * SCpnt = NULL;
SCpnt1181drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, bytes, ST_TIMEOUT, MAX_RETRIES);
SCpnt1182drivers/scsi/st.cif (!SCpnt)
SCpnt1194drivers/scsi/st.cSCpnt->sense_buffer[0], SCpnt->sense_buffer[1],
SCpnt1195drivers/scsi/st.cSCpnt->sense_buffer[2], SCpnt->sense_buffer[3],
SCpnt1196drivers/scsi/st.cSCpnt->sense_buffer[4], SCpnt->sense_buffer[5],
SCpnt1197drivers/scsi/st.cSCpnt->sense_buffer[6], SCpnt->sense_buffer[7]);
SCpnt1199drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x70) == 0x70) { /* extended sense */
SCpnt1201drivers/scsi/st.cif ((SCpnt->sense_buffer[2] & 0xe0) != 0) { /* EOF, EOM, or ILI */
SCpnt1203drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x80) != 0)
SCpnt1204drivers/scsi/st.ctransfer = (SCpnt->sense_buffer[3] << 24) |
SCpnt1205drivers/scsi/st.c(SCpnt->sense_buffer[4] << 16) |
SCpnt1206drivers/scsi/st.c(SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
SCpnt1210drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) == MEDIUM_ERROR)
SCpnt1213drivers/scsi/st.cif (SCpnt->sense_buffer[2] & 0x20) {
SCpnt1221drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1225drivers/scsi/st.celse if (SCpnt->sense_buffer[2] & 0x40) {
SCpnt1238drivers/scsi/st.celse if (SCpnt->sense_buffer[2] & 0x80) {
SCpnt1258drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;
SCpnt1263drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) == BLANK_CHECK) {
SCpnt1279drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1314drivers/scsi/st.cif (SCpnt != NULL)
SCpnt1315drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1334drivers/scsi/st.cif (SCpnt != NULL)
SCpnt1335drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1505drivers/scsi/st.cScsi_Cmnd * SCpnt = NULL;
SCpnt1514drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, cmd[4], ST_TIMEOUT, 0);
SCpnt1515drivers/scsi/st.cdev = TAPE_NR(SCpnt->request.rq_dev);
SCpnt1522drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1537drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1555drivers/scsi/st.cSCpnt = st_do_scsi(SCpnt, STp, cmd, cmd[4], ST_TIMEOUT, 0);
SCpnt1562drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1572drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1587drivers/scsi/st.cScsi_Cmnd * SCpnt;
SCpnt1933drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, cmd, datalen, timeout, MAX_RETRIES);
SCpnt1934drivers/scsi/st.cif (!SCpnt)
SCpnt1939drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt1987drivers/scsi/st.cif (SCpnt->sense_buffer[2] & 0x40) {
SCpnt1995drivers/scsi/st.c(SCpnt->sense_buffer[3] << 24) +
SCpnt1996drivers/scsi/st.c(SCpnt->sense_buffer[4] << 16) +
SCpnt1997drivers/scsi/st.c(SCpnt->sense_buffer[5] << 8) +
SCpnt1998drivers/scsi/st.cSCpnt->sense_buffer[6] );
SCpnt2011drivers/scsi/st.cif (SCpnt->sense_buffer[2] & 0x80) { /* Hit filemark */
SCpnt2023drivers/scsi/st.cif (SCpnt->sense_buffer[2] & 0x80) { /* Hit filemark */
SCpnt2039drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) == BLANK_CHECK)
SCpnt2059drivers/scsi/st.cScsi_Cmnd *SCpnt;
SCpnt2251drivers/scsi/st.cSCpnt = st_do_scsi(NULL, STp, scmd, 20, ST_TIMEOUT, MAX_READY_RETRIES);
SCpnt2252drivers/scsi/st.cif (!SCpnt)
SCpnt2277drivers/scsi/st.cSCpnt->request.rq_status = RQ_INACTIVE;  /* Mark as not busy */
SCpnt51drivers/scsi/st.hScsi_Cmnd SCpnt;
SCpnt261drivers/scsi/u14-34f.cScsi_Cmnd *SCpnt;
SCpnt557drivers/scsi/u14-34f.cstatic inline void build_sg_list(struct mscp *cpp, Scsi_Cmnd *SCpnt) {
SCpnt561drivers/scsi/u14-34f.csgpnt = (struct scatterlist *) SCpnt->request_buffer;
SCpnt563drivers/scsi/u14-34f.cfor (k = 0; k < SCpnt->use_sg; k++) {
SCpnt569drivers/scsi/u14-34f.ccpp->use_sg = SCpnt->use_sg;
SCpnt574drivers/scsi/u14-34f.cint u14_34f_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) {
SCpnt587drivers/scsi/u14-34f.cj = ((struct hostdata *) SCpnt->host->hostdata)->board_number;
SCpnt589drivers/scsi/u14-34f.cif (!done) panic("%s: qcomm, pid %ld, null done.\n", BN(j), SCpnt->pid);
SCpnt610drivers/scsi/u14-34f.celse if (u14_34f_reset(SCpnt, SCSI_RESET_SUGGEST_BUS_RESET) 
SCpnt614drivers/scsi/u14-34f.cSCpnt->result = DID_BUS_BUSY << 16; 
SCpnt615drivers/scsi/u14-34f.cSCpnt->host_scribble = NULL;
SCpnt616drivers/scsi/u14-34f.cprintk("%s: qcomm, pid %ld, DID_BUS_BUSY, done.\n", BN(j), SCpnt->pid);
SCpnt618drivers/scsi/u14-34f.cdone(SCpnt);    
SCpnt626drivers/scsi/u14-34f.cSCpnt->scsi_done = done;
SCpnt628drivers/scsi/u14-34f.cSCpnt->host_scribble = (unsigned char *) &cpp->index;
SCpnt631drivers/scsi/u14-34f.cBN(j), i, SCpnt->target, SCpnt->pid);
SCpnt636drivers/scsi/u14-34f.cif (SCpnt->cmnd[0] == data_out_cmds[k]) {
SCpnt642drivers/scsi/u14-34f.ccpp->target = SCpnt->target;
SCpnt643drivers/scsi/u14-34f.ccpp->lun = SCpnt->lun;
SCpnt644drivers/scsi/u14-34f.ccpp->SCpnt = SCpnt;
SCpnt645drivers/scsi/u14-34f.ccpp->sense_addr = (unsigned int) SCpnt->sense_buffer;
SCpnt646drivers/scsi/u14-34f.ccpp->sense_len = sizeof SCpnt->sense_buffer;
SCpnt648drivers/scsi/u14-34f.cif (SCpnt->use_sg) {
SCpnt650drivers/scsi/u14-34f.cbuild_sg_list(cpp, SCpnt);
SCpnt653drivers/scsi/u14-34f.ccpp->data_address = (unsigned int)SCpnt->request_buffer;
SCpnt654drivers/scsi/u14-34f.ccpp->data_len = SCpnt->request_bufflen;
SCpnt657drivers/scsi/u14-34f.ccpp->scsi_cdbs_len = SCpnt->cmd_len;
SCpnt658drivers/scsi/u14-34f.cmemcpy(cpp->scsi_cdbs, SCpnt->cmnd, cpp->scsi_cdbs_len);
SCpnt661drivers/scsi/u14-34f.cSCpnt->result = DID_ERROR << 16;
SCpnt662drivers/scsi/u14-34f.cSCpnt->host_scribble = NULL;
SCpnt664drivers/scsi/u14-34f.cBN(j), SCpnt->target, SCpnt->pid);
SCpnt666drivers/scsi/u14-34f.cdone(SCpnt);
SCpnt717drivers/scsi/u14-34f.cif (SCarg != HD(j)->cp[i].SCpnt)
SCpnt719drivers/scsi/u14-34f.cBN(j), i, SCarg, HD(j)->cp[i].SCpnt);
SCpnt743drivers/scsi/u14-34f.cScsi_Cmnd *SCpnt;
SCpnt780drivers/scsi/u14-34f.cSCpnt = HD(j)->cp[i].SCpnt;
SCpnt783drivers/scsi/u14-34f.cBN(j), i, SCpnt->pid);
SCpnt785drivers/scsi/u14-34f.cif (SCpnt == NULL)
SCpnt788drivers/scsi/u14-34f.cif (SCpnt->host_scribble == NULL)
SCpnt791drivers/scsi/u14-34f.cif (*(unsigned int *)SCpnt->host_scribble != i) 
SCpnt794drivers/scsi/u14-34f.cif (SCpnt->scsi_done == NULL) 
SCpnt797drivers/scsi/u14-34f.cif (SCpnt == SCarg) arg_done = TRUE;
SCpnt825drivers/scsi/u14-34f.cSCpnt = HD(j)->cp[i].SCpnt;
SCpnt826drivers/scsi/u14-34f.cSCpnt->result = DID_RESET << 16;
SCpnt827drivers/scsi/u14-34f.cSCpnt->host_scribble = NULL;
SCpnt833drivers/scsi/u14-34f.cBN(j), i, SCpnt->pid);
SCpnt835drivers/scsi/u14-34f.cSCpnt->scsi_done(SCpnt);
SCpnt864drivers/scsi/u14-34f.cScsi_Cmnd *SCpnt;
SCpnt926drivers/scsi/u14-34f.cSCpnt = spp->SCpnt;
SCpnt928drivers/scsi/u14-34f.cif (SCpnt == NULL) 
SCpnt931drivers/scsi/u14-34f.cif (SCpnt->host_scribble == NULL) 
SCpnt933drivers/scsi/u14-34f.cBN(j), i, SCpnt->pid, SCpnt);
SCpnt935drivers/scsi/u14-34f.cif (*(unsigned int *)SCpnt->host_scribble != i) 
SCpnt937drivers/scsi/u14-34f.c" irq %d.\n", BN(j), i, SCpnt->pid, 
SCpnt938drivers/scsi/u14-34f.c*(unsigned int *)SCpnt->host_scribble, irq);
SCpnt946drivers/scsi/u14-34f.cif (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE) 
SCpnt951drivers/scsi/u14-34f.c&& SCpnt->device->type == TYPE_DISK
SCpnt952drivers/scsi/u14-34f.c&& HD(j)->target_reset[SCpnt->target])
SCpnt957drivers/scsi/u14-34f.c&& SCpnt->device->type == TYPE_DISK
SCpnt958drivers/scsi/u14-34f.c&& (SCpnt->sense_buffer[2] & 0xf) == RECOVERED_ERROR)
SCpnt965drivers/scsi/u14-34f.cHD(j)->target_reset[SCpnt->target] = FALSE;
SCpnt967drivers/scsi/u14-34f.cif (spp->target_status && SCpnt->device->type == TYPE_DISK)
SCpnt970drivers/scsi/u14-34f.cSCpnt->target, SCpnt->lun, SCpnt->pid,
SCpnt971drivers/scsi/u14-34f.cspp->target_status, SCpnt->sense_buffer[2]);
SCpnt973drivers/scsi/u14-34f.cHD(j)->target_time_out[SCpnt->target] = 0;
SCpnt978drivers/scsi/u14-34f.cif (HD(j)->target_time_out[SCpnt->target] > 1)
SCpnt982drivers/scsi/u14-34f.cHD(j)->target_time_out[SCpnt->target]++;
SCpnt992drivers/scsi/u14-34f.cif (SCpnt->device->type != TYPE_TAPE)
SCpnt1013drivers/scsi/u14-34f.cSCpnt->result = status | spp->target_status;
SCpnt1019drivers/scsi/u14-34f.cif (SCpnt->result || do_trace) 
SCpnt1029drivers/scsi/u14-34f.cSCpnt->target, SCpnt->lun, SCpnt->pid, HD(j)->iocount);
SCpnt1032drivers/scsi/u14-34f.cSCpnt->host_scribble = NULL;
SCpnt1035drivers/scsi/u14-34f.cSCpnt->scsi_done(SCpnt);
SCpnt297drivers/scsi/ultrastor.cstatic inline void build_sg_list(struct mscp *, Scsi_Cmnd *SCpnt);
SCpnt656drivers/scsi/ultrastor.cstatic inline void build_sg_list(register struct mscp *mscp, Scsi_Cmnd *SCpnt)
SCpnt662drivers/scsi/ultrastor.csl = (struct scatterlist *) SCpnt->request_buffer;
SCpnt663drivers/scsi/ultrastor.cmax = SCpnt->use_sg;
SCpnt677drivers/scsi/ultrastor.cint ultrastor_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt715drivers/scsi/ultrastor.cmy_mscp->ca = SCpnt->device->type != TYPE_TAPE;
SCpnt716drivers/scsi/ultrastor.cmy_mscp->target_id = SCpnt->target;
SCpnt718drivers/scsi/ultrastor.cmy_mscp->lun = SCpnt->lun;
SCpnt719drivers/scsi/ultrastor.cif (SCpnt->use_sg) {
SCpnt722drivers/scsi/ultrastor.cbuild_sg_list(my_mscp, SCpnt);
SCpnt726drivers/scsi/ultrastor.cmy_mscp->transfer_data = (unsigned int)SCpnt->request_buffer;
SCpnt727drivers/scsi/ultrastor.cmy_mscp->transfer_data_length = SCpnt->request_bufflen;
SCpnt731drivers/scsi/ultrastor.cmy_mscp->length_of_sense_byte = sizeof SCpnt->sense_buffer;
SCpnt732drivers/scsi/ultrastor.cmy_mscp->length_of_scsi_cdbs = SCpnt->cmd_len;
SCpnt733drivers/scsi/ultrastor.cmemcpy(my_mscp->scsi_cdbs, SCpnt->cmnd, my_mscp->length_of_scsi_cdbs);
SCpnt736drivers/scsi/ultrastor.cmy_mscp->sense_data = (unsigned int)&SCpnt->sense_buffer;
SCpnt738drivers/scsi/ultrastor.cmy_mscp->SCint = SCpnt;
SCpnt739drivers/scsi/ultrastor.cSCpnt->host_scribble = (unsigned char *)my_mscp;
SCpnt785drivers/scsi/ultrastor.cSCpnt->result = status;
SCpnt786drivers/scsi/ultrastor.cdone(SCpnt);
SCpnt829drivers/scsi/ultrastor.cint ultrastor_abort(Scsi_Cmnd *SCpnt)
SCpnt844drivers/scsi/ultrastor.cif(!SCpnt->host_scribble)
SCpnt847drivers/scsi/ultrastor.cmscp_index = ((struct mscp *)SCpnt->host_scribble) - config.mscp;
SCpnt935drivers/scsi/ultrastor.cif (config.mscp[mscp_index].SCint != SCpnt)
SCpnt937drivers/scsi/ultrastor.cconfig.mscp[mscp_index].SCint, SCpnt);
SCpnt942drivers/scsi/ultrastor.cif (config.mscp[mscp_index].SCint != SCpnt) panic("Bad abort");
SCpnt946drivers/scsi/ultrastor.cSCpnt->result = DID_ABORT << 16;
SCpnt948drivers/scsi/ultrastor.cdone(SCpnt);
SCpnt954drivers/scsi/ultrastor.cint ultrastor_reset(Scsi_Cmnd * SCpnt)
SCpnt351drivers/scsi/wd7000.cScsi_Cmnd *SCpnt;             /* Scsi_Cmnd using this SCB */
SCpnt682drivers/scsi/wd7000.cscbs[i].next = &(scbs[i+1]);  scbs[i].SCpnt = NULL;
SCpnt685drivers/scsi/wd7000.cscbs[MAX_SCBS-1].SCpnt = NULL;
SCpnt800drivers/scsi/wd7000.cstatic void wd7000_scsi_done(Scsi_Cmnd * SCpnt)
SCpnt803drivers/scsi/wd7000.cprintk("wd7000_scsi_done: %06x\n",(unsigned int) SCpnt);
SCpnt805drivers/scsi/wd7000.cSCpnt->SCp.phase = 0;
SCpnt817drivers/scsi/wd7000.cregister Scsi_Cmnd *SCpnt;
SCpnt874drivers/scsi/wd7000.cSCpnt = scb->SCpnt;
SCpnt875drivers/scsi/wd7000.cif (--(SCpnt->SCp.phase) <= 0)  {  /* all scbs are done */
SCpnt879drivers/scsi/wd7000.cSCpnt->result = errstatus;
SCpnt883drivers/scsi/wd7000.cSCpnt->scsi_done(SCpnt);
SCpnt898drivers/scsi/wd7000.cint wd7000_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt902drivers/scsi/wd7000.cregister unchar *cdb = (unchar *) SCpnt->cmnd;
SCpnt905drivers/scsi/wd7000.cAdapter *host = (Adapter *) SCpnt->host->hostdata;
SCpnt907drivers/scsi/wd7000.ccdblen = SCpnt->cmd_len;
SCpnt908drivers/scsi/wd7000.cidlun = ((SCpnt->target << 5) & 0xe0) | (SCpnt->lun & 7);
SCpnt909drivers/scsi/wd7000.cSCpnt->scsi_done = done;
SCpnt910drivers/scsi/wd7000.cSCpnt->SCp.phase = 1;
SCpnt916drivers/scsi/wd7000.cscb->SCpnt = SCpnt;         /* so we can find stuff later */
SCpnt917drivers/scsi/wd7000.cSCpnt->host_scribble = (unchar *) scb;
SCpnt920drivers/scsi/wd7000.cif (SCpnt->use_sg)  {
SCpnt921drivers/scsi/wd7000.cstruct scatterlist *sg = (struct scatterlist *) SCpnt->request_buffer;
SCpnt924drivers/scsi/wd7000.cif (SCpnt->host->sg_tablesize == SG_NONE)  {
SCpnt928drivers/scsi/wd7000.cprintk("Using scatter/gather with %d elements.\n",SCpnt->use_sg);
SCpnt934drivers/scsi/wd7000.cany2scsi(scb->maxlen, SCpnt->use_sg * sizeof (Sgb) );
SCpnt936drivers/scsi/wd7000.cfor (i = 0;  i < SCpnt->use_sg;  i++)  {
SCpnt942drivers/scsi/wd7000.cany2scsi(scb->dataptr, (int) SCpnt->request_buffer);
SCpnt943drivers/scsi/wd7000.cany2scsi(scb->maxlen, SCpnt->request_bufflen);
SCpnt951drivers/scsi/wd7000.cint wd7000_command(Scsi_Cmnd *SCpnt)
SCpnt953drivers/scsi/wd7000.cwd7000_queuecommand(SCpnt, wd7000_scsi_done);
SCpnt955drivers/scsi/wd7000.cwhile (SCpnt->SCp.phase > 0) barrier();  /* phase counts scbs down to 0 */
SCpnt957drivers/scsi/wd7000.creturn SCpnt->result;
SCpnt1194drivers/scsi/wd7000.cint wd7000_abort(Scsi_Cmnd * SCpnt)
SCpnt1196drivers/scsi/wd7000.cAdapter *host = (Adapter *) SCpnt->host->hostdata;
SCpnt1211drivers/scsi/wd7000.cint wd7000_reset(Scsi_Cmnd * SCpnt)