drivers/scsi/scsi.c

/* */
This source file includes following definitions.
blacklisted
scan_scsis_done
scsi_luns_setup
scan_scsis
scsi_times_out
request_queueable
allocate_device
internal_cmnd
scsi_request_sense
scsi_do_cmd
reset
check_sense
scsi_done
scsi_abort
scsi_reset
scsi_main_timeout
update_timeout
scsi_malloc
scsi_free
scsi_dev_init
print_inquiry
scsi_dump_status
   1 /*
   2  *      scsi.c Copyright (C) 1992 Drew Eckhardt 
   3  *             Copyright (C) 1993, 1994 Eric Youngdale
   4  *
   5  *      generic mid-level SCSI driver by
   6  *              Drew Eckhardt 
   7  *
   8  *      <drew@colorado.edu>
   9  *
  10  *      Bug correction thanks go to : 
  11  *              Rik Faith <faith@cs.unc.edu>
  12  *              Tommy Thorn <tthorn>
  13  *              Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
  14  * 
  15  *       Modified by Eric Youngdale ericy@cais.com to
  16  *       add scatter-gather, multiple outstanding request, and other
  17  *       enhancements.
  18  */
  19 
  20 #include <asm/system.h>
  21 #include <linux/sched.h>
  22 #include <linux/timer.h>
  23 #include <linux/string.h>
  24 #include <asm/irq.h>
  25 
  26 #include "../block/blk.h"
  27 #include "scsi.h"
  28 #include "hosts.h"
  29 #include "constants.h"
  30 
  31 /*
  32 static const char RCSid[] = "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/scsi.c,v 1.5 1993/09/24 12:45:18 drew Exp drew $";
  33 */
  34 
  35 /* Command groups 3 and 4 are reserved and should never be used.  */
  36 const unsigned char scsi_command_size[8] = { 6, 10, 10, 12, 12, 12, 10, 10 };
  37 
  38 #define INTERNAL_ERROR (panic ("Internal error in file %s, line %d.\n", __FILE__, __LINE__))
  39 
  40 static void scsi_done (Scsi_Cmnd *SCpnt);
  41 static int update_timeout (Scsi_Cmnd *, int);
  42 static void print_inquiry(unsigned char *data);
  43 static void scsi_times_out (Scsi_Cmnd * SCpnt);
  44 
  45 static int time_start;
  46 static int time_elapsed;
  47 
  48 #define MAX_SCSI_DEVICE_CODE 10
  49 const char *const scsi_device_types[MAX_SCSI_DEVICE_CODE] =
  50 {
  51  "Direct-Access    ",
  52  "Sequential-Access",
  53  "Printer          ",
  54  "Processor        ",
  55  "WORM             ",
  56  "CD-ROM           ",
  57  "Scanner          ",
  58  "Optical Device   ",
  59  "Medium Changer   ",
  60  "Communications   "
  61 };
  62 
  63 
  64 /*
  65         global variables : 
  66         NR_SCSI_DEVICES is the number of SCSI devices we have detected, 
  67         scsi_devices an array of these specifing the address for each 
  68         (host, id, LUN)
  69 */
  70         
  71 int NR_SCSI_DEVICES=0;
  72 
  73 Scsi_Device * scsi_devices = NULL;
  74 
  75 static unsigned char generic_sense[6] = {REQUEST_SENSE, 0,0,0, 255, 0};
  76 
  77 /* We make this not static so that we can read the array with gdb. */
  78 /* static */ Scsi_Cmnd * last_cmnd = NULL;
  79 
  80 /*
  81  *      As the scsi do command functions are inteligent, and may need to 
  82  *      redo a command, we need to keep track of the last command 
  83  *      executed on each one.
  84  */
  85 
  86 #define WAS_RESET       0x01
  87 #define WAS_TIMEDOUT    0x02
  88 #define WAS_SENSE       0x04
  89 #define IS_RESETTING    0x08
  90 #define IS_ABORTING     0x10
  91 #define ASKED_FOR_SENSE 0x20
  92 
  93 /*
  94  *      This is the number  of clock ticks we should wait before we time out 
  95  *      and abort the command.  This is for  where the scsi.c module generates 
  96  *      the command, not where it originates from a higher level, in which
  97  *      case the timeout is specified there.
  98  *
  99  *      ABORT_TIMEOUT and RESET_TIMEOUT are the timeouts for RESET and ABORT
 100  *      respectively.
 101  */
 102 
 103 #ifdef DEBUG_TIMEOUT
 104 static void scsi_dump_status(void);
 105 #endif
 106 
 107 
 108 #ifdef DEBUG
 109         #define SCSI_TIMEOUT 500
 110 #else
 111         #define SCSI_TIMEOUT 100
 112 #endif
 113 
 114 #ifdef DEBUG
 115         #define SENSE_TIMEOUT SCSI_TIMEOUT
 116         #define ABORT_TIMEOUT SCSI_TIMEOUT
 117         #define RESET_TIMEOUT SCSI_TIMEOUT
 118 #else
 119         #define SENSE_TIMEOUT 50
 120         #define RESET_TIMEOUT 50
 121         #define ABORT_TIMEOUT 50
 122         #define MIN_RESET_DELAY 100
 123 #endif
 124 
 125 /* The following devices are known not to tolerate a lun != 0 scan for
 126    one reason or another.  Some will respond to all luns, others will
 127    lock up. */
 128 
 129      struct blist{
 130        char * vendor;
 131        char * model;
 132        char * revision; /* Latest revision known to be bad.  Not used yet */
 133      };
 134 
 135 static struct blist blacklist[] = 
 136 {
 137    {"CHINON","CD-ROM CDS-431","H42"},  /* Locks up if polled for lun != 0 */
 138    {"CHINON","CD-ROM CDS-535","Q14"}, /* Lockup if polled for lun != 0 */
 139    {"DENON","DRD-25X","V"},   /* A cdrom that locks up when probed at lun != 0 */
 140    {"IMS", "CDD521/10","2.06"},   /* Locks-up when LUN>0 polled. */
 141    {"MAXTOR","XT-3280","PR02"},   /* Locks-up when LUN>0 polled. */
 142    {"MAXTOR","XT-4380S","B3C"},   /* Locks-up when LUN>0 polled. */
 143    {"MAXTOR","MXT-1240S","I1.2"}, /* Locks up when LUN > 0 polled */
 144    {"MAXTOR","XT-4170S","B5A"},   /* Locks-up sometimes when LUN>0 polled. */
 145    {"MAXTOR","XT-8760S","B7B"},   /* guess what? */
 146    {"NEC","CD-ROM DRIVE:841","1.0"},  /* Locks-up when LUN>0 polled. */
 147    {"RODIME","RO3000S","2.33"},  /* Locks up if polled for lun != 0 */
 148    {"SEAGATE", "ST157N", "\004|j"}, /* causes failed REQUEST SENSE on lun 1 for aha152x
 149                                      * controller, which causes SCSI code to reset bus.*/
 150    {"SEAGATE", "ST296","921"},   /* Responds to all lun */
 151    {"SONY","CD-ROM CDU-541","4.3d"},
 152    {"TANDBERG","TDC 3600","U07"},  /* Locks up if polled for lun != 0 */
 153    {"TEAC","CD-ROM","1.06"},    /* causes failed REQUEST SENSE on lun 1 for seagate
 154                                  * controller, which causes SCSI code to reset bus.*/
 155    {"TEXEL","CD-ROM","1.06"},   /* causes failed REQUEST SENSE on lun 1 for seagate
 156                                  * controller, which causes SCSI code to reset bus.*/
 157    {NULL, NULL, NULL}}; 
 158 
 159 static int blacklisted(unsigned char * response_data){
     /*  */
 160   int i = 0;
 161   unsigned char * pnt;
 162   for(i=0; 1; i++){
 163     if(blacklist[i].vendor == NULL) return 0;
 164     pnt = &response_data[8];
 165     while(*pnt && *pnt == ' ') pnt++;
 166     if(memcmp(blacklist[i].vendor, pnt,
 167                strlen(blacklist[i].vendor))) continue;
 168     pnt = &response_data[16];
 169     while(*pnt && *pnt == ' ') pnt++;
 170     if(memcmp(blacklist[i].model, pnt,
 171                strlen(blacklist[i].model))) continue;
 172     return 1;
 173   };    
 174 };
 175 
 176 /*
 177  *      As the actual SCSI command runs in the background, we must set up a 
 178  *      flag that tells scan_scsis() when the result it has is valid.  
 179  *      scan_scsis can set the_result to -1, and watch for it to become the 
 180  *      actual return code for that call.  the scan_scsis_done function() is 
 181  *      our user specified completion function that is passed on to the  
 182  *      scsi_do_cmd() function.
 183  */
 184 
 185 static volatile int in_scan = 0;
 186 static int the_result;
 187 static void scan_scsis_done (Scsi_Cmnd * SCpnt)
     /*  */
 188         {
 189         
 190 #ifdef DEBUG
 191         printk ("scan_scsis_done(%d, %06x)\n", SCpnt->host, SCpnt->result);
 192 #endif  
 193         SCpnt->request.dev = 0xfffe;
 194         }
 195 
 196 #ifdef NO_MULTI_LUN
 197 static int max_scsi_luns = 1;
 198 #else
 199 static int max_scsi_luns = 8;
 200 #endif
 201 
 202 void scsi_luns_setup(char *str, int *ints) {
     /*  */
 203     if (ints[0] != 1) 
 204         printk("scsi_luns_setup : usage max_scsi_luns=n (n should be between 1 and 8)\n");
 205     else
 206         max_scsi_luns = ints[1];
 207 }
 208 
 209 /*
 210  *      Detecting SCSI devices :        
 211  *      We scan all present host adapter's busses,  from ID 0 to ID 6.  
 212  *      We use the INQUIRY command, determine device type, and pass the ID / 
 213  *      lun address of all sequential devices to the tape driver, all random 
 214  *      devices to the disk driver.
 215  */
 216 
 217 static void scan_scsis (void)
     /*  */
 218 {
 219   int dev, lun, type;
 220   unsigned char scsi_cmd [12];
 221   unsigned char scsi_result [256];
 222   struct Scsi_Host * shpnt;
 223   Scsi_Cmnd  SCmd;
 224   
 225   ++in_scan;
 226   lun = 0;
 227   
 228   SCmd.next = NULL;
 229   SCmd.prev = NULL;
 230   for (shpnt = scsi_hostlist; shpnt; shpnt = shpnt->next)
 231       {
 232         shpnt->host_queue = &SCmd;  /* We need this so that
 233                                          commands can time out */
 234         for (dev = 0; dev < 8; ++dev)
 235           if (shpnt->this_id != dev)
 236 /*
 237  * We need the for so our continue, etc. work fine.
 238  */
 239 
 240             for (lun = 0; lun < max_scsi_luns; ++lun)
 241               {
 242                 scsi_devices[NR_SCSI_DEVICES].host = shpnt;
 243                 scsi_devices[NR_SCSI_DEVICES].id = dev;
 244                 scsi_devices[NR_SCSI_DEVICES].lun = lun;
 245                 scsi_devices[NR_SCSI_DEVICES].index = NR_SCSI_DEVICES;
 246                 scsi_devices[NR_SCSI_DEVICES].device_wait = NULL;
 247 /*
 248  * Assume that the device will have handshaking problems, and then 
 249  * fix this field later if it turns out it doesn't.
 250  */
 251                 scsi_devices[NR_SCSI_DEVICES].borken = 1;
 252                 
 253                 scsi_cmd[0] = TEST_UNIT_READY;
 254                 scsi_cmd[1] = lun << 5;
 255                 scsi_cmd[2] = scsi_cmd[3] = scsi_cmd[5] = 0;
 256                 scsi_cmd[4] = 0;
 257 
 258                 SCmd.host = shpnt;
 259                 SCmd.target = dev;
 260                 SCmd.lun = lun;
 261 
 262                 SCmd.request.dev = 0xffff; /* Mark not busy */
 263                 SCmd.use_sg  = 0;
 264                 SCmd.old_use_sg  = 0;
 265                 SCmd.transfersize = 0;
 266                 SCmd.underflow = 0;
 267                 SCmd.index = NR_SCSI_DEVICES;
 268 
 269                 scsi_do_cmd (&SCmd,
 270                              (void *)  scsi_cmd, (void *) 
 271                              scsi_result, 256,  scan_scsis_done, 
 272                              SCSI_TIMEOUT + 400, 5);
 273                 
 274                 while (SCmd.request.dev != 0xfffe);
 275 #if defined(DEBUG) || defined(DEBUG_INIT)
 276                 printk("scsi: scan SCSIS id %d lun %d\n", dev, lun);
 277                 printk("scsi: return code %08x\n", SCmd.result);
 278 #endif
 279 
 280 
 281                 if(SCmd.result) {
 282                   if ((driver_byte(SCmd.result)  & DRIVER_SENSE) &&
 283                       ((SCmd.sense_buffer[0] & 0x70) >> 4) == 7) {
 284                     if (SCmd.sense_buffer[2] &0xe0)
 285                       continue; /* No devices here... */
 286                     if(((SCmd.sense_buffer[2] & 0xf) != NOT_READY) &&
 287                        ((SCmd.sense_buffer[2] & 0xf) != UNIT_ATTENTION))
 288                       continue;
 289                   }
 290                   else
 291                     break;
 292                 };
 293 
 294 #if defined (DEBUG) || defined(DEBUG_INIT)
 295                 printk("scsi: performing INQUIRY\n");
 296 #endif
 297 
 298                 /*
 299                  * Build an INQUIRY command block.  
 300                  */
 301                 
 302                 scsi_cmd[0] = INQUIRY;
 303                 scsi_cmd[1] = (lun << 5) & 0xe0;
 304                 scsi_cmd[2] = 0;
 305                 scsi_cmd[3] = 0;
 306                 scsi_cmd[4] = 255;
 307                 scsi_cmd[5] = 0;
 308                 
 309                 SCmd.request.dev = 0xffff; /* Mark not busy */
 310                 
 311                 scsi_do_cmd (&SCmd,
 312                              (void *)  scsi_cmd, (void *) 
 313                              scsi_result, 256,  scan_scsis_done, 
 314                              SCSI_TIMEOUT, 3);
 315                 
 316                 while (SCmd.request.dev != 0xfffe);
 317                 
 318                 the_result = SCmd.result;
 319                 
 320 #if defined(DEBUG) || defined(DEBUG_INIT)
 321                 if (!the_result)
 322                         printk("scsi: INQUIRY successful\n");
 323                 else
 324                         printk("scsi: INQUIRY failed with code %08x\n");
 325 #endif
 326 
 327                 if(the_result) break; 
 328 
 329                 /* skip other luns on this device */
 330                 
 331                 if (!the_result)
 332                   {
 333                     scsi_devices[NR_SCSI_DEVICES].
 334                       removable = (0x80 & 
 335                                    scsi_result[1]) >> 7;
 336                     scsi_devices[NR_SCSI_DEVICES].lockable =
 337                       scsi_devices[NR_SCSI_DEVICES].removable;
 338                     scsi_devices[NR_SCSI_DEVICES].
 339                       changed = 0;
 340                     scsi_devices[NR_SCSI_DEVICES].
 341                       access_count = 0;
 342                     scsi_devices[NR_SCSI_DEVICES].
 343                       busy = 0;
 344 /* 
 345  *      Currently, all sequential devices are assumed to be tapes,
 346  *      all random devices disk, with the appropriate read only 
 347  *      flags set for ROM / WORM treated as RO.
 348  */ 
 349 
 350                     switch (type = scsi_result[0])
 351                       {
 352                       case TYPE_TAPE :
 353                       case TYPE_DISK :
 354                       case TYPE_MOD :
 355                         scsi_devices[NR_SCSI_DEVICES].writeable = 1;
 356                         break;
 357                       case TYPE_WORM :
 358                       case TYPE_ROM :
 359                         scsi_devices[NR_SCSI_DEVICES].writeable = 0;
 360                         break;
 361                         default :
 362 #if 0
 363 #ifdef DEBUG
 364                         printk("scsi: unknown type %d\n", type);
 365                         print_inquiry(scsi_result);
 366 #endif
 367 #endif
 368                           type = -1;
 369                       }
 370 
 371                     scsi_devices[NR_SCSI_DEVICES].soft_reset = 
 372                       (scsi_result[7] & 1) && ((scsi_result[3] & 7) == 2);
 373                     scsi_devices[NR_SCSI_DEVICES].random = 
 374                       (type == TYPE_TAPE) ? 0 : 1;
 375                     scsi_devices[NR_SCSI_DEVICES].type = type;
 376 
 377                     if (type != -1)
 378                       {
 379                         print_inquiry(scsi_result);
 380                         switch(type){
 381                         case TYPE_TAPE:
 382                           printk("Detected scsi tape st%d at scsi%d, id %d, lun %d\n", MAX_ST,
 383                                  shpnt->host_no , dev, lun); 
 384                           if(NR_ST != -1) ++MAX_ST;
 385                           break;
 386                         case TYPE_ROM:
 387                           printk("Detected scsi CD-ROM sr%d at scsi%d, id %d, lun %d\n", MAX_SR,
 388                                  shpnt->host_no , dev, lun); 
 389                           if(NR_SR != -1) ++MAX_SR;
 390                           break;
 391                         case TYPE_DISK:
 392                         case TYPE_MOD:
 393                           printk("Detected scsi disk sd%c at scsi%d, id %d, lun %d\n", 'a'+MAX_SD,
 394                                  shpnt->host_no , dev, lun); 
 395                           if(NR_SD != -1) ++MAX_SD;
 396                           break;
 397                         default:
 398                           break;
 399                         };
 400 
 401                         if(NR_SG != -1) ++MAX_SG;
 402 
 403                         scsi_devices[NR_SCSI_DEVICES].scsi_level =
 404                           scsi_result[2] & 0x07;
 405                         if (scsi_devices[NR_SCSI_DEVICES].scsi_level >= 2 ||
 406                             (scsi_devices[NR_SCSI_DEVICES].scsi_level == 1 &&
 407                              (scsi_result[3] & 0x0f) == 1))
 408                           scsi_devices[NR_SCSI_DEVICES].scsi_level++;
 409 /* 
 410  * Set the tagged_queue flag for SCSI-II devices that purport to support
 411  * tagged queuing in the INQUIRY data.
 412  */
 413 
 414                         scsi_devices[NR_SCSI_DEVICES].tagged_queue = 0;
 415 
 416                         if ((scsi_devices[NR_SCSI_DEVICES].scsi_level >= SCSI_2) &&
 417                             (scsi_result[7] & 2)) {
 418                             scsi_devices[NR_SCSI_DEVICES].tagged_supported = 1;
 419                             scsi_devices[NR_SCSI_DEVICES].current_tag = 0;
 420                         }
 421 
 422 /*
 423  * Accomodate drivers that want to sleep when they should be in a polling
 424  * loop.
 425  */
 426 
 427                         scsi_devices[NR_SCSI_DEVICES].disconnect = 0;
 428 
 429 /*
 430  * Some revisions of the Texel CD ROM drives have handshaking
 431  * problems when used with the Seagate controllers.  Before we
 432  * know what type of device we're talking to, we assume it's 
 433  * borken and then change it here if it turns out that it isn't
 434  * a TEXEL drive.
 435  */
 436 
 437                         if(strncmp("TEXEL", (char *) &scsi_result[8], 5) != 0 ||
 438                           strncmp("CD-ROM", (char *) &scsi_result[16], 6) != 0 
 439 /* 
 440  * XXX 1.06 has problems, some one should figure out the others too so
 441  * ALL TEXEL drives don't suffer in performance, especially when I finish
 442  * integrating my seagate patches which do multiple I_T_L nexuses.
 443  */
 444 
 445 #ifdef notyet
 446                            || (strncmp("1.06", (char *) &scsi_result[[, 4) != 0)
 447 #endif
 448                            )
 449                            scsi_devices[NR_SCSI_DEVICES].borken = 0;
 450 
 451 
 452                         /* These devices need this "key" to unlock the device
 453                            so we can use it */
 454                         if(memcmp("INSITE", &scsi_result[8], 6) == 0 &&
 455                            (memcmp("Floptical   F*8I", &scsi_result[16], 16) == 0
 456                             || memcmp("I325VM", &scsi_result[16], 6) == 0)) {
 457                           printk("Unlocked floptical drive.\n");
 458                           scsi_devices[NR_SCSI_DEVICES].lockable = 0;
 459                           scsi_cmd[0] = MODE_SENSE;
 460                           scsi_cmd[1] = (lun << 5) & 0xe0;
 461                           scsi_cmd[2] = 0x2e;
 462                           scsi_cmd[3] = 0;
 463                           scsi_cmd[4] = 0x2a;
 464                           scsi_cmd[5] = 0;
 465                 
 466                           SCmd.request.dev = 0xffff; /* Mark not busy */
 467                           
 468                           scsi_do_cmd (&SCmd,
 469                                        (void *)  scsi_cmd, (void *) 
 470                                        scsi_result, 0x2a,  scan_scsis_done, 
 471                                        SCSI_TIMEOUT, 3);
 472                 
 473                           while (SCmd.request.dev != 0xfffe);
 474                         };
 475 
 476                         ++NR_SCSI_DEVICES;
 477                         /* Some scsi devices cannot be polled for lun != 0
 478                            due to firmware bugs */
 479                         if(blacklisted(scsi_result)) break;
 480                         /* Old drives like the MAXTOR XT-3280 say vers=0 */
 481                         if ((scsi_result[2] & 0x07) == 0)
 482                             break;
 483                         /* Some scsi-1 peripherals do not handle lun != 0.
 484                            I am assuming that scsi-2 peripherals do better */
 485                         if((scsi_result[2] & 0x07) == 1 && 
 486                            (scsi_result[3] & 0x0f) == 0) break;
 487                         }
 488                   }       /* if result == DID_OK ends */
 489               }       /* for lun ends */
 490         shpnt->host_queue = NULL;  /* No longer needed here */
 491       }         /* if present */  
 492   
 493   printk("scsi : detected ");
 494   if(NR_SD != -1)
 495     printk("%d SCSI disk%s ", MAX_SD, (MAX_SD != 1) ? "s" : "");
 496          
 497   if(NR_ST != -1)
 498     printk("%d tape%s ", MAX_ST, (MAX_ST != 1) ? "s" : "");
 499 
 500   if(NR_SR != -1)
 501     printk("%d CD-ROM drive%s ", MAX_SR, (MAX_SR != 1) ? "s" : "");
 502 
 503   printk("total.\n");
 504   in_scan = 0;
 505 }       /* scan_scsis  ends */
 506 
 507 /*
 508  *      Flag bits for the internal_timeout array 
 509  */
 510 
 511 #define NORMAL_TIMEOUT 0
 512 #define IN_ABORT 1
 513 #define IN_RESET 2
 514 /*
 515         This is our time out function, called when the timer expires for a 
 516         given host adapter.  It will attempt to abort the currently executing 
 517         command, that failing perform a kernel panic.
 518 */ 
 519 
 520 static void scsi_times_out (Scsi_Cmnd * SCpnt)
     /*  */
 521         {
 522         
 523         switch (SCpnt->internal_timeout & (IN_ABORT | IN_RESET))
 524                 {
 525                 case NORMAL_TIMEOUT:
 526                         if (!in_scan) {
 527                           printk("SCSI host %d timed out - aborting command\n",
 528                                  SCpnt->host->host_no);
 529 #ifdef DEBUG_TIMEOUT
 530                           scsi_dump_status();
 531 #endif
 532                         }
 533                         
 534                         if (!scsi_abort (SCpnt, DID_TIME_OUT))
 535                                 return;                         
 536                 case IN_ABORT:
 537                         printk("SCSI host %d abort() timed out - reseting\n",
 538                                 SCpnt->host->host_no);
 539                         if (!scsi_reset (SCpnt)) 
 540                                 return;
 541                 case IN_RESET:
 542                 case (IN_ABORT | IN_RESET):
 543                   /* This might be controversial, but if there is a bus hang,
 544                      you might conceivably want the machine up and running
 545                      esp if you have an ide disk. */
 546                         printk("Unable to reset scsi host %d - ",SCpnt->host->host_no);
 547                         printk("probably a SCSI bus hang.\n");
 548                         return;
 549 
 550                 default:
 551                         INTERNAL_ERROR;
 552                 }
 553                                         
 554         }
 555 
 556 
 557 /* This function takes a quick look at a request, and decides if it
 558 can be queued now, or if there would be a stall while waiting for
 559 something else to finish.  This routine assumes that interrupts are
 560 turned off when entering the routine.  It is the responsibility
 561 of the calling code to ensure that this is the case. */
 562 
 563 Scsi_Cmnd * request_queueable (struct request * req, int index)
     /*  */
 564 {
 565   Scsi_Cmnd * SCpnt = NULL;
 566   int tablesize;
 567   struct buffer_head * bh, *bhp;
 568 
 569   if ((index < 0) ||  (index > NR_SCSI_DEVICES))
 570     panic ("Index number in allocate_device() is out of range.\n");
 571   
 572   if (req && req->dev <= 0)
 573     panic("Invalid device in allocate_device");
 574   
 575   SCpnt =  scsi_devices[index].host->host_queue;
 576     while(SCpnt){
 577       if(SCpnt->target == scsi_devices[index].id &&
 578          SCpnt->lun == scsi_devices[index].lun)
 579         if(SCpnt->request.dev < 0) break;
 580       SCpnt = SCpnt->next;
 581     };
 582 
 583   if (!SCpnt) return NULL;
 584 
 585   if (scsi_devices[index].host->hostt->can_queue
 586       && scsi_devices[index].host->host_busy >= scsi_devices[index].host->hostt->can_queue) return NULL;
 587 
 588   if (req) {
 589     memcpy(&SCpnt->request, req, sizeof(struct request));
 590     tablesize = scsi_devices[index].host->sg_tablesize;
 591     bhp = bh = req->bh;
 592     if(!tablesize) bh = NULL;
 593     /* Take a quick look through the table to see how big it is.  We already
 594        have our copy of req, so we can mess with that if we want to.  */
 595     while(req->nr_sectors && bh){
 596             bhp = bhp->b_reqnext;
 597             if(!bhp || !CONTIGUOUS_BUFFERS(bh,bhp)) tablesize--;
 598             req->nr_sectors -= bh->b_size >> 9;
 599             req->sector += bh->b_size >> 9;
 600             if(!tablesize) break;
 601             bh = bhp;
 602     };
 603     if(req->nr_sectors && bh && bh->b_reqnext){  /* Any leftovers? */
 604       SCpnt->request.bhtail = bh;
 605       req->bh = bh->b_reqnext; /* Divide request */
 606       bh->b_reqnext = NULL;
 607       bh = req->bh;
 608 
 609       /* Now reset things so that req looks OK */
 610       SCpnt->request.nr_sectors -= req->nr_sectors;
 611       req->current_nr_sectors = bh->b_size >> 9;
 612       req->buffer = bh->b_data;
 613       SCpnt->request.waiting = NULL; /* Wait until whole thing done */
 614     } else {
 615       req->dev = -1;
 616       wake_up(&wait_for_request);
 617     };      
 618   } else {
 619     SCpnt->request.dev = 0xffff; /* Busy, but no request */
 620     SCpnt->request.waiting = NULL;  /* And no one is waiting for the device either */
 621   };
 622 
 623   SCpnt->use_sg = 0;  /* Reset the scatter-gather flag */
 624   SCpnt->old_use_sg  = 0;
 625   SCpnt->transfersize = 0;
 626   SCpnt->underflow = 0;
 627   return SCpnt;
 628 }
 629 
 630 /* This function returns a structure pointer that will be valid for
 631 the device.  The wait parameter tells us whether we should wait for
 632 the unit to become free or not.  We are also able to tell this routine
 633 not to return a descriptor if the host is unable to accept any more
 634 commands for the time being.  We need to keep in mind that there is no
 635 guarantee that the host remain not busy.  Keep in mind the
 636 request_queueable function also knows the internal allocation scheme
 637 of the packets for each device */
 638 
 639 Scsi_Cmnd * allocate_device (struct request ** reqp, int index, int wait)
     /*  */
 640 {
 641   int dev = -1;
 642   struct request * req = NULL;
 643   int tablesize;
 644   struct buffer_head * bh, *bhp;
 645   struct Scsi_Host * host;
 646   Scsi_Cmnd * SCpnt = NULL;
 647   Scsi_Cmnd * SCwait = NULL;
 648 
 649   if ((index < 0) ||  (index > NR_SCSI_DEVICES))
 650     panic ("Index number in allocate_device() is out of range.\n");
 651   
 652   if (reqp) req = *reqp;
 653 
 654     /* See if this request has already been queued by an interrupt routine */
 655   if (req && (dev = req->dev) <= 0) return NULL;
 656   
 657   host = scsi_devices[index].host;
 658   
 659   while (1==1){
 660     SCpnt = host->host_queue;
 661     while(SCpnt){
 662       if(SCpnt->target == scsi_devices[index].id &&
 663          SCpnt->lun == scsi_devices[index].lun) {
 664         SCwait = SCpnt;
 665         if(SCpnt->request.dev < 0) break;
 666       };
 667       SCpnt = SCpnt->next;
 668     };
 669     cli();
 670     /* See if this request has already been queued by an interrupt routine */
 671     if (req && ((req->dev < 0) || (req->dev != dev))) {
 672       sti();
 673       return NULL;
 674     };
 675     if (!SCpnt || SCpnt->request.dev >= 0)  /* Might have changed */
 676       {
 677         sti();
 678         if(!wait) return NULL;
 679         if (!SCwait) {
 680           printk("Attempt to allocate device index %d, target %d, lun %d\n",
 681                  index, scsi_devices[index].id ,scsi_devices[index].lun);
 682           panic("No device found in allocate_device\n");
 683         };
 684         SCSI_SLEEP(&scsi_devices[SCwait->index].device_wait, 
 685                    (SCwait->request.dev > 0));
 686       } else {
 687         if (req) {
 688           memcpy(&SCpnt->request, req, sizeof(struct request));
 689           tablesize = scsi_devices[index].host->sg_tablesize;
 690           bhp = bh = req->bh;
 691           if(!tablesize) bh = NULL;
 692           /* Take a quick look through the table to see how big it is.  We already
 693              have our copy of req, so we can mess with that if we want to.  */
 694           while(req->nr_sectors && bh){
 695             bhp = bhp->b_reqnext;
 696             if(!bhp || !CONTIGUOUS_BUFFERS(bh,bhp)) tablesize--;
 697             req->nr_sectors -= bh->b_size >> 9;
 698             req->sector += bh->b_size >> 9;
 699             if(!tablesize) break;
 700             bh = bhp;
 701           };
 702           if(req->nr_sectors && bh && bh->b_reqnext){  /* Any leftovers? */
 703             SCpnt->request.bhtail = bh;
 704             req->bh = bh->b_reqnext; /* Divide request */
 705             bh->b_reqnext = NULL;
 706             bh = req->bh;
 707             /* Now reset things so that req looks OK */
 708             SCpnt->request.nr_sectors -= req->nr_sectors;
 709             req->current_nr_sectors = bh->b_size >> 9;
 710             req->buffer = bh->b_data;
 711             SCpnt->request.waiting = NULL; /* Wait until whole thing done */
 712           }
 713           else 
 714             {
 715               req->dev = -1;
 716               *reqp = req->next;
 717               wake_up(&wait_for_request);
 718             };
 719         } else {
 720           SCpnt->request.dev = 0xffff; /* Busy */
 721           SCpnt->request.waiting = NULL;  /* And no one is waiting for this to complete */
 722         };
 723         sti();
 724         break;
 725       };
 726   };
 727 
 728   SCpnt->use_sg = 0;  /* Reset the scatter-gather flag */
 729   SCpnt->old_use_sg  = 0;
 730   SCpnt->transfersize = 0;      /* No default transfer size */
 731   SCpnt->underflow = 0;         /* Do not flag underflow conditions */
 732   return SCpnt;
 733 }
 734 
 735 /*
 736         This is inline because we have stack problemes if we recurse to deeply.
 737 */
 738                          
 739 inline void internal_cmnd (Scsi_Cmnd * SCpnt)
     /*  */
 740         {
 741         int temp;
 742         struct Scsi_Host * host;
 743 #ifdef DEBUG_DELAY      
 744         int clock;
 745 #endif
 746 
 747         if ((unsigned long) &SCpnt < current->kernel_stack_page)
 748           panic("Kernel stack overflow.");
 749 
 750         host = SCpnt->host;
 751 
 752 /*
 753         We will wait MIN_RESET_DELAY clock ticks after the last reset so 
 754         we can avoid the drive not being ready.
 755 */ 
 756 temp = host->last_reset;
 757 while (jiffies < temp);
 758 
 759 update_timeout(SCpnt, SCpnt->timeout_per_command);
 760 
 761 /*
 762         We will use a queued command if possible, otherwise we will emulate the
 763         queing and calling of completion function ourselves. 
 764 */
 765 #ifdef DEBUG
 766         printk("internal_cmnd (host = %d, target = %d, command = %08x, buffer =  %08x, \n"
 767                 "bufflen = %d, done = %08x)\n", SCpnt->host->host_no, SCpnt->target, SCpnt->cmnd, SCpnt->buffer, SCpnt->bufflen, SCpnt->done);
 768 #endif
 769 
 770         if (host->hostt->can_queue)
 771                 {
 772                   extern unsigned long intr_count;
 773 #ifdef DEBUG
 774         printk("queuecommand : routine at %08x\n", 
 775                 host->hostt->queuecommand);
 776 #endif
 777                   /* This locking tries to prevent all sorts of races between
 778                      queuecommand and the interrupt code.  In effect,
 779                      we are only allowed to be in queuecommand once at
 780                      any given time, and we can only be in the interrupt
 781                      handler and the queuecommand function at the same time
 782                      when queuecommand is called while servicing the
 783                      interrupt. */
 784 
 785                 if(!intr_count && SCpnt->host->irq)
 786                   disable_irq(SCpnt->host->irq);
 787 
 788                 host->hostt->queuecommand (SCpnt, scsi_done);
 789 
 790                 if(!intr_count && SCpnt->host->irq)
 791                   enable_irq(SCpnt->host->irq);
 792                 }
 793         else
 794                 {
 795 
 796 #ifdef DEBUG
 797         printk("command() :  routine at %08x\n", host->hostt->command);
 798 #endif
 799                 temp=host->hostt->command (SCpnt);
 800                 SCpnt->result = temp;
 801 #ifdef DEBUG_DELAY
 802         clock = jiffies + 400;
 803         while (jiffies < clock);
 804         printk("done(host = %d, result = %04x) : routine at %08x\n", host->host_no, temp, done);
 805 #endif
 806                 scsi_done(SCpnt);
 807                 }       
 808 #ifdef DEBUG
 809         printk("leaving internal_cmnd()\n");
 810 #endif
 811         }       
 812 
 813 static void scsi_request_sense (Scsi_Cmnd * SCpnt)
     /*  */
 814         {
 815         cli();
 816         SCpnt->flags |= WAS_SENSE | ASKED_FOR_SENSE;
 817         update_timeout(SCpnt, SENSE_TIMEOUT);
 818         sti();
 819         
 820 
 821         memcpy ((void *) SCpnt->cmnd , (void *) generic_sense,
 822                 sizeof(generic_sense));
 823 
 824         SCpnt->cmnd[1] = SCpnt->lun << 5;       
 825         SCpnt->cmnd[4] = sizeof(SCpnt->sense_buffer);
 826 
 827         SCpnt->request_buffer = &SCpnt->sense_buffer;
 828         SCpnt->request_bufflen = sizeof(SCpnt->sense_buffer);
 829         SCpnt->use_sg = 0;
 830         internal_cmnd (SCpnt);
 831         SCpnt->use_sg = SCpnt->old_use_sg;
 832         }
 833 
 834 
 835 
 836 /*
 837         scsi_do_cmd sends all the commands out to the low-level driver.  It 
 838         handles the specifics required for each low level driver - ie queued 
 839         or non queud.  It also prevents conflicts when different high level 
 840         drivers go for the same host at the same time.
 841 */
 842 
 843 void scsi_do_cmd (Scsi_Cmnd * SCpnt, const void *cmnd , 
     /*  */
 844                   void *buffer, unsigned bufflen, void (*done)(Scsi_Cmnd *),
 845                   int timeout, int retries 
 846                    )
 847         {
 848         struct Scsi_Host * host = SCpnt->host;
 849 
 850 #ifdef DEBUG
 851         {
 852         int i;  
 853         int target = SCpnt->target;
 854         printk ("scsi_do_cmd (host = %d, target = %d, buffer =%08x, "
 855                 "bufflen = %d, done = %08x, timeout = %d, retries = %d)\n"
 856                 "command : " , host->host_no, target, buffer, bufflen, done, timeout, retries);
 857         for (i = 0; i < 10; ++i)
 858                 printk ("%02x  ", ((unsigned char *) cmnd)[i]); 
 859         printk("\n");
 860       };
 861 #endif
 862         
 863         if (!host)
 864                 {
 865                 panic ("Invalid or not present host. %d\n", host->host_no);
 866                 }
 867 
 868         
 869 /*
 870         We must prevent reentrancy to the lowlevel host driver.  This prevents 
 871         it - we enter a loop until the host we want to talk to is not busy.   
 872         Race conditions are prevented, as interrupts are disabled inbetween the
 873         time we check for the host being not busy, and the time we mark it busy
 874         ourselves.
 875 */
 876 
 877         while (1==1){
 878           cli();
 879           if (host->hostt->can_queue
 880               && host->host_busy >= host->hostt->can_queue)
 881             {
 882               sti();
 883               SCSI_SLEEP(&host->host_wait, 
 884                          (host->host_busy >= host->hostt->can_queue));
 885             } else {
 886               host->host_busy++;
 887               sti();
 888               break;
 889             };
 890       };
 891 /*
 892         Our own function scsi_done (which marks the host as not busy, disables 
 893         the timeout counter, etc) will be called by us or by the 
 894         scsi_hosts[host].queuecommand() function needs to also call
 895         the completion function for the high level driver.
 896 
 897 */
 898 
 899         memcpy ((void *) SCpnt->data_cmnd , (void *) cmnd, 12);
 900 #if 0
 901         SCpnt->host = host;
 902         SCpnt->target = target;
 903         SCpnt->lun = (SCpnt->data_cmnd[1] >> 5);
 904 #endif
 905         SCpnt->bufflen = bufflen;
 906         SCpnt->buffer = buffer;
 907         SCpnt->flags=0;
 908         SCpnt->retries=0;
 909         SCpnt->allowed=retries;
 910         SCpnt->done = done;
 911         SCpnt->timeout_per_command = timeout;
 912                                 
 913         memcpy ((void *) SCpnt->cmnd , (void *) cmnd, 12);
 914         /* Zero the sense buffer.  Some host adapters automatically request
 915            sense on error.  0 is not a valid sense code.  */
 916         memset ((void *) SCpnt->sense_buffer, 0, sizeof SCpnt->sense_buffer);
 917         SCpnt->request_buffer = buffer;
 918         SCpnt->request_bufflen = bufflen;
 919         SCpnt->old_use_sg = SCpnt->use_sg;
 920 
 921         /* Start the timer ticking.  */
 922 
 923         SCpnt->internal_timeout = 0;
 924         SCpnt->abort_reason = 0;
 925         internal_cmnd (SCpnt);
 926 
 927 #ifdef DEBUG
 928         printk ("Leaving scsi_do_cmd()\n");
 929 #endif
 930         }
 931 
 932 
 933 
 934 /*
 935         The scsi_done() function disables the timeout timer for the scsi host, 
 936         marks the host as not busy, and calls the user specified completion 
 937         function for that host's current command.
 938 */
 939 
 940 static void reset (Scsi_Cmnd * SCpnt)
     /*  */
 941 {
 942 #ifdef DEBUG
 943         printk("scsi: reset(%d)\n", SCpnt->host->host_no);
 944 #endif
 945         
 946         SCpnt->flags |= (WAS_RESET | IS_RESETTING);
 947         scsi_reset(SCpnt);
 948         
 949 #ifdef DEBUG
 950         printk("performing request sense\n");
 951 #endif
 952         
 953 #if 0  /* FIXME - remove this when done */
 954         if(SCpnt->flags & NEEDS_JUMPSTART) {
 955           SCpnt->flags &= ~NEEDS_JUMPSTART;
 956           scsi_request_sense (SCpnt);
 957         };
 958 #endif
 959 }
 960         
 961         
 962 
 963 static int check_sense (Scsi_Cmnd * SCpnt)
     /*  */
 964         {
 965   /* If there is no sense information, request it.  If we have already
 966      requested it, there is no point in asking again - the firmware must be
 967      confused. */
 968   if (((SCpnt->sense_buffer[0] & 0x70) >> 4) != 7) {
 969     if(!(SCpnt->flags & ASKED_FOR_SENSE))
 970       return SUGGEST_SENSE;
 971     else
 972       return SUGGEST_RETRY;
 973       }
 974   
 975   SCpnt->flags &= ~ASKED_FOR_SENSE;
 976 
 977 #ifdef DEBUG_INIT
 978         printk("scsi%d : ", SCpnt->host->host_no);
 979         print_sense("", SCpnt);
 980         printk("\n");
 981 #endif
 982                 if (SCpnt->sense_buffer[2] &0xe0)
 983                   return SUGGEST_ABORT;
 984 
 985                 switch (SCpnt->sense_buffer[2] & 0xf)
 986                 {
 987                 case NO_SENSE:
 988                         return 0;
 989                 case RECOVERED_ERROR:
 990                         if (scsi_devices[SCpnt->index].type == TYPE_TAPE)
 991                           return SUGGEST_IS_OK;
 992                         else
 993                           return 0;
 994 
 995                 case ABORTED_COMMAND:
 996                         return SUGGEST_RETRY;   
 997                 case NOT_READY:
 998                 case UNIT_ATTENTION:
 999                         return SUGGEST_ABORT;
1000 
1001                 /* these three are not supported */     
1002                 case COPY_ABORTED:
1003                 case VOLUME_OVERFLOW:
1004                 case MISCOMPARE:
1005         
1006                 case MEDIUM_ERROR:
1007                         return SUGGEST_REMAP;
1008                 case BLANK_CHECK:
1009                 case DATA_PROTECT:
1010                 case HARDWARE_ERROR:
1011                 case ILLEGAL_REQUEST:
1012                 default:
1013                         return SUGGEST_ABORT;
1014                 }
1015               }
1016 
1017 /* This function is the mid-level interrupt routine, which decides how
1018  *  to handle error conditions.  Each invocation of this function must
1019  *  do one and *only* one of the following:
1020  *
1021  *  (1) Call last_cmnd[host].done.  This is done for fatal errors and
1022  *      normal completion, and indicates that the handling for this
1023  *      request is complete.
1024  *  (2) Call internal_cmnd to requeue the command.  This will result in
1025  *      scsi_done being called again when the retry is complete.
1026  *  (3) Call scsi_request_sense.  This asks the host adapter/drive for
1027  *      more information about the error condition.  When the information
1028  *      is available, scsi_done will be called again.
1029  *  (4) Call reset().  This is sort of a last resort, and the idea is that
1030  *      this may kick things loose and get the drive working again.  reset()
1031  *      automatically calls scsi_request_sense, and thus scsi_done will be
1032  *      called again once the reset is complete.
1033  *
1034  *      If none of the above actions are taken, the drive in question
1035  * will hang. If more than one of the above actions are taken by
1036  * scsi_done, then unpredictable behavior will result.
1037  */
1038 static void scsi_done (Scsi_Cmnd * SCpnt)
     /*  */
1039         {
1040         int status=0;
1041         int exit=0;
1042         int checked;
1043         int oldto;
1044         struct Scsi_Host * host = SCpnt->host;
1045         int result = SCpnt->result;
1046         oldto = update_timeout(SCpnt, 0);
1047 
1048 #ifdef DEBUG_TIMEOUT
1049         if(result) printk("Non-zero result in scsi_done %x %d:%d\n",
1050                           result, SCpnt->target, SCpnt->lun);
1051 #endif
1052 
1053         /* If we requested an abort, (and we got it) then fix up the return
1054            status to say why */
1055         if(host_byte(result) == DID_ABORT && SCpnt->abort_reason)
1056           SCpnt->result = result = (result & 0xff00ffff) | 
1057             (SCpnt->abort_reason << 16);
1058 
1059 
1060 #define FINISHED 0
1061 #define MAYREDO  1
1062 #define REDO     3
1063 #define PENDING  4
1064 
1065 #ifdef DEBUG
1066         printk("In scsi_done(host = %d, result = %06x)\n", host->host_no, result);
1067 #endif
1068         switch (host_byte(result))      
1069         {
1070         case DID_OK:
1071                 if (status_byte(result) && (SCpnt->flags & WAS_SENSE))
1072                         /* Failed to obtain sense information */
1073                         {
1074                         SCpnt->flags &= ~WAS_SENSE;
1075                         SCpnt->internal_timeout &= ~SENSE_TIMEOUT;
1076 
1077                         if (!(SCpnt->flags & WAS_RESET))
1078                                 {
1079                                 printk("scsi%d : target %d lun %d request sense failed, performing reset.\n", 
1080                                         SCpnt->host->host_no, SCpnt->target, SCpnt->lun);
1081                                 reset(SCpnt);
1082                                 return;
1083                                 }
1084                         else
1085                                 {
1086                                 exit = (DRIVER_HARD | SUGGEST_ABORT);
1087                                 status = FINISHED;
1088                                 }
1089                         }
1090                 else switch(msg_byte(result))
1091                         {
1092                         case COMMAND_COMPLETE:
1093                         switch (status_byte(result))
1094                         {
1095                         case GOOD:
1096                                 if (SCpnt->flags & WAS_SENSE)
1097                                         {
1098 #ifdef DEBUG
1099         printk ("In scsi_done, GOOD status, COMMAND COMPLETE, parsing sense information.\n");
1100 #endif
1101 
1102                                         SCpnt->flags &= ~WAS_SENSE;
1103                                         SCpnt->internal_timeout &= ~SENSE_TIMEOUT;
1104         
1105                                         switch (checked = check_sense(SCpnt))
1106                                         {
1107                                         case SUGGEST_SENSE:
1108                                         case 0: 
1109 #ifdef DEBUG
1110         printk("NO SENSE.  status = REDO\n");
1111 #endif
1112 
1113                                                 update_timeout(SCpnt, oldto);
1114                                                 status = REDO;
1115                                                 break;
1116                                         case SUGGEST_IS_OK:
1117                                                 break;
1118                                         case SUGGEST_REMAP:                     
1119                                         case SUGGEST_RETRY: 
1120 #ifdef DEBUG
1121         printk("SENSE SUGGEST REMAP or SUGGEST RETRY - status = MAYREDO\n");
1122 #endif
1123 
1124                                                 status = MAYREDO;
1125                                                 exit = DRIVER_SENSE | SUGGEST_RETRY;
1126                                                 break;
1127                                         case SUGGEST_ABORT:
1128 #ifdef DEBUG
1129         printk("SENSE SUGGEST ABORT - status = FINISHED");
1130 #endif
1131 
1132                                                 status = FINISHED;
1133                                                 exit =  DRIVER_SENSE | SUGGEST_ABORT;
1134                                                 break;
1135                                         default:
1136                                                 printk ("Internal error %s %d \n", __FILE__, 
1137                                                         __LINE__);
1138                                         }                          
1139                                         }       
1140                                 else
1141                                         {
1142 #ifdef DEBUG
1143         printk("COMMAND COMPLETE message returned, status = FINISHED. \n");
1144 #endif
1145 
1146                                         exit =  DRIVER_OK;
1147                                         status = FINISHED;
1148                                         }
1149                                 break;  
1150 
1151                         case CHECK_CONDITION:
1152                                 switch (check_sense(SCpnt))
1153                                   {
1154                                   case 0: 
1155                                     update_timeout(SCpnt, oldto);
1156                                     status = REDO;
1157                                     break;
1158                                   case SUGGEST_REMAP:                   
1159                                   case SUGGEST_RETRY:
1160                                     status = MAYREDO;
1161                                     exit = DRIVER_SENSE | SUGGEST_RETRY;
1162                                     break;
1163                                   case SUGGEST_ABORT:
1164                                     status = FINISHED;
1165                                     exit =  DRIVER_SENSE | SUGGEST_ABORT;
1166                                     break;
1167                                   case SUGGEST_SENSE:
1168                                 scsi_request_sense (SCpnt);
1169                                 status = PENDING;
1170                                 break;          
1171                                   }
1172                                 break;          
1173                         
1174                         case CONDITION_GOOD:
1175                         case INTERMEDIATE_GOOD:
1176                         case INTERMEDIATE_C_GOOD:
1177                                 break;
1178                                 
1179                         case BUSY:
1180                                 update_timeout(SCpnt, oldto);
1181                                 status = REDO;
1182                                 break;
1183 
1184                         case RESERVATION_CONFLICT:
1185                                 printk("scsi%d : RESERVATION CONFLICT performing reset.\n", 
1186                                         SCpnt->host->host_no);
1187                                 reset(SCpnt);
1188                                 return;
1189 #if 0
1190                                 exit = DRIVER_SOFT | SUGGEST_ABORT;
1191                                 status = MAYREDO;
1192                                 break;
1193 #endif
1194                         default:
1195                                 printk ("Internal error %s %d \n"
1196                                         "status byte = %d \n", __FILE__, 
1197                                         __LINE__, status_byte(result));
1198                                 
1199                         }
1200                         break;
1201                         default:
1202                                 panic("scsi: unsupported message byte %d recieved\n", msg_byte(result)); 
1203                         }
1204                         break;
1205         case DID_TIME_OUT:      
1206 #ifdef DEBUG
1207         printk("Host returned DID_TIME_OUT - ");
1208 #endif
1209 
1210                 if (SCpnt->flags & WAS_TIMEDOUT)
1211                         {
1212 #ifdef DEBUG
1213         printk("Aborting\n");
1214 #endif  
1215                         exit = (DRIVER_TIMEOUT | SUGGEST_ABORT);
1216                         }               
1217                 else 
1218                         {
1219 #ifdef DEBUG
1220                         printk ("Retrying.\n");
1221 #endif
1222                         SCpnt->flags  |= WAS_TIMEDOUT;
1223                         SCpnt->internal_timeout &= ~IN_ABORT;
1224                         status = REDO;
1225                         }
1226                 break;
1227         case DID_BUS_BUSY:
1228         case DID_PARITY:
1229                 status = REDO;
1230                 break;
1231         case DID_NO_CONNECT:
1232 #ifdef DEBUG
1233                 printk("Couldn't connect.\n");
1234 #endif
1235                 exit  = (DRIVER_HARD | SUGGEST_ABORT);
1236                 break;
1237         case DID_ERROR: 
1238                 status = MAYREDO;
1239                 exit = (DRIVER_HARD | SUGGEST_ABORT);
1240                 break;
1241         case DID_BAD_TARGET:
1242         case DID_ABORT:
1243                 exit = (DRIVER_INVALID | SUGGEST_ABORT);
1244                 break;  
1245         case DID_RESET:
1246                 if (SCpnt->flags & IS_RESETTING)
1247                         {
1248                         SCpnt->flags &= ~IS_RESETTING;
1249                         status = REDO;
1250                         break;
1251                         }
1252 
1253                 if(msg_byte(result) == GOOD &&
1254                       status_byte(result) == CHECK_CONDITION) {
1255                         switch (check_sense(SCpnt)) {
1256                         case 0: 
1257                             update_timeout(SCpnt, oldto);
1258                             status = REDO;
1259                             break;
1260                         case SUGGEST_REMAP:                     
1261                         case SUGGEST_RETRY:
1262                             status = MAYREDO;
1263                             exit = DRIVER_SENSE | SUGGEST_RETRY;
1264                             break;
1265                         case SUGGEST_ABORT:
1266                             status = FINISHED;
1267                             exit =  DRIVER_SENSE | SUGGEST_ABORT;
1268                             break;
1269                         case SUGGEST_SENSE:
1270                               scsi_request_sense (SCpnt);
1271                               status = PENDING;
1272                               break;
1273                         }
1274                 } else {
1275                 status=REDO;
1276                 exit = SUGGEST_RETRY;
1277                 }
1278                 break;
1279         default :               
1280                 exit = (DRIVER_ERROR | SUGGEST_DIE);
1281         }
1282 
1283         switch (status) 
1284                 {
1285                 case FINISHED:
1286                 case PENDING:
1287                         break;
1288                 case MAYREDO:
1289 
1290 #ifdef DEBUG
1291         printk("In MAYREDO, allowing %d retries, have %d\n",
1292                SCpnt->allowed, SCpnt->retries);
1293 #endif
1294 
1295                         if ((++SCpnt->retries) < SCpnt->allowed)
1296                         {
1297                         if ((SCpnt->retries >= (SCpnt->allowed >> 1))
1298                             && !(SCpnt->flags & WAS_RESET))
1299                                 {
1300                                         printk("scsi%d : reseting for second half of retries.\n",
1301                                                 SCpnt->host->host_no);
1302                                         reset(SCpnt);
1303                                         break;
1304                                 }
1305 
1306                         }
1307                         else
1308                                 {
1309                                 status = FINISHED;
1310                                 break;
1311                                 }
1312                         /* fall through to REDO */
1313 
1314                 case REDO:
1315                         if (SCpnt->flags & WAS_SENSE)                   
1316                                 scsi_request_sense(SCpnt);      
1317                         else    
1318                           {
1319                             memcpy ((void *) SCpnt->cmnd,
1320                                     (void*) SCpnt->data_cmnd, 
1321                                     sizeof(SCpnt->data_cmnd));
1322                             SCpnt->request_buffer = SCpnt->buffer;
1323                             SCpnt->request_bufflen = SCpnt->bufflen;
1324                             SCpnt->use_sg = SCpnt->old_use_sg;
1325                             internal_cmnd (SCpnt);
1326                           };
1327                         break;  
1328                 default: 
1329                         INTERNAL_ERROR;
1330                 }
1331 
1332         if (status == FINISHED) 
1333                 {
1334                 #ifdef DEBUG
1335                         printk("Calling done function - at address %08x\n", SCpnt->done);
1336                 #endif
1337                 host->host_busy--; /* Indicate that we are free */
1338                 wake_up(&host->host_wait);
1339                 SCpnt->result = result | ((exit & 0xff) << 24);
1340                 SCpnt->use_sg = SCpnt->old_use_sg;
1341                 SCpnt->done (SCpnt);
1342                 }
1343 
1344 
1345 #undef FINISHED
1346 #undef REDO
1347 #undef MAYREDO
1348 #undef PENDING
1349         }
1350 
1351 /*
1352         The scsi_abort function interfaces with the abort() function of the host
1353         we are aborting, and causes the current command to not complete.  The 
1354         caller should deal with any error messages or status returned on the 
1355         next call.
1356         
1357         This will not be called rentrantly for a given host.
1358 */
1359         
1360 /*
1361         Since we're nice guys and specified that abort() and reset()
1362         can be non-reentrant.  The internal_timeout flags are used for
1363         this.
1364 */
1365 
1366 
1367 int scsi_abort (Scsi_Cmnd * SCpnt, int why)
     /*  */
1368         {
1369         int oldto;
1370         struct Scsi_Host * host = SCpnt->host;
1371         
1372         while(1)        
1373                 {
1374                 cli();
1375                 if (SCpnt->internal_timeout & IN_ABORT) 
1376                         {
1377                         sti();
1378                         while (SCpnt->internal_timeout & IN_ABORT);
1379                         }
1380                 else
1381                         {       
1382                         SCpnt->internal_timeout |= IN_ABORT;
1383                         oldto = update_timeout(SCpnt, ABORT_TIMEOUT);
1384 
1385                         if ((SCpnt->flags & IS_RESETTING) && 
1386                             SCpnt->device->soft_reset) {
1387                           /* OK, this command must have died when we did the
1388                              reset.  The device itself must have lied. */
1389                           printk("Stale command on %d:%d appears to have died when"
1390                                  " the bus was reset\n", SCpnt->target, SCpnt->lun);
1391                         }
1392                         
1393                         sti();
1394                         if (!host->host_busy) {
1395                           SCpnt->internal_timeout &= ~IN_ABORT;
1396                           update_timeout(SCpnt, oldto);
1397                           return 0;
1398                         }
1399                         SCpnt->abort_reason = why;
1400                         switch(host->hostt->abort(SCpnt)) {
1401                           /* We do not know how to abort.  Try waiting another
1402                              time increment and see if this helps. Set the
1403                              WAS_TIMEDOUT flag set so we do not try this twice
1404                              */
1405                         case SCSI_ABORT_BUSY: /* Tough call - returning 1 from
1406                                                  this is too severe */
1407                         case SCSI_ABORT_SNOOZE:
1408                           if(why == DID_TIME_OUT) {
1409                             cli();
1410                             SCpnt->internal_timeout &= ~IN_ABORT;
1411                             if(SCpnt->flags & WAS_TIMEDOUT) {
1412                               sti();
1413                               return 1; /* Indicate we cannot handle this.
1414                                            We drop down into the reset handler
1415                                            and try again */
1416                             } else {
1417                               SCpnt->flags |= WAS_TIMEDOUT;
1418                               oldto = SCpnt->timeout_per_command;
1419                               update_timeout(SCpnt, oldto);
1420                             }
1421                             sti();
1422                           }
1423                           return 0;
1424                         case SCSI_ABORT_PENDING:
1425                           if(why != DID_TIME_OUT) {
1426                             cli();
1427                             update_timeout(SCpnt, oldto);
1428                             sti();
1429                           }
1430                           return 0;
1431                         case SCSI_ABORT_SUCCESS:
1432                           /* We should have already aborted this one.  No
1433                              need to adjust timeout */
1434                         case SCSI_ABORT_NOT_RUNNING:
1435                           SCpnt->internal_timeout &= ~IN_ABORT;
1436                           return 0;
1437                         case SCSI_ABORT_ERROR:
1438                         default:
1439                           SCpnt->internal_timeout &= ~IN_ABORT;
1440                           return 1;
1441                         }
1442                       }
1443               } 
1444       }
1445      
1446 int scsi_reset (Scsi_Cmnd * SCpnt)
     /*  */
1447         {
1448         int temp, oldto;
1449         Scsi_Cmnd * SCpnt1;
1450         struct Scsi_Host * host = SCpnt->host;
1451         
1452 #ifdef DEBUG
1453         printk("Danger Will Robinson! - SCSI bus for host %d is being reset.\n",host->host_no);
1454 #endif
1455         while (1) {
1456                 cli();  
1457                 if (SCpnt->internal_timeout & IN_RESET)
1458                         {
1459                         sti();
1460                         while (SCpnt->internal_timeout & IN_RESET);
1461                         }
1462                 else
1463                         {
1464                         SCpnt->internal_timeout |= IN_RESET;
1465                         oldto = update_timeout(SCpnt, RESET_TIMEOUT);   
1466                                         
1467                         if (host->host_busy)
1468                                 {       
1469                                 sti();
1470                                 SCpnt1 = host->host_queue;
1471                                 while(SCpnt1) {
1472                                   if (SCpnt1->request.dev > 0) {
1473 #if 0                             
1474                                     if (!(SCpnt1->flags & IS_RESETTING) && 
1475                                       !(SCpnt1->internal_timeout & IN_ABORT))
1476                                     scsi_abort(SCpnt1, DID_RESET);
1477 #endif
1478                                     SCpnt1->flags |= IS_RESETTING;
1479                                   }
1480                                   SCpnt1 = SCpnt1->next;
1481                                 };
1482 
1483                                 temp = host->hostt->reset(SCpnt);       
1484                                 }                               
1485                         else
1486                                 {
1487                                 host->host_busy++;
1488         
1489                                 sti();
1490                                 temp = host->hostt->reset(SCpnt);
1491                                 host->last_reset = jiffies;
1492                                 host->host_busy--;
1493                                 }
1494 
1495 #ifdef DEBUG
1496                         printk("scsi reset function returned %d\n", temp);
1497 #endif
1498                         switch(temp) {
1499                         case SCSI_RESET_SUCCESS:
1500                           cli();
1501                           SCpnt->internal_timeout &= ~IN_RESET;
1502                           update_timeout(SCpnt, oldto);
1503                           sti();
1504                           return 0;
1505                         case SCSI_RESET_PENDING:
1506                           return 0;
1507                         case SCSI_RESET_PUNT:
1508                         case SCSI_RESET_WAKEUP:
1509                           SCpnt->internal_timeout &= ~IN_RESET;
1510                           scsi_request_sense (SCpnt);
1511                           return 0;
1512                         case SCSI_RESET_SNOOZE:                   
1513                           /* In this case, we set the timeout field to 0
1514                              so that this command does not time out any more,
1515                              and we return 1 so that we get a message on the
1516                              screen. */
1517                           cli();
1518                           SCpnt->internal_timeout &= ~IN_RESET;
1519                           update_timeout(SCpnt, 0);
1520                           sti();
1521                           /* If you snooze, you lose... */
1522                         case SCSI_RESET_ERROR:
1523                         default:
1524                           return 1;
1525                         }
1526         
1527                         return temp;    
1528                         }
1529                 }
1530         }
1531                          
1532 
1533 static void scsi_main_timeout(void)
     /*  */
1534         {
1535         /*
1536                 We must not enter update_timeout with a timeout condition still pending.
1537         */
1538 
1539         int timed_out;
1540         struct Scsi_Host * host;
1541         Scsi_Cmnd * SCpnt = NULL;
1542 
1543         do      {       
1544                 cli();
1545 
1546                 update_timeout(NULL, 0);
1547         /*
1548                 Find all timers such that they have 0 or negative (shouldn't happen)
1549                 time remaining on them.
1550         */
1551                         
1552                 timed_out = 0;
1553                 for(host = scsi_hostlist; host; host = host->next) {
1554                   for(SCpnt = host->host_queue; SCpnt; SCpnt = SCpnt->next)
1555                     if (SCpnt->timeout == -1)
1556                       {
1557                         sti();
1558                         SCpnt->timeout = 0;
1559                         scsi_times_out(SCpnt);
1560                         ++timed_out; 
1561                         cli();
1562                       }
1563                 };
1564               } while (timed_out);      
1565         sti();
1566       }
1567 
1568 /*
1569         The strategy is to cause the timer code to call scsi_times_out()
1570         when the soonest timeout is pending.  
1571         The arguments are used when we are queueing a new command, because
1572         we do not want to subtract the time used from this time, but when we
1573         set the timer, we want to take this value into account.
1574 */
1575         
1576 static int update_timeout(Scsi_Cmnd * SCset, int timeout)
     /*  */
1577         {
1578         unsigned int least, used;
1579         unsigned int oldto;
1580         struct Scsi_Host * host;
1581         Scsi_Cmnd * SCpnt = NULL;
1582 
1583         cli();
1584 
1585 /* 
1586         Figure out how much time has passed since the last time the timeouts 
1587         were updated 
1588 */
1589         used = (time_start) ? (jiffies - time_start) : 0;
1590 
1591 /*
1592         Find out what is due to timeout soonest, and adjust all timeouts for
1593         the amount of time that has passed since the last time we called 
1594         update_timeout. 
1595 */
1596         
1597         oldto = 0;
1598 
1599         if(SCset){
1600           oldto = SCset->timeout - used;
1601           SCset->timeout = timeout + used;
1602         };
1603 
1604         least = 0xffffffff;
1605 
1606         for(host = scsi_hostlist; host; host = host->next)
1607           for(SCpnt = host->host_queue; SCpnt; SCpnt = SCpnt->next)
1608             if (SCpnt->timeout > 0) {
1609               SCpnt->timeout -= used;
1610               if(SCpnt->timeout <= 0) SCpnt->timeout = -1;
1611               if(SCpnt->timeout > 0 && SCpnt->timeout < least)
1612                 least = SCpnt->timeout;
1613             };
1614 
1615 /*
1616         If something is due to timeout again, then we will set the next timeout 
1617         interrupt to occur.  Otherwise, timeouts are disabled.
1618 */
1619         
1620         if (least != 0xffffffff)
1621                 {
1622                 time_start = jiffies;   
1623                 timer_table[SCSI_TIMER].expires = (time_elapsed = least) + jiffies;     
1624                 timer_active |= 1 << SCSI_TIMER;
1625                 }
1626         else
1627                 {
1628                 timer_table[SCSI_TIMER].expires = time_start = time_elapsed = 0;
1629                 timer_active &= ~(1 << SCSI_TIMER);
1630                 }       
1631         sti();
1632         return oldto;
1633         }               
1634 
1635 
1636 static unsigned short * dma_malloc_freelist = NULL;
1637 static unsigned int dma_sectors = 0;
1638 unsigned int dma_free_sectors = 0;
1639 unsigned int need_isa_buffer = 0;
1640 static unsigned char * dma_malloc_buffer = NULL;
1641 
1642 void *scsi_malloc(unsigned int len)
     /*  */
1643 {
1644   unsigned int nbits, mask;
1645   int i, j;
1646   if((len & 0x1ff) || len > 8192)
1647     return NULL;
1648   
1649   cli();
1650   nbits = len >> 9;
1651   mask = (1 << nbits) - 1;
1652   
1653   for(i=0;i < (dma_sectors >> 4); i++)
1654     for(j=0; j<17-nbits; j++){
1655       if ((dma_malloc_freelist[i] & (mask << j)) == 0){
1656         dma_malloc_freelist[i] |= (mask << j);
1657         sti();
1658         dma_free_sectors -= nbits;
1659 #ifdef DEBUG
1660         printk("SMalloc: %d %x ",len, dma_malloc_buffer + (i << 13) + (j << 9));
1661 #endif
1662         return (void *) ((unsigned long) dma_malloc_buffer + (i << 13) + (j << 9));
1663       };
1664     };
1665   sti();
1666   return NULL;  /* Nope.  No more */
1667 }
1668 
1669 int scsi_free(void *obj, unsigned int len)
     /*  */
1670 {
1671   int offset;
1672   int page, sector, nbits, mask;
1673 
1674 #ifdef DEBUG
1675   printk("Sfree %x %d\n",obj, len);
1676 #endif
1677 
1678   offset = ((int) obj) - ((int) dma_malloc_buffer);
1679 
1680   if (offset < 0) panic("Bad offset");
1681   page = offset >> 13;
1682   sector = offset >> 9;
1683   if(sector >= dma_sectors) panic ("Bad page");
1684 
1685   sector = (offset >> 9) & 15;
1686   nbits = len >> 9;
1687   mask = (1 << nbits) - 1;
1688 
1689   if ((mask << sector) > 0xffff) panic ("Bad memory alignment");
1690 
1691   cli();
1692   if(dma_malloc_freelist[page] & (mask << sector) != (mask<<sector))
1693     panic("Trying to free unused memory");
1694 
1695   dma_free_sectors += nbits;
1696   dma_malloc_freelist[page] &= ~(mask << sector);
1697   sti();
1698   return 0;
1699 }
1700 
1701 /*
1702         scsi_dev_init() is our initialization routine, which inturn calls host 
1703         initialization, bus scanning, and sd/st initialization routines.  It 
1704         should be called from main().
1705 */
1706 
1707 unsigned long scsi_dev_init (unsigned long memory_start,unsigned long memory_end)
     /*  */
1708         {
1709         int i;
1710         struct Scsi_Host * host;
1711         Scsi_Cmnd * SCpnt;
1712 #ifdef FOO_ON_YOU
1713         return;
1714 #endif  
1715         timer_table[SCSI_TIMER].fn = scsi_main_timeout;
1716         timer_table[SCSI_TIMER].expires = 0;
1717 
1718         /* initialize all hosts */
1719         memory_start = scsi_init(memory_start, memory_end); 
1720                                 
1721         scsi_devices = (Scsi_Device *) memory_start;
1722         scan_scsis();           /* scan for scsi devices */
1723         memory_start += NR_SCSI_DEVICES * sizeof(Scsi_Device);
1724 
1725         memory_start = sd_init1(memory_start, memory_end);
1726         memory_start = st_init1(memory_start, memory_end);
1727         memory_start = sr_init1(memory_start, memory_end);
1728         memory_start = sg_init1(memory_start, memory_end);
1729 
1730         last_cmnd = (Scsi_Cmnd *) memory_start;
1731 
1732         SCpnt = last_cmnd;
1733 
1734         for (i=0; i< NR_SCSI_DEVICES; i++) {
1735           int j;
1736           scsi_devices[i].scsi_request_fn = NULL;
1737           switch (scsi_devices[i].type)
1738             {
1739             case TYPE_TAPE :
1740               st_attach(&scsi_devices[i]);
1741               break;
1742             case TYPE_ROM:
1743               sr_attach(&scsi_devices[i]);
1744               break;
1745             case TYPE_DISK:
1746             case TYPE_MOD:
1747               sd_attach(&scsi_devices[i]);
1748             default:
1749               break;
1750             };
1751           sg_attach(&scsi_devices[i]);
1752           if(scsi_devices[i].type != -1){
1753             for(j=0;j<scsi_devices[i].host->hostt->cmd_per_lun;j++){
1754               SCpnt->host = scsi_devices[i].host;
1755               SCpnt->device = &scsi_devices[i];
1756               SCpnt->target = scsi_devices[i].id;
1757               SCpnt->lun = scsi_devices[i].lun;
1758               SCpnt->index = i;
1759               SCpnt->request.dev = -1; /* Mark not busy */
1760               SCpnt->use_sg = 0;
1761               SCpnt->old_use_sg = 0;
1762               SCpnt->underflow = 0;
1763               SCpnt->transfersize = 0;
1764               SCpnt->host_scribble = NULL;
1765               host = scsi_devices[i].host;
1766               if(host->host_queue)
1767                 host->host_queue->prev = SCpnt;
1768               SCpnt->next = host->host_queue;
1769               SCpnt->prev = NULL;
1770               host->host_queue = SCpnt;
1771               SCpnt++;
1772             };
1773           };
1774         };
1775 
1776         memory_start = (int) SCpnt;
1777 
1778         if (NR_SD > 0 || NR_SR > 0 || NR_ST > 0)
1779           dma_sectors = 16;  /* Base value we use */
1780 
1781         for (i = 0; i < NR_SCSI_DEVICES; ++i) {
1782           struct Scsi_Host * host;
1783           host = scsi_devices[i].host;
1784           
1785           if(scsi_devices[i].type != TYPE_TAPE)
1786             dma_sectors += ((host->sg_tablesize * 
1787                              sizeof(struct scatterlist) + 511) >> 9) * 
1788                                host->hostt->cmd_per_lun;
1789           
1790           if(host->unchecked_isa_dma &&
1791              memory_end > ISA_DMA_THRESHOLD &&
1792              scsi_devices[i].type != TYPE_TAPE) {
1793             dma_sectors += (PAGE_SIZE >> 9) * host->sg_tablesize *
1794               host->hostt->cmd_per_lun;
1795             need_isa_buffer++;
1796           };
1797         };
1798 
1799         dma_sectors = (dma_sectors + 15) & 0xfff0;
1800         dma_free_sectors = dma_sectors;  /* This must be a multiple of 16 */
1801 
1802         memory_start = (memory_start + 3) & 0xfffffffc;
1803         dma_malloc_freelist = (unsigned short *) memory_start;
1804         memory_start += dma_sectors >> 3;
1805         memset(dma_malloc_freelist, 0, dma_sectors >> 3);
1806 
1807         if(memory_start & 1) memory_start++; /* Some host adapters require
1808                                                 buffers to be word aligned */
1809         dma_malloc_buffer = (unsigned char *) memory_start;
1810         memory_start += dma_sectors << 9;
1811 
1812         memory_start = sd_init(memory_start, memory_end); /* init scsi disks */
1813         memory_start = st_init(memory_start, memory_end); /* init scsi tapes */
1814         memory_start = sr_init(memory_start, memory_end); /* init scsi CDROMs */
1815         memory_start = sg_init(memory_start, memory_end); /* init scsi generic */
1816         
1817         return memory_start;
1818         }
1819 
1820 static void print_inquiry(unsigned char *data)
     /*  */
1821 {
1822         int i;
1823 
1824         printk("  Vendor: ");
1825         for (i = 8; i < 16; i++)
1826                 {
1827                 if (data[i] >= 0x20 && i < data[4] + 5)
1828                         printk("%c", data[i]);
1829                 else
1830                         printk(" ");
1831                 }
1832 
1833         printk("  Model: ");
1834         for (i = 16; i < 32; i++)
1835                 {
1836                 if (data[i] >= 0x20 && i < data[4] + 5)
1837                         printk("%c", data[i]);
1838                 else
1839                         printk(" ");
1840                 }
1841 
1842         printk("  Rev: ");
1843         for (i = 32; i < 36; i++)
1844                 {
1845                 if (data[i] >= 0x20 && i < data[4] + 5)
1846                         printk("%c", data[i]);
1847                 else
1848                         printk(" ");
1849                 }
1850 
1851         printk("\n");
1852 
1853         i = data[0] & 0x1f;
1854 
1855         printk("  Type:   %s ",
1856                i < MAX_SCSI_DEVICE_CODE ? scsi_device_types[i] : "Unknown          " );
1857         printk("                 ANSI SCSI revision: %02x", data[2] & 0x07);
1858         if ((data[2] & 0x07) == 1 && (data[3] & 0x0f) == 1)
1859           printk(" CCS\n");
1860         else
1861           printk("\n");
1862 }
1863 
1864 #ifdef DEBUG_TIMEOUT
1865 static void 
1866 scsi_dump_status(void)
     /*  */
1867 {
1868   int i, i1;
1869   Scsi_Cmnd * SCpnt;
1870   printk("Dump of scsi parameters:\n");
1871   SCpnt = last_cmnd;
1872   for(i=0; i<NR_SCSI_DEVICES; i++)
1873     for(i1=0; i1<scsi_devices[i].host->hostt->cmd_per_lun;i1++)
1874       {
1875         /*  (0) 0:0:0 (802 123434 8 8 0) (3 3 2) (%d %d %d) %d %x      */
1876         printk("(%d) %d:%d:%d (%4.4x %d %d %d %d) (%d %d %x) (%d %d %d) %x %x %d %x\n",
1877                i, SCpnt->host->host_no,
1878                SCpnt->target,
1879                SCpnt->lun,
1880                SCpnt->request.dev,
1881                SCpnt->request.sector,
1882                SCpnt->request.nr_sectors,
1883                SCpnt->request.current_nr_sectors,
1884                SCpnt->use_sg,
1885                SCpnt->retries,
1886                SCpnt->allowed,
1887                SCpnt->flags,
1888                SCpnt->timeout_per_command,
1889                SCpnt->timeout,
1890                SCpnt->internal_timeout,
1891                SCpnt->cmnd[0],
1892                SCpnt->sense_buffer[2],
1893                (SCpnt->request.waiting ? 
1894                 SCpnt->request.waiting->pid : 0),
1895                SCpnt->result);
1896         SCpnt++;
1897       };
1898   printk("wait_for_request = %x\n", wait_for_request);
1899   /* Now dump the request lists for each block device */
1900   printk("Dump of pending block device requests\n");
1901   for(i=0; i<MAX_BLKDEV; i++)
1902     if(blk_dev[i].current_request)
1903       {
1904         struct request * req;
1905         printk("%d: ", i);
1906         req = blk_dev[i].current_request;
1907         while(req) {
1908           printk("(%x %d %d %d %d %d) ",
1909                  req->dev,
1910                  req->cmd,
1911                  req->sector,
1912                  req->nr_sectors,
1913                  req->current_nr_sectors,
1914                  (req->waiting ? 
1915                   req->waiting->pid : 0));
1916           req = req->next;
1917         }
1918         printk("\n");
1919       }
1920 }
1921 #endif
/* */
root/drivers/scsi/scsi.c

DEFINITIONS
