taglinefilesource code
SCpnt702drivers/scsi/aha152x.cint aha152x_queue( Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt715drivers/scsi/aha152x.cSCpnt->target,
SCpnt716drivers/scsi/aha152x.cSCpnt->lun,
SCpnt717drivers/scsi/aha152x.c*(unsigned char *)SCpnt->cmnd,
SCpnt718drivers/scsi/aha152x.cSCpnt->use_sg,
SCpnt719drivers/scsi/aha152x.cSCpnt->request_bufflen );
SCpnt723drivers/scsi/aha152x.cSCpnt->scsi_done =       done;
SCpnt731drivers/scsi/aha152x.cSCpnt->SCp.phase = not_issued;
SCpnt732drivers/scsi/aha152x.cif (SCpnt->use_sg)
SCpnt734drivers/scsi/aha152x.cSCpnt->SCp.buffer           = (struct scatterlist *)SCpnt->request_buffer;
SCpnt735drivers/scsi/aha152x.cSCpnt->SCp.ptr              = SCpnt->SCp.buffer->address;
SCpnt736drivers/scsi/aha152x.cSCpnt->SCp.this_residual    = SCpnt->SCp.buffer->length;
SCpnt737drivers/scsi/aha152x.cSCpnt->SCp.buffers_residual = SCpnt->use_sg - 1;
SCpnt741drivers/scsi/aha152x.cSCpnt->SCp.ptr              = (char *)SCpnt->request_buffer;
SCpnt742drivers/scsi/aha152x.cSCpnt->SCp.this_residual    = SCpnt->request_bufflen;
SCpnt743drivers/scsi/aha152x.cSCpnt->SCp.buffer           = NULL;
SCpnt744drivers/scsi/aha152x.cSCpnt->SCp.buffers_residual = 0;
SCpnt747drivers/scsi/aha152x.cSCpnt->SCp.Status              = CHECK_CONDITION;
SCpnt748drivers/scsi/aha152x.cSCpnt->SCp.Message             = 0;
SCpnt749drivers/scsi/aha152x.cSCpnt->SCp.have_data_in        = 0;
SCpnt750drivers/scsi/aha152x.cSCpnt->SCp.sent_command        = 0;
SCpnt761drivers/scsi/aha152x.cappend_SC( &issue_SC, SCpnt);
SCpnt777drivers/scsi/aha152x.cint aha152x_command( Scsi_Cmnd *SCpnt )
SCpnt787drivers/scsi/aha152x.cint aha152x_abort( Scsi_Cmnd *SCpnt, int code )
SCpnt794drivers/scsi/aha152x.cprintk("aha152x: abort(), SCpnt=0x%08x, ", (unsigned long) SCpnt );
SCpnt801drivers/scsi/aha152x.cptr && ptr!=SCpnt;
SCpnt829drivers/scsi/aha152x.cptr && ptr!=SCpnt;
SCpnt388drivers/scsi/aha1542.cint aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt392drivers/scsi/aha1542.cunchar *cmd = (unchar *) SCpnt->cmnd;
SCpnt393drivers/scsi/aha1542.cunchar target = SCpnt->target;
SCpnt394drivers/scsi/aha1542.cunchar lun = SCpnt->lun;
SCpnt395drivers/scsi/aha1542.cvoid *buff = SCpnt->request_buffer;
SCpnt396drivers/scsi/aha1542.cint bufflen = SCpnt->request_bufflen;
SCpnt403drivers/scsi/aha1542.cmb = HOSTDATA(SCpnt->host)->mb;
SCpnt404drivers/scsi/aha1542.cccb = HOSTDATA(SCpnt->host)->ccb;
SCpnt407drivers/scsi/aha1542.cSCpnt->result = DID_TIME_OUT << 16;
SCpnt408drivers/scsi/aha1542.cdone(SCpnt); return 0;});
SCpnt412drivers/scsi/aha1542.cif (bufflen != sizeof(SCpnt->sense_buffer)) {
SCpnt417drivers/scsi/aha1542.cSCpnt->result = 0;
SCpnt418drivers/scsi/aha1542.cdone(SCpnt); 
SCpnt444drivers/scsi/aha1542.cmbo = HOSTDATA(SCpnt->host)->aha1542_last_mbo_used + 1;
SCpnt448drivers/scsi/aha1542.cif(mb[mbo].status == 0 && HOSTDATA(SCpnt->host)->SCint[mbo] == NULL)
SCpnt452drivers/scsi/aha1542.c} while (mbo != HOSTDATA(SCpnt->host)->aha1542_last_mbo_used);
SCpnt454drivers/scsi/aha1542.cif(mb[mbo].status || HOSTDATA(SCpnt->host)->SCint[mbo])
SCpnt457drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->SCint[mbo] = SCpnt;  /* This will effectively prevent someone else from
SCpnt460drivers/scsi/aha1542.cHOSTDATA(SCpnt->host)->aha1542_last_mbo_used = mbo;    
SCpnt481drivers/scsi/aha1542.cif (SCpnt->use_sg) {
SCpnt489drivers/scsi/aha1542.cSCpnt->host_scribble = (unsigned char *) scsi_malloc(512);
SCpnt490drivers/scsi/aha1542.csgpnt = (struct scatterlist *) SCpnt->request_buffer;
SCpnt491drivers/scsi/aha1542.ccptr = (struct chain *) SCpnt->host_scribble; 
SCpnt493drivers/scsi/aha1542.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt494drivers/scsi/aha1542.cif(sgpnt[i].length == 0 || SCpnt->use_sg > 16 || 
SCpnt497drivers/scsi/aha1542.cprintk("Bad segment list supplied to aha1542.c (%d, %d)\n",SCpnt->use_sg,i);
SCpnt498drivers/scsi/aha1542.cfor(i=0;i<SCpnt->use_sg;i++){
SCpnt511drivers/scsi/aha1542.cany2scsi(ccb[mbo].datalen, SCpnt->use_sg * sizeof(struct chain));
SCpnt521drivers/scsi/aha1542.cSCpnt->host_scribble = NULL;
SCpnt540drivers/scsi/aha1542.cSCpnt->scsi_done = done;
SCpnt542drivers/scsi/aha1542.caha1542_out(SCpnt->host->io_port, &ahacmd, 1);    /* start scsi command */
SCpnt553drivers/scsi/aha1542.cstatic void internal_done(Scsi_Cmnd * SCpnt)
SCpnt555drivers/scsi/aha1542.cSCpnt->SCp.Status++;
SCpnt558drivers/scsi/aha1542.cint aha1542_command(Scsi_Cmnd * SCpnt)
SCpnt562drivers/scsi/aha1542.caha1542_queuecommand(SCpnt, internal_done);
SCpnt564drivers/scsi/aha1542.cSCpnt->SCp.Status = 0;
SCpnt565drivers/scsi/aha1542.cwhile (!SCpnt->SCp.Status);
SCpnt566drivers/scsi/aha1542.creturn SCpnt->result;
SCpnt867drivers/scsi/aha1542.cint aha1542_abort(Scsi_Cmnd * SCpnt, int i)
SCpnt877drivers/scsi/aha1542.cif (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]){
SCpnt891drivers/scsi/aha1542.cint aha1542_reset(Scsi_Cmnd * SCpnt)
SCpnt894drivers/scsi/aha1542.cif(SCpnt) SCpnt->flags |= NEEDS_JUMPSTART;
SCpnt198drivers/scsi/aha1740.cSCtmp = ecbptr->SCpnt;
SCpnt238drivers/scsi/aha1740.cint aha1740_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt241drivers/scsi/aha1740.cunchar *cmd = (unchar *) SCpnt->cmnd;
SCpnt242drivers/scsi/aha1740.cunchar target = SCpnt->target;
SCpnt243drivers/scsi/aha1740.cvoid *buff = SCpnt->request_buffer;
SCpnt244drivers/scsi/aha1740.cint bufflen = SCpnt->request_bufflen;
SCpnt251drivers/scsi/aha1740.cif (bufflen != sizeof(SCpnt->sense_buffer))
SCpnt256drivers/scsi/aha1740.cSCpnt->result = 0;
SCpnt257drivers/scsi/aha1740.cdone(SCpnt); 
SCpnt309drivers/scsi/aha1740.cif (SCpnt->use_sg)
SCpnt318drivers/scsi/aha1740.cSCpnt->host_scribble = (unsigned char *) scsi_malloc(512);
SCpnt319drivers/scsi/aha1740.csgpnt = (struct scatterlist *) SCpnt->request_buffer;
SCpnt320drivers/scsi/aha1740.ccptr = (struct aha1740_chain *) SCpnt->host_scribble; 
SCpnt322drivers/scsi/aha1740.cfor(i=0; i<SCpnt->use_sg; i++)
SCpnt327drivers/scsi/aha1740.cecb[ecbno].datalen = SCpnt->use_sg * sizeof(struct aha1740_chain);
SCpnt337drivers/scsi/aha1740.cSCpnt->host_scribble = NULL;
SCpnt341drivers/scsi/aha1740.cecb[ecbno].lun = SCpnt->lun;
SCpnt349drivers/scsi/aha1740.cecb[ecbno].SCpnt = SCpnt;
SCpnt403drivers/scsi/aha1740.cstatic void internal_done(Scsi_Cmnd * SCpnt)
SCpnt405drivers/scsi/aha1740.cinternal_done_errcode = SCpnt->result;
SCpnt409drivers/scsi/aha1740.cint aha1740_command(Scsi_Cmnd * SCpnt)
SCpnt411drivers/scsi/aha1740.caha1740_queuecommand(SCpnt, internal_done);
SCpnt477drivers/scsi/aha1740.cint aha1740_abort(Scsi_Cmnd * SCpnt, int i)
SCpnt487drivers/scsi/aha1740.cint aha1740_reset(Scsi_Cmnd * SCpnt)
SCpnt490drivers/scsi/aha1740.cif (SCpnt) SCpnt->flags |= NEEDS_JUMPSTART;
SCpnt142drivers/scsi/aha1740.hScsi_Cmnd *SCpnt;    /* Link to the SCSI Command Block */
SCpnt360drivers/scsi/constants.cvoid print_sense(char * devclass, Scsi_Cmnd * SCpnt)
SCpnt364drivers/scsi/constants.cunsigned char * sense_buffer = SCpnt->sense_buffer;
SCpnt366drivers/scsi/constants.cint dev = SCpnt->request.dev;
SCpnt374drivers/scsi/constants.cif(s > sizeof(SCpnt->sense_buffer)) s = sizeof(SCpnt->sense_buffer);
SCpnt1189drivers/scsi/fdomain.cint fdomain_16x0_queue( Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt1196drivers/scsi/fdomain.cSCpnt->target,
SCpnt1197drivers/scsi/fdomain.c*(unsigned char *)SCpnt->cmnd,
SCpnt1198drivers/scsi/fdomain.cSCpnt->use_sg,
SCpnt1199drivers/scsi/fdomain.cSCpnt->request_bufflen );
SCpnt1204drivers/scsi/fdomain.ccurrent_SC            = SCpnt; /* Save this for the done function */
SCpnt1247drivers/scsi/fdomain.cstatic void internal_done( Scsi_Cmnd *SCpnt )
SCpnt1249drivers/scsi/fdomain.cinternal_done_errcode = SCpnt->result;
SCpnt1253drivers/scsi/fdomain.cint fdomain_16x0_command( Scsi_Cmnd *SCpnt )
SCpnt1255drivers/scsi/fdomain.cfdomain_16x0_queue( SCpnt, internal_done );
SCpnt1265drivers/scsi/fdomain.cvoid print_info( Scsi_Cmnd *SCpnt )
SCpnt1272drivers/scsi/fdomain.cswitch (SCpnt->SCp.phase) {
SCpnt1280drivers/scsi/fdomain.cSCpnt->SCp.phase,
SCpnt1281drivers/scsi/fdomain.cSCpnt->target,
SCpnt1282drivers/scsi/fdomain.c*(unsigned char *)SCpnt->cmnd,
SCpnt1283drivers/scsi/fdomain.cSCpnt->use_sg,
SCpnt1284drivers/scsi/fdomain.cSCpnt->request_bufflen );
SCpnt1286drivers/scsi/fdomain.cSCpnt->SCp.sent_command,
SCpnt1287drivers/scsi/fdomain.cSCpnt->SCp.have_data_in,
SCpnt1288drivers/scsi/fdomain.cSCpnt->timeout );
SCpnt1329drivers/scsi/fdomain.cint fdomain_16x0_abort( Scsi_Cmnd *SCpnt, int code )
SCpnt1350drivers/scsi/fdomain.cprint_info( SCpnt );
SCpnt1367drivers/scsi/fdomain.cint fdomain_16x0_reset( Scsi_Cmnd *SCpnt )
SCpnt1393drivers/scsi/fdomain.cif (SCpnt)
SCpnt1394drivers/scsi/fdomain.cSCpnt->flags |= NEEDS_JUMPSTART;
SCpnt37drivers/scsi/scsi.cstatic void scsi_done (Scsi_Cmnd *SCpnt);
SCpnt40drivers/scsi/scsi.cstatic void scsi_times_out (Scsi_Cmnd * SCpnt);
SCpnt171drivers/scsi/scsi.cstatic void scan_scsis_done (Scsi_Cmnd * SCpnt)
SCpnt175drivers/scsi/scsi.cprintk ("scan_scsis_done(%d, %06x)\n", SCpnt->host, SCpnt->result);
SCpnt177drivers/scsi/scsi.cSCpnt->request.dev = 0xfffe;
SCpnt489drivers/scsi/scsi.cstatic void scsi_times_out (Scsi_Cmnd * SCpnt)
SCpnt492drivers/scsi/scsi.cswitch (SCpnt->internal_timeout & (IN_ABORT | IN_RESET))
SCpnt497drivers/scsi/scsi.cSCpnt->host->host_no);
SCpnt499drivers/scsi/scsi.cif (!scsi_abort  (SCpnt, DID_TIME_OUT))
SCpnt503drivers/scsi/scsi.cSCpnt->host->host_no);
SCpnt504drivers/scsi/scsi.cif (!scsi_reset (SCpnt)) 
SCpnt508drivers/scsi/scsi.cpanic("Unable to reset scsi host %d\n",SCpnt->host->host_no);
SCpnt524drivers/scsi/scsi.cScsi_Cmnd * SCpnt = NULL;
SCpnt534drivers/scsi/scsi.cSCpnt =  scsi_devices[index].host->host_queue;
SCpnt535drivers/scsi/scsi.cwhile(SCpnt){
SCpnt536drivers/scsi/scsi.cif(SCpnt->target == scsi_devices[index].id &&
SCpnt537drivers/scsi/scsi.cSCpnt->lun == scsi_devices[index].lun)
SCpnt538drivers/scsi/scsi.cif(SCpnt->request.dev < 0) break;
SCpnt539drivers/scsi/scsi.cSCpnt = SCpnt->next;
SCpnt542drivers/scsi/scsi.cif (!SCpnt) return NULL;
SCpnt548drivers/scsi/scsi.cmemcpy(&SCpnt->request, req, sizeof(struct request));
SCpnt562drivers/scsi/scsi.cSCpnt->request.bhtail = bh;
SCpnt568drivers/scsi/scsi.cSCpnt->request.nr_sectors -= req->nr_sectors;
SCpnt571drivers/scsi/scsi.cSCpnt->request.waiting = NULL; /* Wait until whole thing done */
SCpnt576drivers/scsi/scsi.cSCpnt->request.dev = 0xffff; /* Busy, but no request */
SCpnt577drivers/scsi/scsi.cSCpnt->request.waiting = NULL;  /* And no one is waiting for the device either */
SCpnt580drivers/scsi/scsi.cSCpnt->use_sg = 0;  /* Reset the scatter-gather flag */
SCpnt581drivers/scsi/scsi.cSCpnt->old_use_sg  = 0;
SCpnt582drivers/scsi/scsi.cSCpnt->transfersize = 0;
SCpnt583drivers/scsi/scsi.cSCpnt->underflow = 0;
SCpnt584drivers/scsi/scsi.creturn SCpnt;
SCpnt603drivers/scsi/scsi.cScsi_Cmnd * SCpnt = NULL;
SCpnt617drivers/scsi/scsi.cSCpnt = host->host_queue;
SCpnt618drivers/scsi/scsi.cwhile(SCpnt){
SCpnt619drivers/scsi/scsi.cif(SCpnt->target == scsi_devices[index].id &&
SCpnt620drivers/scsi/scsi.cSCpnt->lun == scsi_devices[index].lun) {
SCpnt621drivers/scsi/scsi.cSCwait = SCpnt;
SCpnt622drivers/scsi/scsi.cif(SCpnt->request.dev < 0) break;
SCpnt624drivers/scsi/scsi.cSCpnt = SCpnt->next;
SCpnt632drivers/scsi/scsi.cif (!SCpnt || SCpnt->request.dev >= 0)  /* Might have changed */
SCpnt645drivers/scsi/scsi.cmemcpy(&SCpnt->request, req, sizeof(struct request));
SCpnt659drivers/scsi/scsi.cSCpnt->request.bhtail = bh;
SCpnt664drivers/scsi/scsi.cSCpnt->request.nr_sectors -= req->nr_sectors;
SCpnt667drivers/scsi/scsi.cSCpnt->request.waiting = NULL; /* Wait until whole thing done */
SCpnt675drivers/scsi/scsi.cSCpnt->request.dev = 0xffff; /* Busy */
SCpnt676drivers/scsi/scsi.cSCpnt->request.waiting = NULL;  /* And no one is waiting for this to complete */
SCpnt683drivers/scsi/scsi.cSCpnt->use_sg = 0;  /* Reset the scatter-gather flag */
SCpnt684drivers/scsi/scsi.cSCpnt->old_use_sg  = 0;
SCpnt685drivers/scsi/scsi.cSCpnt->transfersize = 0;      /* No default transfer size */
SCpnt686drivers/scsi/scsi.cSCpnt->underflow = 0;         /* Do not flag underflow conditions */
SCpnt687drivers/scsi/scsi.creturn SCpnt;
SCpnt694drivers/scsi/scsi.cinline void internal_cmnd (Scsi_Cmnd * SCpnt)
SCpnt702drivers/scsi/scsi.cif ((unsigned long) &SCpnt < current->kernel_stack_page)
SCpnt705drivers/scsi/scsi.chost = SCpnt->host;
SCpnt714drivers/scsi/scsi.cupdate_timeout(SCpnt, SCpnt->timeout_per_command);
SCpnt722drivers/scsi/scsi.c"bufflen = %d, done = %08x)\n", SCpnt->host->host_no, SCpnt->target, SCpnt->cmnd, SCpnt->buffer, SCpnt->bufflen, SCpnt->done);
SCpnt731drivers/scsi/scsi.chost->hostt->queuecommand (SCpnt, scsi_done);
SCpnt739drivers/scsi/scsi.ctemp=host->hostt->command (SCpnt);
SCpnt740drivers/scsi/scsi.cSCpnt->result = temp;
SCpnt746drivers/scsi/scsi.cscsi_done(SCpnt);
SCpnt753drivers/scsi/scsi.cstatic void scsi_request_sense (Scsi_Cmnd * SCpnt)
SCpnt756drivers/scsi/scsi.cSCpnt->flags |= WAS_SENSE | ASKED_FOR_SENSE;
SCpnt757drivers/scsi/scsi.cupdate_timeout(SCpnt, SENSE_TIMEOUT);
SCpnt761drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd , (void *) generic_sense,
SCpnt764drivers/scsi/scsi.cSCpnt->cmnd[1] = SCpnt->lun << 5;  
SCpnt765drivers/scsi/scsi.cSCpnt->cmnd[4] = sizeof(SCpnt->sense_buffer);
SCpnt767drivers/scsi/scsi.cSCpnt->request_buffer = &SCpnt->sense_buffer;
SCpnt768drivers/scsi/scsi.cSCpnt->request_bufflen = sizeof(SCpnt->sense_buffer);
SCpnt769drivers/scsi/scsi.cSCpnt->use_sg = 0;
SCpnt770drivers/scsi/scsi.cinternal_cmnd (SCpnt);
SCpnt771drivers/scsi/scsi.cSCpnt->use_sg = SCpnt->old_use_sg;
SCpnt783drivers/scsi/scsi.cvoid scsi_do_cmd (Scsi_Cmnd * SCpnt, const void *cmnd , 
SCpnt788drivers/scsi/scsi.cstruct Scsi_Host * host = SCpnt->host;
SCpnt793drivers/scsi/scsi.cint target = SCpnt->target;
SCpnt839drivers/scsi/scsi.cmemcpy ((void *) SCpnt->data_cmnd , (void *) cmnd, 12);
SCpnt841drivers/scsi/scsi.cSCpnt->host = host;
SCpnt842drivers/scsi/scsi.cSCpnt->target = target;
SCpnt843drivers/scsi/scsi.cSCpnt->lun = (SCpnt->data_cmnd[1] >> 5);
SCpnt845drivers/scsi/scsi.cSCpnt->bufflen = bufflen;
SCpnt846drivers/scsi/scsi.cSCpnt->buffer = buffer;
SCpnt847drivers/scsi/scsi.cSCpnt->flags=0;
SCpnt848drivers/scsi/scsi.cSCpnt->retries=0;
SCpnt849drivers/scsi/scsi.cSCpnt->allowed=retries;
SCpnt850drivers/scsi/scsi.cSCpnt->done = done;
SCpnt851drivers/scsi/scsi.cSCpnt->timeout_per_command = timeout;
SCpnt853drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd , (void *) cmnd, 12);
SCpnt856drivers/scsi/scsi.cmemset ((void *) SCpnt->sense_buffer, 0, sizeof SCpnt->sense_buffer);
SCpnt857drivers/scsi/scsi.cSCpnt->request_buffer = buffer;
SCpnt858drivers/scsi/scsi.cSCpnt->request_bufflen = bufflen;
SCpnt859drivers/scsi/scsi.cSCpnt->old_use_sg = SCpnt->use_sg;
SCpnt863drivers/scsi/scsi.cSCpnt->internal_timeout = 0;
SCpnt864drivers/scsi/scsi.cinternal_cmnd (SCpnt);
SCpnt879drivers/scsi/scsi.cstatic void reset (Scsi_Cmnd * SCpnt)
SCpnt882drivers/scsi/scsi.cprintk("scsi: reset(%d)\n", SCpnt->host->host_no);
SCpnt885drivers/scsi/scsi.cSCpnt->flags |= (WAS_RESET | IS_RESETTING);
SCpnt886drivers/scsi/scsi.cscsi_reset(SCpnt);
SCpnt892drivers/scsi/scsi.cif(SCpnt->flags & NEEDS_JUMPSTART) {
SCpnt893drivers/scsi/scsi.cSCpnt->flags &= ~NEEDS_JUMPSTART;
SCpnt894drivers/scsi/scsi.cscsi_request_sense (SCpnt);
SCpnt900drivers/scsi/scsi.cstatic int check_sense (Scsi_Cmnd * SCpnt)
SCpnt905drivers/scsi/scsi.cif (((SCpnt->sense_buffer[0] & 0x70) >> 4) != 7) {
SCpnt906drivers/scsi/scsi.cif(!(SCpnt->flags & ASKED_FOR_SENSE))
SCpnt912drivers/scsi/scsi.cSCpnt->flags &= ~ASKED_FOR_SENSE;
SCpnt915drivers/scsi/scsi.cprintk("scsi%d : ", SCpnt->host->host_no);
SCpnt916drivers/scsi/scsi.cprint_sense("", SCpnt);
SCpnt919drivers/scsi/scsi.cif (SCpnt->sense_buffer[2] &0xe0)
SCpnt922drivers/scsi/scsi.cswitch (SCpnt->sense_buffer[2] & 0xf)
SCpnt927drivers/scsi/scsi.cif (scsi_devices[SCpnt->index].type == TYPE_TAPE)
SCpnt975drivers/scsi/scsi.cstatic void scsi_done (Scsi_Cmnd * SCpnt)
SCpnt981drivers/scsi/scsi.cstruct Scsi_Host * host = SCpnt->host;
SCpnt982drivers/scsi/scsi.cint result = SCpnt->result;
SCpnt983drivers/scsi/scsi.coldto = update_timeout(SCpnt, 0);
SCpnt996drivers/scsi/scsi.cif (SCpnt->flags & IS_RESETTING)
SCpnt998drivers/scsi/scsi.cSCpnt->flags &= ~IS_RESETTING;
SCpnt1003drivers/scsi/scsi.cif (status_byte(result) && (SCpnt->flags & WAS_SENSE))
SCpnt1006drivers/scsi/scsi.cSCpnt->flags &= ~WAS_SENSE;
SCpnt1007drivers/scsi/scsi.cSCpnt->internal_timeout &= ~SENSE_TIMEOUT;
SCpnt1009drivers/scsi/scsi.cif (!(SCpnt->flags & WAS_RESET))
SCpnt1012drivers/scsi/scsi.cSCpnt->host->host_no, SCpnt->target, SCpnt->lun);
SCpnt1013drivers/scsi/scsi.creset(SCpnt);
SCpnt1028drivers/scsi/scsi.cif (SCpnt->flags & WAS_SENSE)
SCpnt1034drivers/scsi/scsi.cSCpnt->flags &= ~WAS_SENSE;
SCpnt1035drivers/scsi/scsi.cSCpnt->internal_timeout &= ~SENSE_TIMEOUT;
SCpnt1037drivers/scsi/scsi.cswitch (checked = check_sense(SCpnt))
SCpnt1045drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1084drivers/scsi/scsi.cswitch (check_sense(SCpnt))
SCpnt1087drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1100drivers/scsi/scsi.cscsi_request_sense (SCpnt);
SCpnt1112drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1118drivers/scsi/scsi.cSCpnt->host->host_no);
SCpnt1119drivers/scsi/scsi.creset(SCpnt);
SCpnt1142drivers/scsi/scsi.cif (SCpnt->flags & WAS_TIMEDOUT)  
SCpnt1154drivers/scsi/scsi.cSCpnt->flags  |= WAS_TIMEDOUT;
SCpnt1179drivers/scsi/scsi.cswitch (check_sense(SCpnt)) {
SCpnt1181drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1194drivers/scsi/scsi.cscsi_request_sense (SCpnt);
SCpnt1216drivers/scsi/scsi.cSCpnt->allowed, SCpnt->retries);
SCpnt1219drivers/scsi/scsi.cif ((++SCpnt->retries) < SCpnt->allowed)
SCpnt1221drivers/scsi/scsi.cif ((SCpnt->retries >= (SCpnt->allowed >> 1))
SCpnt1222drivers/scsi/scsi.c&& !(SCpnt->flags & WAS_RESET))
SCpnt1225drivers/scsi/scsi.cSCpnt->host->host_no);
SCpnt1226drivers/scsi/scsi.creset(SCpnt);
SCpnt1239drivers/scsi/scsi.cif (SCpnt->flags & WAS_SENSE)      
SCpnt1240drivers/scsi/scsi.cscsi_request_sense(SCpnt);   
SCpnt1243drivers/scsi/scsi.cmemcpy ((void *) SCpnt->cmnd,
SCpnt1244drivers/scsi/scsi.c(void*) SCpnt->data_cmnd, 
SCpnt1245drivers/scsi/scsi.csizeof(SCpnt->data_cmnd));
SCpnt1246drivers/scsi/scsi.cSCpnt->request_buffer = SCpnt->buffer;
SCpnt1247drivers/scsi/scsi.cSCpnt->request_bufflen = SCpnt->bufflen;
SCpnt1248drivers/scsi/scsi.cSCpnt->use_sg = SCpnt->old_use_sg;
SCpnt1249drivers/scsi/scsi.cinternal_cmnd (SCpnt);
SCpnt1259drivers/scsi/scsi.cprintk("Calling done function - at address %08x\n", SCpnt->done);
SCpnt1263drivers/scsi/scsi.cSCpnt->result = result | ((exit & 0xff) << 24);
SCpnt1264drivers/scsi/scsi.cSCpnt->use_sg = SCpnt->old_use_sg;
SCpnt1265drivers/scsi/scsi.cSCpnt->done (SCpnt);
SCpnt1291drivers/scsi/scsi.cint scsi_abort (Scsi_Cmnd * SCpnt, int why)
SCpnt1294drivers/scsi/scsi.cstruct Scsi_Host * host = SCpnt->host;
SCpnt1299drivers/scsi/scsi.cif (SCpnt->internal_timeout & IN_ABORT) 
SCpnt1302drivers/scsi/scsi.cwhile (SCpnt->internal_timeout & IN_ABORT);
SCpnt1306drivers/scsi/scsi.cSCpnt->internal_timeout |= IN_ABORT;
SCpnt1307drivers/scsi/scsi.coldto = update_timeout(SCpnt, ABORT_TIMEOUT);
SCpnt1311drivers/scsi/scsi.cif (!host->host_busy || !host->hostt->abort(SCpnt, why))
SCpnt1317drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_ABORT;
SCpnt1318drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1325drivers/scsi/scsi.cint scsi_reset (Scsi_Cmnd * SCpnt)
SCpnt1329drivers/scsi/scsi.cstruct Scsi_Host * host = SCpnt->host;
SCpnt1336drivers/scsi/scsi.cif (SCpnt->internal_timeout & IN_RESET)
SCpnt1339drivers/scsi/scsi.cwhile (SCpnt->internal_timeout & IN_RESET);
SCpnt1343drivers/scsi/scsi.cSCpnt->internal_timeout |= IN_RESET;
SCpnt1344drivers/scsi/scsi.coldto = update_timeout(SCpnt, RESET_TIMEOUT);  
SCpnt1358drivers/scsi/scsi.ctemp = host->hostt->reset(SCpnt);  
SCpnt1365drivers/scsi/scsi.ctemp = host->hostt->reset(SCpnt);
SCpnt1371drivers/scsi/scsi.cSCpnt->internal_timeout &= ~IN_RESET;
SCpnt1372drivers/scsi/scsi.cupdate_timeout(SCpnt, oldto);
SCpnt1388drivers/scsi/scsi.cScsi_Cmnd * SCpnt = NULL;
SCpnt1400drivers/scsi/scsi.cSCpnt = host->host_queue;
SCpnt1401drivers/scsi/scsi.cwhile (SCpnt){
SCpnt1402drivers/scsi/scsi.cif (SCpnt->timeout > 0 && SCpnt->timeout <= time_elapsed)
SCpnt1405drivers/scsi/scsi.cSCpnt->timeout = 0;
SCpnt1406drivers/scsi/scsi.cscsi_times_out(SCpnt);
SCpnt1410drivers/scsi/scsi.cSCpnt =  SCpnt->next;
SCpnt1431drivers/scsi/scsi.cScsi_Cmnd * SCpnt = NULL;
SCpnt1457drivers/scsi/scsi.cSCpnt = host->host_queue;
SCpnt1458drivers/scsi/scsi.cwhile (SCpnt){
SCpnt1459drivers/scsi/scsi.cif (SCpnt->timeout > 0 && (SCpnt->timeout -= used) < least)
SCpnt1460drivers/scsi/scsi.cleast = SCpnt->timeout;
SCpnt1461drivers/scsi/scsi.cSCpnt =  SCpnt->next;
SCpnt1561drivers/scsi/scsi.cScsi_Cmnd * SCpnt;
SCpnt1582drivers/scsi/scsi.cSCpnt = last_cmnd;
SCpnt1603drivers/scsi/scsi.cSCpnt->host = scsi_devices[i].host;
SCpnt1604drivers/scsi/scsi.cSCpnt->target = scsi_devices[i].id;
SCpnt1605drivers/scsi/scsi.cSCpnt->lun = scsi_devices[i].lun;
SCpnt1606drivers/scsi/scsi.cSCpnt->index = i;
SCpnt1607drivers/scsi/scsi.cSCpnt->request.dev = -1; /* Mark not busy */
SCpnt1608drivers/scsi/scsi.cSCpnt->use_sg = 0;
SCpnt1609drivers/scsi/scsi.cSCpnt->old_use_sg = 0;
SCpnt1610drivers/scsi/scsi.cSCpnt->underflow = 0;
SCpnt1611drivers/scsi/scsi.cSCpnt->transfersize = 0;
SCpnt1612drivers/scsi/scsi.cSCpnt->host_scribble = NULL;
SCpnt1615drivers/scsi/scsi.chost->host_queue->prev = SCpnt;
SCpnt1616drivers/scsi/scsi.cSCpnt->next = host->host_queue;
SCpnt1617drivers/scsi/scsi.cSCpnt->prev = NULL;
SCpnt1618drivers/scsi/scsi.chost->host_queue = SCpnt;
SCpnt1619drivers/scsi/scsi.cSCpnt++;
SCpnt1624drivers/scsi/scsi.cmemory_start = (int) SCpnt;
SCpnt451drivers/scsi/scsi.hstatic void end_scsi_request(Scsi_Cmnd * SCpnt, int uptodate, int sectors)
SCpnt457drivers/scsi/scsi.hreq = &SCpnt->request;
SCpnt494drivers/scsi/scsi.hwake_up(&scsi_devices[SCpnt->index].device_wait);
SCpnt49drivers/scsi/scsi_debug.cif ((SCpnt->request.dev & 0xf) != 0) start = starts[(SCpnt->request.dev & 0xf) - 1];    \
SCpnt55drivers/scsi/scsi_debug.cif (bh->b_dev != SCpnt->request.dev) panic ("Bad bh target");\
SCpnt61drivers/scsi/scsi_debug.cif ((SCpnt->request.dev & 0xfff0) != ((target + NR_REAL) << 4) +(MAJOR_NR << 8)){  \
SCpnt62drivers/scsi/scsi_debug.cprintk("Dev #s %x %x ",SCpnt->request.dev, target);      \
SCpnt68drivers/scsi/scsi_debug.cif (bufflen != 1024 && (!SCpnt->use_sg)) {printk("%x %d\n ",bufflen, SCpnt->use_sg); panic("Bad bufflen");};     \
SCpnt70drivers/scsi/scsi_debug.cif ((SCpnt->request.dev & 0xf) > npart) panic ("Bad partition");  \
SCpnt71drivers/scsi/scsi_debug.cif ((SCpnt->request.dev & 0xf) != 0) start = starts[(SCpnt->request.dev & 0xf) - 1];    \
SCpnt72drivers/scsi/scsi_debug.cif (SCpnt->request.cmd != RW) panic ("Wrong  operation");    \
SCpnt73drivers/scsi/scsi_debug.cif (SCpnt->request.sector + start != block) panic("Wrong block.");  \
SCpnt74drivers/scsi/scsi_debug.cif (SCpnt->request.current_nr_sectors != 2 && (!SCpnt->use_sg)) panic ("Wrong # blocks");  \
SCpnt75drivers/scsi/scsi_debug.cif (SCpnt->request.bh){              \
SCpnt76drivers/scsi/scsi_debug.cif (SCpnt->request.bh->b_size != 1024) panic ("Wrong bh size");  \
SCpnt77drivers/scsi/scsi_debug.cif ((SCpnt->request.bh->b_blocknr << 1) + start != block)           \
SCpnt78drivers/scsi/scsi_debug.c{  printk("Wrong bh block# %d %d ",SCpnt->request.bh->b_blocknr, block);  \
SCpnt80drivers/scsi/scsi_debug.cif (SCpnt->request.bh->b_dev != SCpnt->request.dev) panic ("Bad bh target");\
SCpnt92drivers/scsi/scsi_debug.cstatic void scsi_dump(Scsi_Cmnd * SCpnt, int flag){
SCpnt99drivers/scsi/scsi_debug.cprintk("use_sg: %d",SCpnt->use_sg);
SCpnt100drivers/scsi/scsi_debug.cif (SCpnt->use_sg){
SCpnt101drivers/scsi/scsi_debug.csgpnt = (struct scatterlist *) SCpnt->buffer;
SCpnt102drivers/scsi/scsi_debug.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt108drivers/scsi/scsi_debug.cprintk("nosg: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
SCpnt109drivers/scsi/scsi_debug.cSCpnt->bufflen);
SCpnt110drivers/scsi/scsi_debug.clpnt = (int *) SCpnt->request.buffer;
SCpnt113drivers/scsi/scsi_debug.clpnt = (unsigned int *) SCpnt;
SCpnt137drivers/scsi/scsi_debug.cint scsi_debug_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt139drivers/scsi/scsi_debug.cunchar *cmd = (unchar *) SCpnt->cmnd;
SCpnt147drivers/scsi/scsi_debug.cint target = SCpnt->target;
SCpnt148drivers/scsi/scsi_debug.cint bufflen = SCpnt->request_bufflen;
SCpnt153drivers/scsi/scsi_debug.cDEB(if (target > 1) { SCpnt->result = DID_TIME_OUT << 16;done(SCpnt);return 0;});
SCpnt155drivers/scsi/scsi_debug.cbuff = (unsigned char *) SCpnt->request_buffer;
SCpnt157drivers/scsi/scsi_debug.cif(target>=2 || SCpnt->lun != 0) {
SCpnt158drivers/scsi/scsi_debug.cSCpnt->result =  DID_NO_CONNECT << 16;
SCpnt159drivers/scsi/scsi_debug.cdone(SCpnt);
SCpnt168drivers/scsi/scsi_debug.cprintk("scsi_debug: Requesting sense buffer (%x %x %x %d):", SCpnt, buff, done, bufflen);
SCpnt176drivers/scsi/scsi_debug.cSCpnt->result = 0;
SCpnt177drivers/scsi/scsi_debug.cdone(SCpnt); 
SCpnt203drivers/scsi/scsi_debug.cif(NR_REAL < 0) NR_REAL = (SCpnt->request.dev >> 4) & 0x0f;
SCpnt222drivers/scsi/scsi_debug.cprintk("(r%d)",SCpnt->request.nr_sectors);
SCpnt224drivers/scsi/scsi_debug.cif(SCpnt->use_sg){
SCpnt229drivers/scsi/scsi_debug.cbh = SCpnt->request.bh;
SCpnt252drivers/scsi/scsi_debug.cif (SCpnt->use_sg) printk("Block %x (%d %d)\n",block, SCpnt->request.nr_sectors,
SCpnt253drivers/scsi/scsi_debug.cSCpnt->request.current_nr_sectors);
SCpnt277drivers/scsi/scsi_debug.cmemcpy(buff+64, SCpnt, sizeof(Scsi_Cmnd));
SCpnt279drivers/scsi/scsi_debug.cif(SCpnt->use_sg){
SCpnt291drivers/scsi/scsi_debug.cif (SCpnt->use_sg && !scsi_debug_errsts)
SCpnt292drivers/scsi/scsi_debug.cif(bh) scsi_dump(SCpnt, 0);
SCpnt304drivers/scsi/scsi_debug.cprintk("(w%d)",SCpnt->request.nr_sectors);
SCpnt305drivers/scsi/scsi_debug.cif (SCpnt->use_sg){
SCpnt306drivers/scsi/scsi_debug.cif ((bufflen >> 9) != SCpnt->request.nr_sectors)
SCpnt314drivers/scsi/scsi_debug.cscsi_dump(SCpnt,1);
SCpnt322drivers/scsi/scsi_debug.cSCpnt->result =  DID_NO_CONNECT << 16;
SCpnt323drivers/scsi/scsi_debug.cdone(SCpnt);
SCpnt335drivers/scsi/scsi_debug.cSCint[i] = SCpnt;
SCpnt355drivers/scsi/scsi_debug.cSCpnt->result = scsi_debug_errsts;
SCpnt367drivers/scsi/scsi_debug.cstatic void internal_done(Scsi_Cmnd * SCpnt)
SCpnt369drivers/scsi/scsi_debug.cinternal_done_errcode = SCpnt->result;
SCpnt373drivers/scsi/scsi_debug.cint scsi_debug_command(Scsi_Cmnd * SCpnt)
SCpnt376drivers/scsi/scsi_debug.cscsi_debug_queuecommand(SCpnt, internal_done);
SCpnt462drivers/scsi/scsi_debug.cint scsi_debug_abort(Scsi_Cmnd * SCpnt,int i)
SCpnt467drivers/scsi/scsi_debug.cSCpnt->result = i << 16;
SCpnt469drivers/scsi/scsi_debug.cif(SCpnt == SCint[j]) {
SCpnt471drivers/scsi/scsi_debug.cmy_done(SCpnt);
SCpnt490drivers/scsi/scsi_debug.cint scsi_debug_reset(Scsi_Cmnd * SCpnt)
SCpnt73drivers/scsi/scsi_ioctl.cstatic void scsi_ioctl_done (Scsi_Cmnd * SCpnt)
SCpnt78drivers/scsi/scsi_ioctl.creq = &SCpnt->request;
SCpnt92drivers/scsi/scsi_ioctl.cScsi_Cmnd * SCpnt;
SCpnt94drivers/scsi/scsi_ioctl.cSCpnt = allocate_device(NULL, dev->index, 1);
SCpnt95drivers/scsi/scsi_ioctl.cscsi_do_cmd(SCpnt,  cmd, NULL,  0,
SCpnt99drivers/scsi/scsi_ioctl.cif (SCpnt->request.dev != 0xfffe){
SCpnt100drivers/scsi/scsi_ioctl.cSCpnt->request.waiting = current;
SCpnt102drivers/scsi/scsi_ioctl.cwhile (SCpnt->request.dev != 0xfffe) schedule();
SCpnt105drivers/scsi/scsi_ioctl.cif(driver_byte(SCpnt->result) != 0)
SCpnt106drivers/scsi/scsi_ioctl.cswitch(SCpnt->sense_buffer[2] & 0xf) {
SCpnt119drivers/scsi/scsi_ioctl.cSCpnt->result = 0; /* This is no longer considered an error */
SCpnt128drivers/scsi/scsi_ioctl.cSCpnt->result);
SCpnt130drivers/scsi/scsi_ioctl.csense_class(SCpnt->sense_buffer[0]),
SCpnt131drivers/scsi/scsi_ioctl.csense_error(SCpnt->sense_buffer[0]),
SCpnt132drivers/scsi/scsi_ioctl.cSCpnt->sense_buffer[2] & 0xf);
SCpnt136drivers/scsi/scsi_ioctl.cresult = SCpnt->result;
SCpnt137drivers/scsi/scsi_ioctl.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt138drivers/scsi/scsi_ioctl.cwake_up(&scsi_devices[SCpnt->index].device_wait);
SCpnt147drivers/scsi/scsi_ioctl.cScsi_Cmnd * SCpnt;
SCpnt178drivers/scsi/scsi_ioctl.cSCpnt = allocate_device(NULL, dev->index, 1);
SCpnt180drivers/scsi/scsi_ioctl.cscsi_do_cmd(SCpnt,  cmd,  buf, needed,  scsi_ioctl_done,  MAX_TIMEOUT, 
SCpnt183drivers/scsi/scsi_ioctl.cif (SCpnt->request.dev != 0xfffe){
SCpnt184drivers/scsi/scsi_ioctl.cSCpnt->request.waiting = current;
SCpnt186drivers/scsi/scsi_ioctl.cwhile (SCpnt->request.dev != 0xfffe) schedule();
SCpnt191drivers/scsi/scsi_ioctl.cif(SCpnt->result) {
SCpnt192drivers/scsi/scsi_ioctl.cresult = verify_area(VERIFY_WRITE, cmd_in, sizeof(SCpnt->sense_buffer));
SCpnt195drivers/scsi/scsi_ioctl.cmemcpy_tofs((void *) cmd_in,  SCpnt->sense_buffer, sizeof(SCpnt->sense_buffer));
SCpnt203drivers/scsi/scsi_ioctl.cresult = SCpnt->result;
SCpnt204drivers/scsi/scsi_ioctl.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt206drivers/scsi/scsi_ioctl.cwake_up(&scsi_devices[SCpnt->index].device_wait);
SCpnt54drivers/scsi/sd.cstatic void requeue_sd_request (Scsi_Cmnd * SCpnt);
SCpnt138drivers/scsi/sd.cstatic void rw_intr (Scsi_Cmnd *SCpnt)
SCpnt140drivers/scsi/sd.cint result = SCpnt->result;
SCpnt141drivers/scsi/sd.cint this_count = SCpnt->bufflen >> 9;
SCpnt144drivers/scsi/sd.cprintk("sd%d : rw_intr(%d, %d)\n", MINOR(SCpnt->request.dev), SCpnt->host->host_no, result);
SCpnt156drivers/scsi/sd.cprintk("sd%d : %d sectors remain.\n", MINOR(SCpnt->request.dev), SCpnt->request.nr_sectors);
SCpnt157drivers/scsi/sd.cprintk("use_sg is %d\n ",SCpnt->use_sg);
SCpnt159drivers/scsi/sd.cif (SCpnt->use_sg) {
SCpnt162drivers/scsi/sd.csgpnt = (struct scatterlist *) SCpnt->buffer;
SCpnt163drivers/scsi/sd.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt168drivers/scsi/sd.cif (SCpnt->request.cmd == READ)
SCpnt173drivers/scsi/sd.cscsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
SCpnt175drivers/scsi/sd.cif (SCpnt->buffer != SCpnt->request.buffer) {
SCpnt177drivers/scsi/sd.cprintk("nosg: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
SCpnt178drivers/scsi/sd.cSCpnt->bufflen);
SCpnt180drivers/scsi/sd.cif (SCpnt->request.cmd == READ)
SCpnt181drivers/scsi/sd.cmemcpy(SCpnt->request.buffer, SCpnt->buffer,
SCpnt182drivers/scsi/sd.cSCpnt->bufflen);
SCpnt183drivers/scsi/sd.cscsi_free(SCpnt->buffer, SCpnt->bufflen);
SCpnt191drivers/scsi/sd.cif (SCpnt->request.nr_sectors > this_count)
SCpnt193drivers/scsi/sd.cSCpnt->request.errors = 0;
SCpnt195drivers/scsi/sd.cif (!SCpnt->request.bh)
SCpnt199drivers/scsi/sd.cMINOR(SCpnt->request.dev));
SCpnt206drivers/scsi/sd.cSCpnt->request.sector, this_count);
SCpnt209drivers/scsi/sd.cend_scsi_request(SCpnt, 1, this_count);
SCpnt210drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt215drivers/scsi/sd.cif (SCpnt->use_sg) {
SCpnt218drivers/scsi/sd.csgpnt = (struct scatterlist *) SCpnt->buffer;
SCpnt219drivers/scsi/sd.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt221drivers/scsi/sd.cprintk("err: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
SCpnt222drivers/scsi/sd.cSCpnt->bufflen);
SCpnt228drivers/scsi/sd.cscsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
SCpnt231drivers/scsi/sd.cprintk("nosgerr: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
SCpnt232drivers/scsi/sd.cSCpnt->bufflen);
SCpnt234drivers/scsi/sd.cif (SCpnt->buffer != SCpnt->request.buffer)
SCpnt235drivers/scsi/sd.cscsi_free(SCpnt->buffer, SCpnt->bufflen);
SCpnt251drivers/scsi/sd.cif rscsi_disks[DEVICE_NR(SCpnt->request.dev)].remap
SCpnt260drivers/scsi/sd.cif ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
SCpnt261drivers/scsi/sd.cif ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
SCpnt262drivers/scsi/sd.cif(rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->removable) {
SCpnt266drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
SCpnt267drivers/scsi/sd.cend_scsi_request(SCpnt, 0, this_count);
SCpnt268drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt282drivers/scsi/sd.cif (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
SCpnt283drivers/scsi/sd.cif (rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten) {
SCpnt284drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten = 0;
SCpnt285drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt293drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->host->host_no,
SCpnt294drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->id,
SCpnt295drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->lun, result);
SCpnt298drivers/scsi/sd.cprint_sense("sd", SCpnt);
SCpnt299drivers/scsi/sd.cend_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
SCpnt300drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt313drivers/scsi/sd.cScsi_Cmnd * SCpnt = NULL;
SCpnt338drivers/scsi/sd.cSCpnt = allocate_device(&CURRENT,
SCpnt340drivers/scsi/sd.celse SCpnt = NULL;
SCpnt350drivers/scsi/sd.cif (!SCpnt && NR_SD > 1){
SCpnt356drivers/scsi/sd.cSCpnt = request_queueable(req,
SCpnt358drivers/scsi/sd.cif(SCpnt) break;
SCpnt362drivers/scsi/sd.cif (SCpnt && req->dev == -1) {
SCpnt371drivers/scsi/sd.cif (!SCpnt) return; /* Could not find anything to do */
SCpnt376drivers/scsi/sd.crequeue_sd_request(SCpnt);
SCpnt380drivers/scsi/sd.cstatic void requeue_sd_request (Scsi_Cmnd * SCpnt)
SCpnt388drivers/scsi/sd.cif(SCpnt->request.dev <= 0) {
SCpnt393drivers/scsi/sd.cdev =  MINOR(SCpnt->request.dev);
SCpnt394drivers/scsi/sd.cblock = SCpnt->request.sector;
SCpnt401drivers/scsi/sd.cif (dev >= (NR_SD << 4) || block + SCpnt->request.nr_sectors > sd[dev].nr_sects)
SCpnt403drivers/scsi/sd.cend_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt416drivers/scsi/sd.cend_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt421drivers/scsi/sd.cprintk("sd%d : real dev = /dev/sd%d, block = %d\n", MINOR(SCpnt->request.dev), dev, block);
SCpnt424drivers/scsi/sd.cswitch (SCpnt->request.cmd)
SCpnt429drivers/scsi/sd.cend_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt438drivers/scsi/sd.cpanic ("Unknown sd command %d\n", SCpnt->request.cmd);
SCpnt441drivers/scsi/sd.cSCpnt->this_count = 0;
SCpnt443drivers/scsi/sd.cif (!SCpnt->request.bh || 
SCpnt444drivers/scsi/sd.c(SCpnt->request.nr_sectors == SCpnt->request.current_nr_sectors)) {
SCpnt447drivers/scsi/sd.cthis_count = SCpnt->request.nr_sectors;
SCpnt448drivers/scsi/sd.cbuff = SCpnt->request.buffer;
SCpnt449drivers/scsi/sd.cSCpnt->use_sg = 0;
SCpnt451drivers/scsi/sd.c} else if (SCpnt->host->sg_tablesize == 0 ||
SCpnt462drivers/scsi/sd.cif (SCpnt->host->sg_tablesize != 0 &&
SCpnt467drivers/scsi/sd.cthis_count = SCpnt->request.current_nr_sectors;
SCpnt468drivers/scsi/sd.cbuff = SCpnt->request.buffer;
SCpnt469drivers/scsi/sd.cSCpnt->use_sg = 0;
SCpnt477drivers/scsi/sd.cbh = SCpnt->request.bh;
SCpnt481drivers/scsi/sd.cwhile(bh && count < SCpnt->host->sg_tablesize) {
SCpnt487drivers/scsi/sd.cSCpnt->use_sg = count;  /* Number of chains */
SCpnt489drivers/scsi/sd.cwhile( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
SCpnt491drivers/scsi/sd.cSCpnt->sglist_len = count;
SCpnt495drivers/scsi/sd.cSCpnt->use_sg = 0;  /* No memory left - bail out */
SCpnt496drivers/scsi/sd.cthis_count = SCpnt->request.current_nr_sectors;
SCpnt497drivers/scsi/sd.cbuff = SCpnt->request.buffer;
SCpnt501drivers/scsi/sd.cbh = SCpnt->request.bh;
SCpnt502drivers/scsi/sd.cfor(count = 0, bh = SCpnt->request.bh; count < SCpnt->use_sg; 
SCpnt508drivers/scsi/sd.cISA_DMA_THRESHOLD & (SCpnt->host->unchecked_isa_dma)) {
SCpnt529drivers/scsi/sd.cthis_count = SCpnt->request.current_nr_sectors;
SCpnt530drivers/scsi/sd.cbuff = SCpnt->request.buffer;
SCpnt531drivers/scsi/sd.cSCpnt->use_sg = 0;
SCpnt532drivers/scsi/sd.cscsi_free(buff, SCpnt->sglist_len);
SCpnt536drivers/scsi/sd.cif (SCpnt->request.cmd == WRITE)
SCpnt546drivers/scsi/sd.cif(SCpnt->use_sg == 0){
SCpnt548drivers/scsi/sd.c(SCpnt->host->unchecked_isa_dma)) {
SCpnt551drivers/scsi/sd.cif (SCpnt->request.cmd == WRITE)
SCpnt552drivers/scsi/sd.cmemcpy(buff, (char *)SCpnt->request.buffer, this_count << 9);
SCpnt557drivers/scsi/sd.cprintk("sd%d : %s %d/%d 512 byte blocks.\n", MINOR(SCpnt->request.dev),
SCpnt558drivers/scsi/sd.c(SCpnt->request.cmd == WRITE) ? "writing" : "reading",
SCpnt559drivers/scsi/sd.cthis_count, SCpnt->request.nr_sectors);
SCpnt562drivers/scsi/sd.ccmd[1] = (SCpnt->lun << 5) & 0xe0;
SCpnt608drivers/scsi/sd.cSCpnt->transfersize = rscsi_disks[dev].sector_size;
SCpnt609drivers/scsi/sd.cSCpnt->underflow = this_count << 9; 
SCpnt611drivers/scsi/sd.cscsi_do_cmd (SCpnt, (void *) cmd, buff, 
SCpnt648drivers/scsi/sd.cstatic void sd_init_done (Scsi_Cmnd * SCpnt)
SCpnt653drivers/scsi/sd.creq = &SCpnt->request;
SCpnt671drivers/scsi/sd.cScsi_Cmnd * SCpnt;
SCpnt677drivers/scsi/sd.cSCpnt = allocate_device(NULL, rscsi_disks[i].device->index, 1);
SCpnt688drivers/scsi/sd.cSCpnt->request.dev = 0xffff;  /* Mark as really busy again */
SCpnt689drivers/scsi/sd.cSCpnt->sense_buffer[0] = 0;
SCpnt690drivers/scsi/sd.cSCpnt->sense_buffer[2] = 0;
SCpnt692drivers/scsi/sd.cscsi_do_cmd (SCpnt,
SCpnt697drivers/scsi/sd.cwhile(SCpnt->request.dev != 0xfffe);
SCpnt699drivers/scsi/sd.cthe_result = SCpnt->result;
SCpnt704drivers/scsi/sd.cSCpnt->sense_buffer[2] == NOT_READY) {
SCpnt713drivers/scsi/sd.cSCpnt->request.dev = 0xffff;  /* Mark as really busy again */
SCpnt714drivers/scsi/sd.cSCpnt->sense_buffer[0] = 0;
SCpnt715drivers/scsi/sd.cSCpnt->sense_buffer[2] = 0;
SCpnt717drivers/scsi/sd.cscsi_do_cmd (SCpnt,
SCpnt722drivers/scsi/sd.cwhile(SCpnt->request.dev != 0xfffe);
SCpnt747drivers/scsi/sd.cSCpnt->request.dev = 0xffff;  /* Mark as really busy again */
SCpnt748drivers/scsi/sd.cSCpnt->sense_buffer[0] = 0;
SCpnt749drivers/scsi/sd.cSCpnt->sense_buffer[2] = 0;
SCpnt751drivers/scsi/sd.cscsi_do_cmd (SCpnt,
SCpnt757drivers/scsi/sd.cwhile(SCpnt->request.dev != 0xfffe);
SCpnt759drivers/scsi/sd.cif (SCpnt->request.dev != 0xfffe){
SCpnt760drivers/scsi/sd.cSCpnt->request.waiting = current;
SCpnt762drivers/scsi/sd.cwhile (SCpnt->request.dev != 0xfffe) schedule();
SCpnt765drivers/scsi/sd.cthe_result = SCpnt->result;
SCpnt770drivers/scsi/sd.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt772drivers/scsi/sd.cwake_up(&scsi_devices[SCpnt->index].device_wait); 
SCpnt800drivers/scsi/sd.cprintk("sd%d : extended sense code = %1x \n", i, SCpnt->sense_buffer[2] & 0xf);
SCpnt811drivers/scsi/sd.cSCpnt->sense_buffer[2] == NOT_READY)
SCpnt514drivers/scsi/seagate.cint seagate_st0x_queue_command (Scsi_Cmnd * SCpnt,  void (*done)(Scsi_Cmnd *))
SCpnt520drivers/scsi/seagate.ccurrent_target = SCpnt->target;
SCpnt521drivers/scsi/seagate.ccurrent_lun = SCpnt->lun;
SCpnt522drivers/scsi/seagate.c(const void *) current_cmnd = SCpnt->cmnd;
SCpnt523drivers/scsi/seagate.ccurrent_data = (unsigned char *) SCpnt->request_buffer;
SCpnt524drivers/scsi/seagate.ccurrent_bufflen = SCpnt->request_bufflen;
SCpnt525drivers/scsi/seagate.cSCint = SCpnt;
SCpnt575drivers/scsi/seagate.cint seagate_st0x_command (Scsi_Cmnd * SCpnt) {
SCpnt576drivers/scsi/seagate.creturn internal_command (SCpnt->target, SCpnt->lun, SCpnt->cmnd, SCpnt->request_buffer,
SCpnt577drivers/scsi/seagate.cSCpnt->request_bufflen, 
SCpnt1549drivers/scsi/seagate.cint seagate_st0x_abort (Scsi_Cmnd * SCpnt, int code)
SCpnt1563drivers/scsi/seagate.cint seagate_st0x_reset (Scsi_Cmnd * SCpnt)
SCpnt1593drivers/scsi/seagate.cif(SCpnt) SCpnt->flags |= NEEDS_JUMPSTART;
SCpnt186drivers/scsi/sg.cstatic void sg_command_done(Scsi_Cmnd * SCpnt)
SCpnt188drivers/scsi/sg.cint dev=SCpnt->request.dev;
SCpnt193drivers/scsi/sg.cSCpnt->request.dev=-1;
SCpnt196drivers/scsi/sg.cif (SCpnt->sense_buffer[0])
SCpnt201drivers/scsi/sg.cdevice->header.result=SCpnt->result;
SCpnt203drivers/scsi/sg.cSCpnt->request.dev=-1;
SCpnt210drivers/scsi/sg.cScsi_Cmnd *SCpnt;
SCpnt251drivers/scsi/sg.cif (!(SCpnt=allocate_device(NULL,device->device->index, !(filp->f_flags & O_NONBLOCK))))
SCpnt262drivers/scsi/sg.cSCpnt->request.dev=dev;
SCpnt263drivers/scsi/sg.cSCpnt->sense_buffer[0]=0;
SCpnt272drivers/scsi/sg.cscsi_do_cmd (SCpnt,(void *) cmnd,
SCpnt46drivers/scsi/sr.cvoid requeue_sr_request (Scsi_Cmnd * SCpnt);
SCpnt118drivers/scsi/sr.cstatic void rw_intr (Scsi_Cmnd * SCpnt)
SCpnt120drivers/scsi/sr.cint result = SCpnt->result;
SCpnt121drivers/scsi/sr.cint this_count = SCpnt->this_count;
SCpnt124drivers/scsi/sr.cprintk("sr.c done: %x %x\n",result, SCpnt->request.bh->b_data);
SCpnt128drivers/scsi/sr.cif (SCpnt->use_sg == 0) {
SCpnt129drivers/scsi/sr.cif (SCpnt->buffer != SCpnt->request.buffer)
SCpnt132drivers/scsi/sr.coffset = (SCpnt->request.sector % 4) << 9;
SCpnt133drivers/scsi/sr.cmemcpy((char *)SCpnt->request.buffer, 
SCpnt134drivers/scsi/sr.c(char *)SCpnt->buffer + offset, 
SCpnt141drivers/scsi/sr.cSCpnt->request.nr_sectors > this_count && 
SCpnt142drivers/scsi/sr.cSCpnt->request.bh &&
SCpnt143drivers/scsi/sr.cSCpnt->request.bh->b_reqnext &&
SCpnt144drivers/scsi/sr.cSCpnt->request.bh->b_reqnext->b_size == 1024) {
SCpnt145drivers/scsi/sr.cmemcpy((char *)SCpnt->request.bh->b_reqnext->b_data, 
SCpnt146drivers/scsi/sr.c(char *)SCpnt->buffer + 1024, 
SCpnt151drivers/scsi/sr.cscsi_free(SCpnt->buffer, 2048);
SCpnt156drivers/scsi/sr.csgpnt = (struct scatterlist *) SCpnt->buffer;
SCpnt157drivers/scsi/sr.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt165drivers/scsi/sr.cscsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
SCpnt166drivers/scsi/sr.cif(SCpnt->request.sector % 4) this_count -= 2;
SCpnt168drivers/scsi/sr.cif(this_count > SCpnt->request.nr_sectors)
SCpnt173drivers/scsi/sr.cprintk("(%x %x %x) ",SCpnt->request.bh, SCpnt->request.nr_sectors, 
SCpnt176drivers/scsi/sr.cif (SCpnt->request.nr_sectors > this_count)
SCpnt178drivers/scsi/sr.cSCpnt->request.errors = 0;
SCpnt179drivers/scsi/sr.cif (!SCpnt->request.bh)
SCpnt181drivers/scsi/sr.cSCpnt->request.sector, this_count);
SCpnt184drivers/scsi/sr.cend_scsi_request(SCpnt, 1, this_count);  /* All done */
SCpnt185drivers/scsi/sr.crequeue_sr_request(SCpnt);
SCpnt192drivers/scsi/sr.cif (SCpnt->use_sg) {
SCpnt195drivers/scsi/sr.csgpnt = (struct scatterlist *) SCpnt->buffer;
SCpnt196drivers/scsi/sr.cfor(i=0; i<SCpnt->use_sg; i++) {
SCpnt201drivers/scsi/sr.cscsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
SCpnt203drivers/scsi/sr.cif (SCpnt->buffer != SCpnt->request.buffer)
SCpnt204drivers/scsi/sr.cscsi_free(SCpnt->buffer, SCpnt->bufflen);
SCpnt208drivers/scsi/sr.cif ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
SCpnt209drivers/scsi/sr.cif ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
SCpnt213drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
SCpnt214drivers/scsi/sr.cend_scsi_request(SCpnt, 0, this_count);
SCpnt215drivers/scsi/sr.crequeue_sr_request(SCpnt);
SCpnt220drivers/scsi/sr.cif (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
SCpnt222drivers/scsi/sr.cif (scsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten) {
SCpnt223drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten = 0;
SCpnt224drivers/scsi/sr.crequeue_sr_request(SCpnt);
SCpnt228drivers/scsi/sr.cprintk("CD-ROM error: Drive reports %d.\n", SCpnt->sense_buffer[2]);        
SCpnt229drivers/scsi/sr.cend_scsi_request(SCpnt, 0, this_count);
SCpnt230drivers/scsi/sr.crequeue_sr_request(SCpnt); /* Do next request */
SCpnt236drivers/scsi/sr.cif (SCpnt->sense_buffer[2] == NOT_READY) {
SCpnt238drivers/scsi/sr.cend_scsi_request(SCpnt, 0, this_count);
SCpnt239drivers/scsi/sr.crequeue_sr_request(SCpnt); /* Do next request */
SCpnt247drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->host->host_no, 
SCpnt248drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->id,
SCpnt249drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->lun,
SCpnt253drivers/scsi/sr.cprint_sense("sr", SCpnt);
SCpnt255drivers/scsi/sr.cend_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
SCpnt256drivers/scsi/sr.crequeue_sr_request(SCpnt);
SCpnt289drivers/scsi/sr.cScsi_Cmnd * SCpnt = NULL;
SCpnt303drivers/scsi/sr.cSCpnt = allocate_device(&CURRENT,
SCpnt305drivers/scsi/sr.celse SCpnt = NULL;
SCpnt315drivers/scsi/sr.cif (!SCpnt && NR_SR > 1){
SCpnt321drivers/scsi/sr.cSCpnt = request_queueable(req,
SCpnt323drivers/scsi/sr.cif(SCpnt) break;
SCpnt327drivers/scsi/sr.cif (SCpnt && req->dev == -1) {
SCpnt336drivers/scsi/sr.cif (!SCpnt)
SCpnt342drivers/scsi/sr.crequeue_sr_request(SCpnt);
SCpnt346drivers/scsi/sr.cvoid requeue_sr_request (Scsi_Cmnd * SCpnt)
SCpnt355drivers/scsi/sr.cif(SCpnt->request.dev <= 0) {
SCpnt360drivers/scsi/sr.cdev =  MINOR(SCpnt->request.dev);
SCpnt361drivers/scsi/sr.cblock = SCpnt->request.sector;  
SCpnt368drivers/scsi/sr.cend_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt376drivers/scsi/sr.cend_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt387drivers/scsi/sr.cend_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt392drivers/scsi/sr.cswitch (SCpnt->request.cmd)
SCpnt395drivers/scsi/sr.cend_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
SCpnt402drivers/scsi/sr.cpanic ("Unknown sr command %d\n", SCpnt->request.cmd);
SCpnt405drivers/scsi/sr.ccmd[1] = (SCpnt->lun << 5) & 0xe0;
SCpnt423drivers/scsi/sr.cSCpnt->use_sg = 0;
SCpnt425drivers/scsi/sr.cif (SCpnt->host->sg_tablesize > 0 &&
SCpnt431drivers/scsi/sr.cbh = SCpnt->request.bh;
SCpnt437drivers/scsi/sr.cthis_count = SCpnt->request.sector % 4;
SCpnt439drivers/scsi/sr.cwhile(bh && count < SCpnt->host->sg_tablesize) {
SCpnt448drivers/scsi/sr.cif (count < SCpnt->host->sg_tablesize) {
SCpnt457drivers/scsi/sr.cSCpnt->use_sg = count;  /* Number of chains */
SCpnt459drivers/scsi/sr.cwhile( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
SCpnt461drivers/scsi/sr.cSCpnt->sglist_len = count;
SCpnt465drivers/scsi/sr.cSCpnt->use_sg = 0;  /* No memory left - bail out */
SCpnt469drivers/scsi/sr.cbh = SCpnt->request.bh;
SCpnt470drivers/scsi/sr.cif(SCpnt->request.sector % 4) {
SCpnt471drivers/scsi/sr.csgpnt[count].length = (SCpnt->request.sector % 4) << 9;
SCpnt478drivers/scsi/sr.cfor(bh = SCpnt->request.bh; count < SCpnt->use_sg; 
SCpnt489drivers/scsi/sr.cif (count+1 != SCpnt->use_sg) panic("Bad sr request list");
SCpnt493drivers/scsi/sr.cISA_DMA_THRESHOLD & (SCpnt->host->unchecked_isa_dma)) {
SCpnt514drivers/scsi/sr.cSCpnt->use_sg = 0;
SCpnt515drivers/scsi/sr.cscsi_free(buffer, SCpnt->sglist_len);
SCpnt521drivers/scsi/sr.cprintk("SG: %d %d %d %d %d *** ",SCpnt->use_sg, SCpnt->request.sector,
SCpnt523drivers/scsi/sr.cSCpnt->request.current_nr_sectors,
SCpnt524drivers/scsi/sr.cSCpnt->request.nr_sectors);
SCpnt525drivers/scsi/sr.cfor(count=0; count<SCpnt->use_sg; count++)
SCpnt534drivers/scsi/sr.cif (SCpnt->use_sg == 0){
SCpnt536drivers/scsi/sr.cif (!SCpnt->request.bh)    
SCpnt537drivers/scsi/sr.cthis_count = SCpnt->request.nr_sectors;
SCpnt539drivers/scsi/sr.cthis_count = (SCpnt->request.bh->b_size >> 9);
SCpnt555drivers/scsi/sr.cbuffer = (unsigned char *) SCpnt->request.buffer;
SCpnt557drivers/scsi/sr.c(SCpnt->host->unchecked_isa_dma))
SCpnt607drivers/scsi/sr.cprintk("Use sg: %d\n", SCpnt->use_sg);
SCpnt614drivers/scsi/sr.cSCpnt->this_count = this_count;
SCpnt615drivers/scsi/sr.cscsi_do_cmd (SCpnt, (void *) cmd, buffer, 
SCpnt631drivers/scsi/sr.cstatic void sr_init_done (Scsi_Cmnd * SCpnt)
SCpnt636drivers/scsi/sr.creq = &SCpnt->request;
SCpnt651drivers/scsi/sr.cScsi_Cmnd * SCpnt;
SCpnt653drivers/scsi/sr.cSCpnt = allocate_device(NULL, scsi_CDs[i].device->index, 1);
SCpnt660drivers/scsi/sr.cSCpnt->request.dev = 0xffff;  /* Mark as really busy */
SCpnt664drivers/scsi/sr.cscsi_do_cmd (SCpnt,
SCpnt670drivers/scsi/sr.cwhile(SCpnt->request.dev != 0xfffe);
SCpnt672drivers/scsi/sr.cif (SCpnt->request.dev != 0xfffe){
SCpnt673drivers/scsi/sr.cSCpnt->request.waiting = current;
SCpnt675drivers/scsi/sr.cwhile (SCpnt->request.dev != 0xfffe) schedule();
SCpnt678drivers/scsi/sr.cthe_result = SCpnt->result;
SCpnt683drivers/scsi/sr.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt685drivers/scsi/sr.cwake_up(&scsi_devices[SCpnt->index].device_wait); 
SCpnt21drivers/scsi/sr_ioctl.cstatic void sr_ioctl_done(Scsi_Cmnd * SCpnt)
SCpnt26drivers/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->index, 1);
SCpnt47drivers/scsi/sr_ioctl.cscsi_do_cmd(SCpnt,
SCpnt52drivers/scsi/sr_ioctl.cif (SCpnt->request.dev != 0xfffe){
SCpnt53drivers/scsi/sr_ioctl.cSCpnt->request.waiting = current;
SCpnt55drivers/scsi/sr_ioctl.cwhile (SCpnt->request.dev != 0xfffe) schedule();
SCpnt58drivers/scsi/sr_ioctl.cresult = SCpnt->result;
SCpnt62drivers/scsi/sr_ioctl.cswitch(SCpnt->sense_buffer[2] & 0xf) {
SCpnt80drivers/scsi/sr_ioctl.csense_class(SCpnt->sense_buffer[0]), 
SCpnt81drivers/scsi/sr_ioctl.csense_error(SCpnt->sense_buffer[0]),
SCpnt82drivers/scsi/sr_ioctl.cSCpnt->sense_buffer[2] & 0xf);
SCpnt86drivers/scsi/sr_ioctl.cresult = SCpnt->result;
SCpnt87drivers/scsi/sr_ioctl.cSCpnt->request.dev = -1; /* Deallocate */
SCpnt88drivers/scsi/sr_ioctl.cwake_up(&scsi_devices[SCpnt->index].device_wait);
SCpnt121drivers/scsi/st.cst_chk_result(Scsi_Cmnd * SCpnt)
SCpnt123drivers/scsi/st.cint dev = SCpnt->request.dev;
SCpnt124drivers/scsi/st.cint result = SCpnt->result;
SCpnt125drivers/scsi/st.cunsigned char * sense = SCpnt->sense_buffer;
SCpnt128drivers/scsi/st.cif (!result && SCpnt->sense_buffer[0] == 0)
SCpnt132drivers/scsi/st.cprint_sense("st", SCpnt);
SCpnt140drivers/scsi/st.c&& SCpnt->cmnd[0] != WRITE_6
SCpnt141drivers/scsi/st.c&& SCpnt->cmnd[0] != WRITE_FILEMARKS
SCpnt145drivers/scsi/st.cif (SCpnt->cmnd[0] == READ_6)
SCpnt147drivers/scsi/st.celse if (SCpnt->cmnd[0] == WRITE_6)
SCpnt161drivers/scsi/st.cst_sleep_done (Scsi_Cmnd * SCpnt)
SCpnt166drivers/scsi/st.cif ((st_nbr = SCpnt->request.dev) < NR_ST && st_nbr >= 0) {
SCpnt169drivers/scsi/st.c(SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
SCpnt170drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x40)) {
SCpnt172drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x80) != 0)
SCpnt173drivers/scsi/st.cremainder = (SCpnt->sense_buffer[3] << 24) |
SCpnt174drivers/scsi/st.c(SCpnt->sense_buffer[4] << 16) |
SCpnt175drivers/scsi/st.c(SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
SCpnt178drivers/scsi/st.cif ((SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW ||
SCpnt180drivers/scsi/st.c(STp->buffer)->last_result = SCpnt->result; /* Error */
SCpnt185drivers/scsi/st.c(STp->buffer)->last_result = SCpnt->result;
SCpnt186drivers/scsi/st.c(STp->buffer)->last_result_fatal = st_chk_result(SCpnt);
SCpnt188drivers/scsi/st.cSCpnt->request.dev = -1;
SCpnt190drivers/scsi/st.cSCpnt->request.dev = 0xffff;
SCpnt239drivers/scsi/st.cScsi_Cmnd *SCpnt;
SCpnt259drivers/scsi/st.cSCpnt = allocate_device(NULL, (STp->device)->index, 1);
SCpnt269drivers/scsi/st.cSCpnt->sense_buffer[0] = 0;
SCpnt277drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt278drivers/scsi/st.cscsi_do_cmd (SCpnt,
SCpnt282drivers/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
SCpnt286drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
SCpnt287drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x40) &&
SCpnt288drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) != VOLUME_OVERFLOW) {
SCpnt300drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt357drivers/scsi/st.cScsi_Cmnd * SCpnt;
SCpnt391drivers/scsi/st.cSCpnt = allocate_device(NULL, (STp->device)->index, 1);
SCpnt392drivers/scsi/st.cif (!SCpnt) {
SCpnt397drivers/scsi/st.cSCpnt->sense_buffer[0]=0;
SCpnt400drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt401drivers/scsi/st.cscsi_do_cmd(SCpnt,
SCpnt406drivers/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
SCpnt408drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
SCpnt409drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) == UNIT_ATTENTION) { /* New media? */
SCpnt410drivers/scsi/st.cSCpnt->sense_buffer[0]=0;
SCpnt413drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt414drivers/scsi/st.cscsi_do_cmd(SCpnt,
SCpnt419drivers/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
SCpnt423drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
SCpnt424drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) == NO_TAPE)
SCpnt427drivers/scsi/st.cprintk("st%d: Error %x.\n", dev, SCpnt->result);
SCpnt430drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt434drivers/scsi/st.cSCpnt->sense_buffer[0]=0;
SCpnt437drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt438drivers/scsi/st.cscsi_do_cmd(SCpnt,
SCpnt442drivers/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
SCpnt444drivers/scsi/st.cif (!SCpnt->result && !SCpnt->sense_buffer[0]) {
SCpnt461drivers/scsi/st.cSCpnt->sense_buffer[0]=0;
SCpnt465drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt466drivers/scsi/st.cscsi_do_cmd(SCpnt,
SCpnt470drivers/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
SCpnt479drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt547drivers/scsi/st.cScsi_Cmnd * SCpnt;
SCpnt564drivers/scsi/st.cSCpnt = allocate_device(NULL, (STp->device)->index, 1);
SCpnt566drivers/scsi/st.cSCpnt->sense_buffer[0] = 0;
SCpnt570drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt571drivers/scsi/st.cscsi_do_cmd( SCpnt,
SCpnt575drivers/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
SCpnt580drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt615drivers/scsi/st.cScsi_Cmnd * SCpnt;
SCpnt672drivers/scsi/st.cSCpnt = allocate_device(NULL, (STp->device)->index, 1);
SCpnt712drivers/scsi/st.cSCpnt->sense_buffer[0] = 0;
SCpnt713drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt714drivers/scsi/st.cscsi_do_cmd (SCpnt,
SCpnt719drivers/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
SCpnt725drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
SCpnt726drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x40)) {
SCpnt727drivers/scsi/st.cif (STp->block_size != 0 && (SCpnt->sense_buffer[0] & 0x80) != 0)
SCpnt728drivers/scsi/st.ctransfer = (SCpnt->sense_buffer[3] << 24) |
SCpnt729drivers/scsi/st.c(SCpnt->sense_buffer[4] << 16) |
SCpnt730drivers/scsi/st.c(SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
SCpnt732drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW)
SCpnt759drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt783drivers/scsi/st.cSCpnt->request.dev = -1;
SCpnt805drivers/scsi/st.cSCpnt->result = (STp->buffer)->last_result = -1;
SCpnt806drivers/scsi/st.cSCpnt->sense_buffer[0] = 0;
SCpnt807drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt808drivers/scsi/st.cscsi_do_cmd (SCpnt,
SCpnt815drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt829drivers/scsi/st.cScsi_Cmnd * SCpnt;
SCpnt862drivers/scsi/st.cSCpnt = allocate_device(NULL, (STp->device)->index, 1);
SCpnt882drivers/scsi/st.cSCpnt->sense_buffer[0] = 0;
SCpnt883drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt884drivers/scsi/st.cscsi_do_cmd (SCpnt,
SCpnt889drivers/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
SCpnt897drivers/scsi/st.cSCpnt->sense_buffer[0], SCpnt->sense_buffer[1],
SCpnt898drivers/scsi/st.cSCpnt->sense_buffer[2], SCpnt->sense_buffer[3],
SCpnt899drivers/scsi/st.cSCpnt->sense_buffer[4], SCpnt->sense_buffer[5],
SCpnt900drivers/scsi/st.cSCpnt->sense_buffer[6], SCpnt->sense_buffer[7]);
SCpnt902drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x70) == 0x70) { /* extended sense */
SCpnt904drivers/scsi/st.cif ((SCpnt->sense_buffer[2] & 0xe0) != 0) { /* EOF, EOM, or ILI */
SCpnt906drivers/scsi/st.cif ((SCpnt->sense_buffer[0] & 0x80) != 0)
SCpnt907drivers/scsi/st.ctransfer = (SCpnt->sense_buffer[3] << 24) |
SCpnt908drivers/scsi/st.c(SCpnt->sense_buffer[4] << 16) |
SCpnt909drivers/scsi/st.c(SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
SCpnt913drivers/scsi/st.c(SCpnt->sense_buffer[2] & 0x0f) == MEDIUM_ERROR)
SCpnt916drivers/scsi/st.cif (SCpnt->sense_buffer[2] & 0x20) {
SCpnt924drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt928drivers/scsi/st.celse if (SCpnt->sense_buffer[2] & 0x40) {
SCpnt941drivers/scsi/st.celse if (SCpnt->sense_buffer[2] & 0x80) {
SCpnt960drivers/scsi/st.cSCpnt->request.dev = -1;
SCpnt969drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt997drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt1010drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt1026drivers/scsi/st.cScsi_Cmnd * SCpnt;
SCpnt1229drivers/scsi/st.cSCpnt = allocate_device(NULL, (STp->device)->index, 1);
SCpnt1230drivers/scsi/st.cSCpnt->sense_buffer[0] = 0;
SCpnt1231drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt1232drivers/scsi/st.cscsi_do_cmd(SCpnt,
SCpnt1236drivers/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
SCpnt1240drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt1291drivers/scsi/st.cScsi_Cmnd *SCpnt;
SCpnt1350drivers/scsi/st.cSCpnt = allocate_device(NULL, (STp->device)->index, 1);
SCpnt1352drivers/scsi/st.cSCpnt->sense_buffer[0]=0;
SCpnt1362drivers/scsi/st.cSCpnt->request.dev = dev;
SCpnt1363drivers/scsi/st.cSCpnt->sense_buffer[0] = 0;
SCpnt1364drivers/scsi/st.cscsi_do_cmd(SCpnt,
SCpnt1368drivers/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
SCpnt1391drivers/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
SCpnt42drivers/scsi/st.hScsi_Cmnd SCpnt;
SCpnt279drivers/scsi/ultrastor.cstatic inline void build_sg_list(struct mscp *, Scsi_Cmnd *SCpnt);
SCpnt626drivers/scsi/ultrastor.cstatic inline void build_sg_list(register struct mscp *mscp, Scsi_Cmnd *SCpnt)
SCpnt632drivers/scsi/ultrastor.csl = (struct scatterlist *) SCpnt->request_buffer;
SCpnt633drivers/scsi/ultrastor.cmax = SCpnt->use_sg;
SCpnt647drivers/scsi/ultrastor.cint ultrastor_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt685drivers/scsi/ultrastor.cmy_mscp->ca = scsi_devices[SCpnt->index].type != TYPE_TAPE;
SCpnt686drivers/scsi/ultrastor.cmy_mscp->target_id = SCpnt->target;
SCpnt688drivers/scsi/ultrastor.cmy_mscp->lun = SCpnt->lun;
SCpnt689drivers/scsi/ultrastor.cif (SCpnt->use_sg) {
SCpnt692drivers/scsi/ultrastor.cbuild_sg_list(my_mscp, SCpnt);
SCpnt696drivers/scsi/ultrastor.cmy_mscp->transfer_data = (unsigned int)SCpnt->request_buffer;
SCpnt697drivers/scsi/ultrastor.cmy_mscp->transfer_data_length = SCpnt->request_bufflen;
SCpnt701drivers/scsi/ultrastor.cmy_mscp->length_of_sense_byte = sizeof SCpnt->sense_buffer;
SCpnt702drivers/scsi/ultrastor.cmy_mscp->length_of_scsi_cdbs = COMMAND_SIZE(*(unsigned char *)SCpnt->cmnd);
SCpnt703drivers/scsi/ultrastor.cmemcpy(my_mscp->scsi_cdbs, SCpnt->cmnd, my_mscp->length_of_scsi_cdbs);
SCpnt706drivers/scsi/ultrastor.cmy_mscp->sense_data = (unsigned int)&SCpnt->sense_buffer;
SCpnt708drivers/scsi/ultrastor.cmy_mscp->SCint = SCpnt;
SCpnt709drivers/scsi/ultrastor.cSCpnt->host_scribble = (unsigned char *)my_mscp;
SCpnt755drivers/scsi/ultrastor.cSCpnt->result = status;
SCpnt756drivers/scsi/ultrastor.cdone(SCpnt);
SCpnt799drivers/scsi/ultrastor.cint ultrastor_abort(Scsi_Cmnd *SCpnt, int code)
SCpnt812drivers/scsi/ultrastor.cmscp_index = ((struct mscp *)SCpnt->host_scribble) - config.mscp;
SCpnt895drivers/scsi/ultrastor.cif (config.mscp[mscp_index].SCint != SCpnt)
SCpnt897drivers/scsi/ultrastor.cconfig.mscp[mscp_index].SCint, SCpnt);
SCpnt902drivers/scsi/ultrastor.cif (config.mscp[mscp_index].SCint != SCpnt) panic("Bad abort");
SCpnt906drivers/scsi/ultrastor.cSCpnt->result = DID_ABORT << 16;
SCpnt908drivers/scsi/ultrastor.cdone(SCpnt);
SCpnt915drivers/scsi/ultrastor.cint ultrastor_reset(Scsi_Cmnd * SCpnt)
SCpnt924drivers/scsi/ultrastor.cif (SCpnt) SCpnt->flags |= NEEDS_JUMPSTART;
SCpnt285drivers/scsi/wd7000.cstatic void wd7000_scsi_done(Scsi_Cmnd * SCpnt)
SCpnt287drivers/scsi/wd7000.cDEB(printk("wd7000_scsi_done: %06x\n",SCpnt);)
SCpnt288drivers/scsi/wd7000.cSCpnt->SCp.phase = 0;
SCpnt298drivers/scsi/wd7000.cScsi_Cmnd *SCpnt;
SCpnt328drivers/scsi/wd7000.cSCpnt = scb->SCpnt;
SCpnt329drivers/scsi/wd7000.cif (--(SCpnt->SCp.phase) <= 0)  {  /* all scbs for SCpnt are done */
SCpnt333drivers/scsi/wd7000.cSCpnt->result = errstatus;
SCpnt335drivers/scsi/wd7000.cif (SCpnt->host_scribble != NULL)
SCpnt336drivers/scsi/wd7000.cscsi_free(SCpnt->host_scribble,WD7000_SCRIBBLE);
SCpnt339drivers/scsi/wd7000.cSCpnt->scsi_done(SCpnt);
SCpnt353drivers/scsi/wd7000.cint wd7000_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
SCpnt361drivers/scsi/wd7000.ccdb = (unchar *) SCpnt->cmnd;
SCpnt363drivers/scsi/wd7000.cidlun = ((SCpnt->target << 5) & 0xe0) | (SCpnt->lun & 7);
SCpnt364drivers/scsi/wd7000.cSCpnt->scsi_done = done;
SCpnt365drivers/scsi/wd7000.cSCpnt->SCp.phase = 1;
SCpnt370drivers/scsi/wd7000.cscb->SCpnt = SCpnt;         /* so we can find stuff later */
SCpnt371drivers/scsi/wd7000.cSCpnt->host_scribble = NULL;
SCpnt373drivers/scsi/wd7000.cSCpnt->request_bufflen, SCpnt->bufflen);)
SCpnt375drivers/scsi/wd7000.cif (SCpnt->use_sg)  {
SCpnt376drivers/scsi/wd7000.cstruct scatterlist *sg = (struct scatterlist *) SCpnt->request_buffer;
SCpnt383drivers/scsi/wd7000.cprintk("Using scatter/gather with %d elements.\n",SCpnt->use_sg);
SCpnt390drivers/scsi/wd7000.cif (SCpnt->use_sg > WD7000_SG)
SCpnt393drivers/scsi/wd7000.cSCpnt->host_scribble = (unsigned char *) scsi_malloc(WD7000_SCRIBBLE);
SCpnt394drivers/scsi/wd7000.csgb = (Sgb *) SCpnt->host_scribble;
SCpnt400drivers/scsi/wd7000.cany2scsi(scb->maxlen, SCpnt->use_sg * sizeof (Sgb) );
SCpnt402drivers/scsi/wd7000.cfor (i = 0;  i < SCpnt->use_sg;  i++)  {
SCpnt408drivers/scsi/wd7000.cscsi2int(scb->maxlen), SCpnt->use_sg);)
SCpnt411drivers/scsi/wd7000.cany2scsi(scb->dataptr, SCpnt->request_buffer);
SCpnt412drivers/scsi/wd7000.cany2scsi(scb->maxlen, SCpnt->request_bufflen);
SCpnt419drivers/scsi/wd7000.cint wd7000_command(Scsi_Cmnd *SCpnt)
SCpnt421drivers/scsi/wd7000.cwd7000_queuecommand(SCpnt, wd7000_scsi_done);
SCpnt423drivers/scsi/wd7000.cwhile (SCpnt->SCp.phase > 0);  /* phase counts scbs down to 0 */
SCpnt425drivers/scsi/wd7000.creturn SCpnt->result;
SCpnt582drivers/scsi/wd7000.cint wd7000_abort(Scsi_Cmnd * SCpnt, int i)
SCpnt585drivers/scsi/wd7000.cprintk("wd7000_abort: Scsi_Cmnd = 0x%08x, code = %d ", SCpnt, i);
SCpnt586drivers/scsi/wd7000.cprintk("id %d lun %d cdb", SCpnt->target, SCpnt->lun);
SCpnt587drivers/scsi/wd7000.c{  int j;  unchar *cdbj = (unchar *) SCpnt->cmnd;
SCpnt589drivers/scsi/wd7000.cprintk(" result %08x\n", SCpnt->result);
SCpnt600drivers/scsi/wd7000.cint wd7000_reset(Scsi_Cmnd * SCpnt)
SCpnt605drivers/scsi/wd7000.cif (SCpnt) SCpnt->flags |= NEEDS_JUMPSTART;
SCpnt141drivers/scsi/wd7000.hScsi_Cmnd *SCpnt;             /* Scsi_Cmnd using this SCB */