root/drivers/scsi/scsi.c

/* */

DEFINITIONS

1. blacklisted
2. scsi_make_blocked_list
3. scan_scsis_done
4. scsi_luns_setup
5. scan_scsis
6. scsi_times_out
7. request_queueable
8. allocate_device
9. internal_cmnd
10. scsi_request_sense
11. scsi_do_cmd
12. reset
13. check_sense
14. scsi_done
15. scsi_abort
16. scsi_reset
17. scsi_main_timeout
18. update_timeout
19. scsi_malloc
20. scsi_free
21. scsi_init_malloc
22. scsi_init_free
23. scsi_dev_init
24. print_inquiry
25. scsi_register_host
26. scsi_unregister_host
27. scsi_register_module
28. scsi_unregister_module
29. scsi_dump_status

   1 /*
   2  *      scsi.c Copyright (C) 1992 Drew Eckhardt
   3  *             Copyright (C) 1993, 1994, 1995 Eric Youngdale
   4  *
   5  *      generic mid-level SCSI driver
   6  *              Initial versions: Drew Eckhardt
   7  *              Subsequent revisions: Eric Youngdale
   8  *
   9  *      <drew@colorado.edu>
  10  *
  11  *      Bug correction thanks go to :
  12  *              Rik Faith <faith@cs.unc.edu>
  13  *              Tommy Thorn <tthorn>
  14  *              Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
  15  *
  16  *       Modified by Eric Youngdale ericy@cais.com to
  17  *       add scatter-gather, multiple outstanding request, and other
  18  *       enhancements.
  19  */
  20 
  21 #include <asm/system.h>
  22 #include <linux/sched.h>
  23 #include <linux/timer.h>
  24 #include <linux/string.h>
  25 #include <linux/malloc.h>
  26 #include <asm/irq.h>
  27 #include <asm/dma.h>
  28 #include <linux/ioport.h>
  29 
  30 #include "../block/blk.h"
  31 #include "scsi.h"
  32 #include "hosts.h"
  33 #include "constants.h"
  34 
  35 #undef USE_STATIC_SCSI_MEMORY
  36 
  37 /*
  38 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 $";
  39 */
  40 
  41 /* Command groups 3 and 4 are reserved and should never be used.  */
  42 const unsigned char scsi_command_size[8] = { 6, 10, 10, 12, 12, 12, 10, 10 };
  43 
  44 #define INTERNAL_ERROR (panic ("Internal error in file %s, line %d.\n", __FILE__, __LINE__))
  45 
  46 static void scsi_done (Scsi_Cmnd *SCpnt);
  47 static int update_timeout (Scsi_Cmnd *, int);
  48 static void print_inquiry(unsigned char *data);
  49 static void scsi_times_out (Scsi_Cmnd * SCpnt, int pid);
  50 
  51 static int time_start;
  52 static int time_elapsed;
  53 static volatile struct Scsi_Host * host_active = NULL;
  54 #define SCSI_BLOCK(HOST) ((HOST->block && host_active && HOST != host_active) \
  55                    || (HOST->can_queue && HOST->host_busy >= HOST->can_queue))
  56 
  57 #define MAX_SCSI_DEVICE_CODE 10
  58 const char *const scsi_device_types[MAX_SCSI_DEVICE_CODE] =
  59 {
  60  "Direct-Access    ",
  61  "Sequential-Access",
  62  "Printer          ",
  63  "Processor        ",
  64  "WORM             ",
  65  "CD-ROM           ",
  66  "Scanner          ",
  67  "Optical Device   ",
  68  "Medium Changer   ",
  69  "Communications   "
  70 };
  71 
  72 
  73 /*
  74         global variables :
  75         scsi_devices an array of these specifying the address for each
  76         (host, id, LUN)
  77 */
  78 
  79 Scsi_Device * scsi_devices = NULL;
  80 
  81 /* Process ID of SCSI commands */
  82 unsigned long scsi_pid = 0;
  83 
  84 static unsigned char generic_sense[6] = {REQUEST_SENSE, 0,0,0, 255, 0};
  85 
  86 /* This variable is merely a hook so that we can debug the kernel with gdb. */
  87 Scsi_Cmnd * last_cmnd = NULL;
  88 
  89 /*
  90  *      As the scsi do command functions are intelligent, and may need to
  91  *      redo a command, we need to keep track of the last command
  92  *      executed on each one.
  93  */
  94 
  95 #define WAS_RESET       0x01
  96 #define WAS_TIMEDOUT    0x02
  97 #define WAS_SENSE       0x04
  98 #define IS_RESETTING    0x08
  99 #define IS_ABORTING     0x10
 100 #define ASKED_FOR_SENSE 0x20
 101 
 102 /*
 103  *      This is the number  of clock ticks we should wait before we time out
 104  *      and abort the command.  This is for  where the scsi.c module generates
 105  *      the command, not where it originates from a higher level, in which
 106  *      case the timeout is specified there.
 107  *
 108  *      ABORT_TIMEOUT and RESET_TIMEOUT are the timeouts for RESET and ABORT
 109  *      respectively.
 110  */
 111 
 112 #ifdef DEBUG_TIMEOUT
 113 static void scsi_dump_status(void);
 114 #endif
 115 
 116 
 117 #ifdef DEBUG
 118         #define SCSI_TIMEOUT 500
 119 #else
 120         #define SCSI_TIMEOUT 100
 121 #endif
 122 
 123 #ifdef DEBUG
 124         #define SENSE_TIMEOUT SCSI_TIMEOUT
 125         #define ABORT_TIMEOUT SCSI_TIMEOUT
 126         #define RESET_TIMEOUT SCSI_TIMEOUT
 127 #else
 128         #define SENSE_TIMEOUT 50
 129         #define RESET_TIMEOUT 50
 130         #define ABORT_TIMEOUT 50
 131 #endif
 132 
 133 #define MIN_RESET_DELAY 100
 134 
 135 /* Do not call reset on error if we just did a reset within 10 sec. */
 136 #define MIN_RESET_PERIOD 1000
 137 
 138 /* The following devices are known not to tolerate a lun != 0 scan for
 139    one reason or another.  Some will respond to all luns, others will
 140    lock up. */
 141 
 142      struct blist{
 143        char * vendor;
 144        char * model;
 145        char * revision; /* Latest revision known to be bad.  Not used yet */
 146      };
 147 
 148 static struct blist blacklist[] =
 149 {
 150    {"CHINON","CD-ROM CDS-431","H42"},  /* Locks up if polled for lun != 0 */
 151    {"CHINON","CD-ROM CDS-535","Q14"}, /* Lockup if polled for lun != 0 */
 152    {"DENON","DRD-25X","V"},   /* A cdrom that locks up when probed at lun != 0 */
 153    {"HITACHI","DK312C","CM81"},   /* Responds to all lun - dtg */
 154    {"HITACHI","DK314C","CR21" }, /* responds to all lun */
 155    {"IMS", "CDD521/10","2.06"},   /* Locks-up when LUN>0 polled. */
 156    {"MAXTOR","XT-3280","PR02"},   /* Locks-up when LUN>0 polled. */
 157    {"MAXTOR","XT-4380S","B3C"},   /* Locks-up when LUN>0 polled. */
 158    {"MAXTOR","MXT-1240S","I1.2"}, /* Locks up when LUN > 0 polled */
 159    {"MAXTOR","XT-4170S","B5A"},   /* Locks-up sometimes when LUN>0 polled. */
 160    {"MAXTOR","XT-8760S","B7B"},   /* guess what? */
 161    {"NEC","CD-ROM DRIVE:841","1.0"},  /* Locks-up when LUN>0 polled. */
 162    {"RODIME","RO3000S","2.33"},  /* Locks up if polled for lun != 0 */
 163    {"SEAGATE", "ST157N", "\004|j"}, /* causes failed REQUEST SENSE on lun 1 for aha152x
 164                                      * controller, which causes SCSI code to reset bus.*/
 165    {"SEAGATE", "ST296","921"},   /* Responds to all lun */
 166    {"SONY","CD-ROM CDU-541","4.3d"},
 167    {"SONY","CD-ROM CDU-55S","1.0i"},
 168    {"TANDBERG","TDC 3600","U07"},  /* Locks up if polled for lun != 0 */
 169    {"TEAC","CD-ROM","1.06"},    /* causes failed REQUEST SENSE on lun 1 for seagate
 170                                  * controller, which causes SCSI code to reset bus.*/
 171    {"TEXEL","CD-ROM","1.06"},   /* causes failed REQUEST SENSE on lun 1 for seagate
 172                                  * controller, which causes SCSI code to reset bus.*/
 173    {"QUANTUM","LPS525S","3110"},/* Locks sometimes if polled for lun != 0 */
 174    {"QUANTUM","PD1225S","3110"},/* Locks sometimes if polled for lun != 0 */
 175    {"MEDIAVIS","CDR-H93MV","1.31"},  /* Locks up if polled for lun != 0 */
 176    {"SANKYO", "CP525","6.64"},  /* causes failed REQ SENSE, extra reset */
 177    {"HP", "C1750A", "3226"},    /* scanjet iic */
 178    {"HP", "C1790A", ""},        /* scanjet iip */
 179    {"HP", "C2500A", ""},        /* scanjet iicx */
 180    {NULL, NULL, NULL}};
 181 
 182 static int blacklisted(unsigned char * response_data){
     /*  */
 183   int i = 0;
 184   unsigned char * pnt;
 185   for(i=0; 1; i++){
 186     if(blacklist[i].vendor == NULL) return 0;
 187     pnt = &response_data[8];
 188     while(*pnt && *pnt == ' ') pnt++;
 189     if(memcmp(blacklist[i].vendor, pnt,
 190                strlen(blacklist[i].vendor))) continue;
 191     pnt = &response_data[16];
 192     while(*pnt && *pnt == ' ') pnt++;
 193     if(memcmp(blacklist[i].model, pnt,
 194                strlen(blacklist[i].model))) continue;
 195     return 1;
 196   }
 197 }
 198 
 199 /*
 200  *      As the actual SCSI command runs in the background, we must set up a
 201  *      flag that tells scan_scsis() when the result it has is valid.
 202  *      scan_scsis can set the_result to -1, and watch for it to become the
 203  *      actual return code for that call.  the scan_scsis_done function() is
 204  *      our user specified completion function that is passed on to the
 205  *      scsi_do_cmd() function.
 206  */
 207 
 208 volatile int in_scan_scsis = 0;
 209 static int the_result;
 210 
 211 void scsi_make_blocked_list(void)  {
     /*  */
 212   int block_count = 0, index;
 213   unsigned int flags;
 214   struct Scsi_Host * sh[128], * shpnt;
 215 
 216   /*
 217    * Create a circular linked list from the scsi hosts which have
 218    * the "wish_block" field in the Scsi_Host structure set.
 219    * The blocked list should include all the scsi hosts using ISA DMA.
 220    * In some systems, using two dma channels simultaneously causes
 221    * unpredictable results.
 222    * Among the scsi hosts in the blocked list, only one host at a time
 223    * is allowed to have active commands queued. The transition from
 224    * one active host to the next one is allowed only when host_busy == 0
 225    * for the active host (which implies host_busy == 0 for all the hosts
 226    * in the list). Moreover for block devices the transition to a new
 227    * active host is allowed only when a request is completed, since a
 228    * block device request can be divided into multiple scsi commands
 229    * (when there are few sg lists or clustering is disabled).
 230    *
 231    * (DB, 4 Feb 1995)
 232    */
 233 
 234   save_flags(flags);
 235   cli();
 236   host_active = NULL;
 237 
 238   for(shpnt=scsi_hostlist; shpnt; shpnt = shpnt->next) {
 239 
 240 #if 0
 241      /*
 242       * Is this is a candidate for the blocked list?
 243       * Useful to put into the blocked list all the hosts whose driver
 244       * does not know about the host->block feature.
 245       */
 246      if (shpnt->unchecked_isa_dma) shpnt->wish_block = 1;
 247 #endif
 248 
 249      if (shpnt->wish_block) sh[block_count++] = shpnt;
 250      }
 251 
 252   if (block_count == 1) sh[0]->block = NULL;
 253 
 254   else if (block_count > 1) {
 255 
 256      for(index = 0; index < block_count - 1; index++) {
 257         sh[index]->block = sh[index + 1];
 258         printk("scsi%d : added to blocked host list.\n",
 259                sh[index]->host_no);
 260         }
 261 
 262      sh[block_count - 1]->block = sh[0];
 263      printk("scsi%d : added to blocked host list.\n",
 264             sh[index]->host_no);
 265      }
 266 
 267   restore_flags(flags);
 268   }
 269 
 270 static void scan_scsis_done (Scsi_Cmnd * SCpnt)
     /*  */
 271         {
 272 
 273 #ifdef DEBUG
 274         printk ("scan_scsis_done(%d, %06x)\n", SCpnt->host, SCpnt->result);
 275 #endif
 276         SCpnt->request.dev = 0xfffe;
 277 
 278         if (SCpnt->request.sem != NULL)
 279           up(SCpnt->request.sem);
 280         }
 281 
 282 #ifdef CONFIG_SCSI_MULTI_LUN
 283 static int max_scsi_luns = 8;
 284 #else
 285 static int max_scsi_luns = 1;
 286 #endif
 287 
 288 void scsi_luns_setup(char *str, int *ints) {
     /*  */
 289     if (ints[0] != 1)
 290         printk("scsi_luns_setup : usage max_scsi_luns=n (n should be between 1 and 8)\n");
 291     else
 292         max_scsi_luns = ints[1];
 293 }
 294 
 295 /*
 296  *      Detecting SCSI devices :
 297  *      We scan all present host adapter's busses,  from ID 0 to ID 6.
 298  *      We use the INQUIRY command, determine device type, and pass the ID /
 299  *      lun address of all sequential devices to the tape driver, all random
 300  *      devices to the disk driver.
 301  */
 302 
 303 void scan_scsis (struct Scsi_Host * shpnt)
     /*  */
 304 {
 305   int dev, lun, type;
 306   unsigned char scsi_cmd [12];
 307   unsigned char scsi_result0 [256];
 308   unsigned char * scsi_result;
 309   Scsi_Device * SDpnt, *SDtail;
 310   struct Scsi_Device_Template * sdtpnt;
 311   Scsi_Cmnd  *SCpnt;
 312 
 313   ++in_scan_scsis;
 314   lun = 0;
 315   type = -1;
 316   SCpnt = (Scsi_Cmnd *) scsi_init_malloc(sizeof(Scsi_Cmnd), GFP_ATOMIC|GFP_DMA);
 317   SDpnt = (Scsi_Device *) scsi_init_malloc(sizeof (Scsi_Device), GFP_ATOMIC);
 318   SDtail = scsi_devices;
 319 
 320   if(scsi_devices) while(SDtail->next) SDtail = SDtail->next;
 321 
 322   /* Make sure we have something that is valid for DMA purposes */
 323   scsi_result = ((current == task[0]  || !shpnt->unchecked_isa_dma)
 324                  ?  &scsi_result0[0] : scsi_malloc(512));
 325 
 326 
 327   shpnt->host_queue = SCpnt;  /* We need this so that commands can time out */
 328 
 329   for (dev = 0; dev < 8; ++dev)
 330     if (shpnt->this_id != dev)
 331 
 332 /*
 333  * We need the for so our continue, etc. work fine.
 334  */
 335       for (lun = 0; lun < max_scsi_luns; ++lun)
 336         {
 337           memset(SDpnt, 0, sizeof(Scsi_Device));
 338           SDpnt->host = shpnt;
 339           SDpnt->id = dev;
 340           SDpnt->lun = lun;
 341 
 342           /* Some low level driver could use device->type (DB) */
 343           SDpnt->type = -1;
 344 /*
 345  * Assume that the device will have handshaking problems, and then
 346  * fix this field later if it turns out it doesn't.
 347  */
 348           SDpnt->borken = 1;
 349 
 350           scsi_cmd[0] = TEST_UNIT_READY;
 351           scsi_cmd[1] = lun << 5;
 352           scsi_cmd[2] = scsi_cmd[3] = scsi_cmd[4] = scsi_cmd[5] = 0;
 353 
 354           memset(SCpnt, 0,  sizeof(Scsi_Cmnd));
 355           SCpnt->host = SDpnt->host;
 356           SCpnt->device = SDpnt;
 357           SCpnt->target = SDpnt->id;
 358           SCpnt->lun = SDpnt->lun;
 359 
 360           /* Used for mutex if loading devices after boot */
 361           SCpnt->request.sem = NULL;
 362 
 363           SCpnt->request.dev = 0xffff; /* Mark not busy */
 364 
 365           scsi_do_cmd (SCpnt, (void *)  scsi_cmd, (void *) scsi_result,
 366                        256,  scan_scsis_done, SCSI_TIMEOUT + 400, 5);
 367 
 368           /* Wait for command to finish. Use simple wait if we are booting, else
 369              do it right and use a mutex */
 370 
 371           if (current == task[0])
 372               while (SCpnt->request.dev != 0xfffe);
 373           else if (SCpnt->request.dev != 0xfffe) {
 374               struct semaphore sem = MUTEX_LOCKED;
 375 
 376               SCpnt->request.sem = &sem;
 377               down(&sem);
 378 
 379               /* Hmm.. Have to ask about this one */
 380               while (SCpnt->request.dev != 0xfffe) schedule();
 381               }
 382 
 383 #if defined(DEBUG) || defined(DEBUG_INIT)
 384           printk("scsi: scan SCSIS id %d lun %d\n", dev, lun);
 385           printk("scsi: return code %08x\n", SCpnt->result);
 386 #endif
 387 
 388 
 389           if(SCpnt->result) {
 390             if ((driver_byte(SCpnt->result)  & DRIVER_SENSE) &&
 391                 ((SCpnt->sense_buffer[0] & 0x70) >> 4) == 7) {
 392               if (SCpnt->sense_buffer[2] &0xe0)
 393                 continue; /* No devices here... */
 394               if(((SCpnt->sense_buffer[2] & 0xf) != NOT_READY) &&
 395                  ((SCpnt->sense_buffer[2] & 0xf) != UNIT_ATTENTION))
 396                 continue;
 397             }
 398             else
 399               break;
 400           }
 401 
 402 #if defined (DEBUG) || defined(DEBUG_INIT)
 403           printk("scsi: performing INQUIRY\n");
 404 #endif
 405 
 406           /*
 407            * Build an INQUIRY command block.
 408            */
 409           scsi_cmd[0] = INQUIRY;
 410           scsi_cmd[1] = (lun << 5) & 0xe0;
 411           scsi_cmd[2] = 0;
 412           scsi_cmd[3] = 0;
 413           scsi_cmd[4] = 255;
 414           scsi_cmd[5] = 0;
 415 
 416           SCpnt->request.dev = 0xffff; /* Mark not busy */
 417           SCpnt->cmd_len = 0;
 418 
 419           scsi_do_cmd (SCpnt, (void *)  scsi_cmd, (void *) scsi_result,
 420                        256,  scan_scsis_done, SCSI_TIMEOUT, 3);
 421 
 422           if (current == task[0])
 423               while (SCpnt->request.dev != 0xfffe);
 424           else if (SCpnt->request.dev != 0xfffe) {
 425               struct semaphore sem = MUTEX_LOCKED;
 426 
 427               SCpnt->request.sem = &sem;
 428               down(&sem);
 429 
 430               /* Hmm.. Have to ask about this one */
 431               while (SCpnt->request.dev != 0xfffe) schedule();
 432               }
 433 
 434           the_result = SCpnt->result;
 435 
 436 #if defined(DEBUG) || defined(DEBUG_INIT)
 437           if (!the_result)
 438             printk("scsi: INQUIRY successful\n");
 439           else
 440             printk("scsi: INQUIRY failed with code %08x\n", the_result);
 441 #endif
 442 
 443           if(the_result) break;
 444 
 445           /* skip other luns on this device */
 446 
 447           if (!the_result)
 448             {
 449                 /* It would seem some TOSHIBA CD-ROM gets things wrong */
 450                 if (!strncmp(scsi_result+8,"TOSHIBA",7) &&
 451                     !strncmp(scsi_result+16,"CD-ROM",6) &&
 452                     scsi_result[0] == TYPE_DISK) {
 453                         scsi_result[0] = TYPE_ROM;
 454                         scsi_result[1] |= 0x80;  /* removable */
 455                 }
 456 
 457               SDpnt->manufacturer = SCSI_MAN_UNKNOWN;
 458               if (!strncmp(scsi_result+8,"NEC",3))
 459                 SDpnt->manufacturer = SCSI_MAN_NEC;
 460               if (!strncmp(scsi_result+8,"TOSHIBA",7))
 461                 SDpnt->manufacturer = SCSI_MAN_TOSHIBA;
 462 
 463               SDpnt->removable = (0x80 &
 464                                   scsi_result[1]) >> 7;
 465               SDpnt->lockable = SDpnt->removable;
 466               SDpnt->changed = 0;
 467               SDpnt->access_count = 0;
 468               SDpnt->busy = 0;
 469 /*
 470  *      Currently, all sequential devices are assumed to be tapes,
 471  *      all random devices disk, with the appropriate read only
 472  *      flags set for ROM / WORM treated as RO.
 473  */
 474 
 475               switch (type = (scsi_result[0] & 0x1f))
 476                 {
 477                 case TYPE_TAPE :
 478                 case TYPE_DISK :
 479                 case TYPE_MOD :
 480                 case TYPE_PROCESSOR :
 481                 case TYPE_SCANNER :
 482                   SDpnt->writeable = 1;
 483                   break;
 484                 case TYPE_WORM :
 485                 case TYPE_ROM :
 486                   SDpnt->writeable = 0;
 487                   break;
 488                 default :
 489 #if 0
 490 #ifdef DEBUG
 491                   printk("scsi: unknown type %d\n", type);
 492                   print_inquiry(scsi_result);
 493 #endif
 494                   type = -1;
 495 #endif
 496                 }
 497 
 498               SDpnt->soft_reset =
 499                 (scsi_result[7] & 1) && ((scsi_result[3] & 7) == 2);
 500               SDpnt->random = (type == TYPE_TAPE) ? 0 : 1;
 501               SDpnt->type = (type & 0x1f);
 502 
 503               if (type != -1)
 504                 {
 505                   print_inquiry(scsi_result);
 506 
 507                   for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
 508                     if(sdtpnt->detect) SDpnt->attached +=
 509                       (*sdtpnt->detect)(SDpnt);
 510 
 511                   SDpnt->scsi_level = scsi_result[2] & 0x07;
 512                   if (SDpnt->scsi_level >= 2 ||
 513                       (SDpnt->scsi_level == 1 &&
 514                        (scsi_result[3] & 0x0f) == 1))
 515                     SDpnt->scsi_level++;
 516 /*
 517  * Set the tagged_queue flag for SCSI-II devices that purport to support
 518  * tagged queuing in the INQUIRY data.
 519  */
 520 
 521                   SDpnt->tagged_queue = 0;
 522 
 523                   if ((SDpnt->scsi_level >= SCSI_2) &&
 524                       (scsi_result[7] & 2)) {
 525                     SDpnt->tagged_supported = 1;
 526                     SDpnt->current_tag = 0;
 527                   }
 528 
 529 /*
 530  * Accommodate drivers that want to sleep when they should be in a polling
 531  * loop.
 532  */
 533 
 534                   SDpnt->disconnect = 0;
 535 
 536 /*
 537  * Some revisions of the Texel CD ROM drives have handshaking
 538  * problems when used with the Seagate controllers.  Before we
 539  * know what type of device we're talking to, we assume it's
 540  * borken and then change it here if it turns out that it isn't
 541  * a TEXEL drive.
 542  */
 543 
 544                   if(strncmp("TEXEL", (char *) &scsi_result[8], 5) != 0 ||
 545                      strncmp("CD-ROM", (char *) &scsi_result[16], 6) != 0
 546 /*
 547  * XXX 1.06 has problems, some one should figure out the others too so
 548  * ALL TEXEL drives don't suffer in performance, especially when I finish
 549  * integrating my seagate patches which do multiple I_T_L nexuses.
 550  */
 551 
 552 #ifdef notyet
 553                      || (strncmp("1.06", (char *) &scsi_result[[, 4) != 0)))
 554 #endif
 555                                  )
 556                     SDpnt->borken = 0;
 557 
 558 
 559                   /* These devices need this "key" to unlock the device
 560                      so we can use it */
 561                   if(memcmp("INSITE", &scsi_result[8], 6) == 0 &&
 562                      (memcmp("Floptical   F*8I", &scsi_result[16], 16) == 0
 563                       || memcmp("I325VM", &scsi_result[16], 6) == 0)) {
 564                     printk("Unlocked floptical drive.\n");
 565                     SDpnt->lockable = 0;
 566                     scsi_cmd[0] = MODE_SENSE;
 567                     scsi_cmd[1] = (lun << 5) & 0xe0;
 568                     scsi_cmd[2] = 0x2e;
 569                     scsi_cmd[3] = 0;
 570                     scsi_cmd[4] = 0x2a;
 571                     scsi_cmd[5] = 0;
 572 
 573                     SCpnt->request.dev = 0xffff; /* Mark not busy */
 574                     SCpnt->cmd_len = 0;
 575 
 576                     scsi_do_cmd (SCpnt, (void *)  scsi_cmd,
 577                                  (void *) scsi_result, 0x2a,  scan_scsis_done,
 578                                  SCSI_TIMEOUT, 3);
 579 
 580                     if (current == task[0])
 581                         while (SCpnt->request.dev != 0xfffe);
 582                     else if (SCpnt->request.dev != 0xfffe) {
 583                         struct semaphore sem = MUTEX_LOCKED;
 584 
 585                         SCpnt->request.sem = &sem;
 586                         down(&sem);
 587 
 588                         /* Hmm.. Have to ask about this one */
 589                         while (SCpnt->request.dev != 0xfffe) schedule();
 590                         }
 591                   }
 592                   /* Add this device to the linked list at the end */
 593                   if(SDtail)
 594                     SDtail->next = SDpnt;
 595                   else
 596                     scsi_devices = SDpnt;
 597                   SDtail = SDpnt;
 598 
 599                   SDpnt = (Scsi_Device *) scsi_init_malloc(sizeof (Scsi_Device), GFP_ATOMIC);
 600                   /* Some scsi devices cannot be polled for lun != 0
 601                      due to firmware bugs */
 602                   if(blacklisted(scsi_result)) break;
 603                   /* Old drives like the MAXTOR XT-3280 say vers=0 */
 604                   if ((scsi_result[2] & 0x07) == 0)
 605                     break;
 606                   /* Some scsi-1 peripherals do not handle lun != 0.
 607                      I am assuming that scsi-2 peripherals do better */
 608                   if((scsi_result[2] & 0x07) == 1 &&
 609                      (scsi_result[3] & 0x0f) == 0) break;
 610                 }
 611             }       /* if result == DID_OK ends */
 612         }       /* for lun ends */
 613 
 614   shpnt->host_queue = NULL;  /* No longer needed here */
 615 
 616   /* Last device block does not exist.  Free memory. */
 617   scsi_init_free((char *) SDpnt, sizeof(Scsi_Device));
 618 
 619   scsi_init_free((char *) SCpnt, sizeof(Scsi_Cmnd));
 620 
 621 
 622   /* If we allocated a buffer so we could do DMA, free it now */
 623   if (scsi_result != &scsi_result0[0]) scsi_free(scsi_result, 512);
 624 
 625   in_scan_scsis = 0;
 626 }       /* scan_scsis  ends */
 627 
 628 /*
 629  *      Flag bits for the internal_timeout array
 630  */
 631 
 632 #define NORMAL_TIMEOUT 0
 633 #define IN_ABORT 1
 634 #define IN_RESET 2
 635 /*
 636         This is our time out function, called when the timer expires for a
 637         given host adapter.  It will attempt to abort the currently executing
 638         command, that failing perform a kernel panic.
 639 */
 640 
 641 static void scsi_times_out (Scsi_Cmnd * SCpnt, int pid)
     /*  */
 642         {
 643 
 644         switch (SCpnt->internal_timeout & (IN_ABORT | IN_RESET))
 645                 {
 646                 case NORMAL_TIMEOUT:
 647                         if (!in_scan_scsis) {
 648 #ifdef DEBUG_TIMEOUT
 649                           scsi_dump_status();
 650 #endif
 651                         }
 652 
 653                         if (!scsi_abort (SCpnt, DID_TIME_OUT, pid))
 654                                 return;
 655                 case IN_ABORT:
 656                         printk("SCSI host %d abort() timed out - resetting\n",
 657                                 SCpnt->host->host_no);
 658                         if (!scsi_reset (SCpnt))
 659                                 return;
 660                 case IN_RESET:
 661                 case (IN_ABORT | IN_RESET):
 662                   /* This might be controversial, but if there is a bus hang,
 663                      you might conceivably want the machine up and running
 664                      esp if you have an ide disk. */
 665                         printk("Unable to reset scsi host %d - ",SCpnt->host->host_no);
 666                         printk("probably a SCSI bus hang.\n");
 667                         return;
 668 
 669                 default:
 670                         INTERNAL_ERROR;
 671                 }
 672 
 673         }
 674 
 675 
 676 /* This function takes a quick look at a request, and decides if it
 677 can be queued now, or if there would be a stall while waiting for
 678 something else to finish.  This routine assumes that interrupts are
 679 turned off when entering the routine.  It is the responsibility
 680 of the calling code to ensure that this is the case. */
 681 
 682 Scsi_Cmnd * request_queueable (struct request * req, Scsi_Device * device)
     /*  */
 683 {
 684   Scsi_Cmnd * SCpnt = NULL;
 685   int tablesize;
 686   struct buffer_head * bh, *bhp;
 687 
 688   if (!device)
 689     panic ("No device passed to request_queueable().\n");
 690 
 691   if (req && req->dev <= 0)
 692     panic("Invalid device in request_queueable");
 693 
 694   SCpnt =  device->host->host_queue;
 695     while(SCpnt){
 696       if(SCpnt->target == device->id &&
 697          SCpnt->lun == device->lun)
 698         if(SCpnt->request.dev < 0) break;
 699       SCpnt = SCpnt->next;
 700     }
 701 
 702   if (!SCpnt) return NULL;
 703 
 704   if (SCSI_BLOCK(device->host)) return NULL;
 705 
 706   if (req) {
 707     memcpy(&SCpnt->request, req, sizeof(struct request));
 708     tablesize = device->host->sg_tablesize;
 709     bhp = bh = req->bh;
 710     if(!tablesize) bh = NULL;
 711     /* Take a quick look through the table to see how big it is.  We already
 712        have our copy of req, so we can mess with that if we want to.  */
 713     while(req->nr_sectors && bh){
 714             bhp = bhp->b_reqnext;
 715             if(!bhp || !CONTIGUOUS_BUFFERS(bh,bhp)) tablesize--;
 716             req->nr_sectors -= bh->b_size >> 9;
 717             req->sector += bh->b_size >> 9;
 718             if(!tablesize) break;
 719             bh = bhp;
 720     }
 721     if(req->nr_sectors && bh && bh->b_reqnext){  /* Any leftovers? */
 722       SCpnt->request.bhtail = bh;
 723       req->bh = bh->b_reqnext; /* Divide request */
 724       bh->b_reqnext = NULL;
 725       bh = req->bh;
 726 
 727       /* Now reset things so that req looks OK */
 728       SCpnt->request.nr_sectors -= req->nr_sectors;
 729       req->current_nr_sectors = bh->b_size >> 9;
 730       req->buffer = bh->b_data;
 731       SCpnt->request.sem = NULL; /* Wait until whole thing done */
 732     } else {
 733       req->dev = -1;
 734       wake_up(&wait_for_request);
 735     }
 736   } else {
 737     SCpnt->request.dev = 0xffff; /* Busy, but no request */
 738     SCpnt->request.sem = NULL;  /* And no one is waiting for the device either */
 739   }
 740 
 741   SCpnt->use_sg = 0;  /* Reset the scatter-gather flag */
 742   SCpnt->old_use_sg  = 0;
 743   SCpnt->transfersize = 0;
 744   SCpnt->underflow = 0;
 745   SCpnt->cmd_len = 0;
 746   return SCpnt;
 747 }
 748 
 749 /* This function returns a structure pointer that will be valid for
 750 the device.  The wait parameter tells us whether we should wait for
 751 the unit to become free or not.  We are also able to tell this routine
 752 not to return a descriptor if the host is unable to accept any more
 753 commands for the time being.  We need to keep in mind that there is no
 754 guarantee that the host remain not busy.  Keep in mind the
 755 request_queueable function also knows the internal allocation scheme
 756 of the packets for each device */
 757 
 758 Scsi_Cmnd * allocate_device (struct request ** reqp, Scsi_Device * device,
     /*  */
 759                              int wait)
 760 {
 761   int dev = -1;
 762   struct request * req = NULL;
 763   int tablesize;
 764   unsigned int flags;
 765   struct buffer_head * bh, *bhp;
 766   struct Scsi_Host * host;
 767   Scsi_Cmnd * SCpnt = NULL;
 768   Scsi_Cmnd * SCwait = NULL;
 769 
 770   if (!device)
 771     panic ("No device passed to allocate_device().\n");
 772 
 773   if (reqp) req = *reqp;
 774 
 775     /* See if this request has already been queued by an interrupt routine */
 776   if (req && (dev = req->dev) <= 0) return NULL;
 777 
 778   host = device->host;
 779 
 780   if (intr_count && SCSI_BLOCK(host)) return NULL;
 781 
 782   while (1==1){
 783     SCpnt = host->host_queue;
 784     while(SCpnt){
 785       if(SCpnt->target == device->id &&
 786          SCpnt->lun == device->lun) {
 787         SCwait = SCpnt;
 788         if(SCpnt->request.dev < 0) break;
 789       }
 790       SCpnt = SCpnt->next;
 791     }
 792     save_flags(flags);
 793     cli();
 794     /* See if this request has already been queued by an interrupt routine */
 795     if (req && ((req->dev < 0) || (req->dev != dev))) {
 796       restore_flags(flags);
 797       return NULL;
 798     }
 799     if (!SCpnt || SCpnt->request.dev >= 0)  /* Might have changed */
 800       {
 801         restore_flags(flags);
 802         if(!wait) return NULL;
 803         if (!SCwait) {
 804           printk("Attempt to allocate device target %d, lun %d\n",
 805                  device->id ,device->lun);
 806           panic("No device found in allocate_device\n");
 807         }
 808         SCSI_SLEEP(&device->device_wait,
 809                    (SCwait->request.dev > 0));
 810       } else {
 811         if (req) {
 812           memcpy(&SCpnt->request, req, sizeof(struct request));
 813           tablesize = device->host->sg_tablesize;
 814           bhp = bh = req->bh;
 815           if(!tablesize) bh = NULL;
 816           /* Take a quick look through the table to see how big it is.  We already
 817              have our copy of req, so we can mess with that if we want to.  */
 818           while(req->nr_sectors && bh){
 819             bhp = bhp->b_reqnext;
 820             if(!bhp || !CONTIGUOUS_BUFFERS(bh,bhp)) tablesize--;
 821             req->nr_sectors -= bh->b_size >> 9;
 822             req->sector += bh->b_size >> 9;
 823             if(!tablesize) break;
 824             bh = bhp;
 825           }
 826           if(req->nr_sectors && bh && bh->b_reqnext){  /* Any leftovers? */
 827             SCpnt->request.bhtail = bh;
 828             req->bh = bh->b_reqnext; /* Divide request */
 829             bh->b_reqnext = NULL;
 830             bh = req->bh;
 831             /* Now reset things so that req looks OK */
 832             SCpnt->request.nr_sectors -= req->nr_sectors;
 833             req->current_nr_sectors = bh->b_size >> 9;
 834             req->buffer = bh->b_data;
 835             SCpnt->request.sem = NULL; /* Wait until whole thing done */
 836           }
 837           else
 838             {
 839               req->dev = -1;
 840               *reqp = req->next;
 841               wake_up(&wait_for_request);
 842             }
 843         } else {
 844           SCpnt->request.dev = 0xffff; /* Busy */
 845           SCpnt->request.sem = NULL;  /* And no one is waiting for this to complete */
 846         }
 847         restore_flags(flags);
 848         break;
 849       }
 850   }
 851 
 852   SCpnt->use_sg = 0;  /* Reset the scatter-gather flag */
 853   SCpnt->old_use_sg  = 0;
 854   SCpnt->transfersize = 0;      /* No default transfer size */
 855   SCpnt->cmd_len = 0;
 856   SCpnt->underflow = 0;         /* Do not flag underflow conditions */
 857   return SCpnt;
 858 }
 859 
 860 /*
 861         This is inline because we have stack problemes if we recurse to deeply.
 862 */
 863 
 864 inline void internal_cmnd (Scsi_Cmnd * SCpnt)
     /*  */
 865         {
 866         int temp;
 867         struct Scsi_Host * host;
 868         unsigned int flags;
 869 #ifdef DEBUG_DELAY
 870         int clock;
 871 #endif
 872 
 873         if ((unsigned long) &SCpnt < current->kernel_stack_page)
 874           panic("Kernel stack overflow.");
 875 
 876         host = SCpnt->host;
 877 
 878 /*
 879         We will wait MIN_RESET_DELAY clock ticks after the last reset so
 880         we can avoid the drive not being ready.
 881 */
 882 save_flags(flags);
 883 sti();
 884 temp = host->last_reset + MIN_RESET_DELAY;
 885 while (jiffies < temp);
 886 restore_flags(flags);
 887 
 888 update_timeout(SCpnt, SCpnt->timeout_per_command);
 889 
 890 /*
 891         We will use a queued command if possible, otherwise we will emulate the
 892         queuing and calling of completion function ourselves.
 893 */
 894 #ifdef DEBUG
 895         printk("internal_cmnd (host = %d, target = %d, command = %08x, buffer =  %08x, \n"
 896                 "bufflen = %d, done = %08x)\n", SCpnt->host->host_no, SCpnt->target, SCpnt->cmnd, SCpnt->buffer, SCpnt->bufflen, SCpnt->done);
 897 #endif
 898 
 899         if (host->can_queue)
 900                 {
 901 #ifdef DEBUG
 902         printk("queuecommand : routine at %08x\n",
 903                 host->hostt->queuecommand);
 904 #endif
 905                   /* This locking tries to prevent all sorts of races between
 906                      queuecommand and the interrupt code.  In effect,
 907                      we are only allowed to be in queuecommand once at
 908                      any given time, and we can only be in the interrupt
 909                      handler and the queuecommand function at the same time
 910                      when queuecommand is called while servicing the
 911                      interrupt. */
 912 
 913                 if(!intr_count && SCpnt->host->irq)
 914                   disable_irq(SCpnt->host->irq);
 915 
 916                 host->hostt->queuecommand (SCpnt, scsi_done);
 917 
 918                 if(!intr_count && SCpnt->host->irq)
 919                   enable_irq(SCpnt->host->irq);
 920                 }
 921         else
 922                 {
 923 
 924 #ifdef DEBUG
 925         printk("command() :  routine at %08x\n", host->hostt->command);
 926 #endif
 927                 temp=host->hostt->command (SCpnt);
 928                 SCpnt->result = temp;
 929 #ifdef DEBUG_DELAY
 930         clock = jiffies + 400;
 931         while (jiffies < clock);
 932         printk("done(host = %d, result = %04x) : routine at %08x\n", host->host_no, temp);
 933 #endif
 934                 scsi_done(SCpnt);
 935                 }
 936 #ifdef DEBUG
 937         printk("leaving internal_cmnd()\n");
 938 #endif
 939         }
 940 
 941 static void scsi_request_sense (Scsi_Cmnd * SCpnt)
     /*  */
 942         {
 943         unsigned int flags;
 944 
 945         save_flags(flags);
 946         cli();
 947         SCpnt->flags |= WAS_SENSE | ASKED_FOR_SENSE;
 948         update_timeout(SCpnt, SENSE_TIMEOUT);
 949         restore_flags(flags);
 950 
 951 
 952         memcpy ((void *) SCpnt->cmnd , (void *) generic_sense,
 953                 sizeof(generic_sense));
 954 
 955         SCpnt->cmnd[1] = SCpnt->lun << 5;
 956         SCpnt->cmnd[4] = sizeof(SCpnt->sense_buffer);
 957 
 958         SCpnt->request_buffer = &SCpnt->sense_buffer;
 959         SCpnt->request_bufflen = sizeof(SCpnt->sense_buffer);
 960         SCpnt->use_sg = 0;
 961         SCpnt->cmd_len = COMMAND_SIZE(SCpnt->cmnd[0]);
 962         internal_cmnd (SCpnt);
 963         }
 964 
 965 
 966 
 967 /*
 968         scsi_do_cmd sends all the commands out to the low-level driver.  It
 969         handles the specifics required for each low level driver - ie queued
 970         or non queued.  It also prevents conflicts when different high level
 971         drivers go for the same host at the same time.
 972 */
 973 
 974 void scsi_do_cmd (Scsi_Cmnd * SCpnt, const void *cmnd ,
     /*  */
 975                   void *buffer, unsigned bufflen, void (*done)(Scsi_Cmnd *),
 976                   int timeout, int retries
 977                    )
 978         {
 979         unsigned long flags;
 980         struct Scsi_Host * host = SCpnt->host;
 981 
 982 #ifdef DEBUG
 983         {
 984         int i;
 985         int target = SCpnt->target;
 986         printk ("scsi_do_cmd (host = %d, target = %d, buffer =%08x, "
 987                 "bufflen = %d, done = %08x, timeout = %d, retries = %d)\n"
 988                 "command : " , host->host_no, target, buffer, bufflen, done, timeout, retries);
 989         for (i = 0; i < 10; ++i)
 990                 printk ("%02x  ", ((unsigned char *) cmnd)[i]);
 991         printk("\n");
 992       }
 993 #endif
 994 
 995         if (!host)
 996                 {
 997                 panic ("Invalid or not present host.\n");
 998                 }
 999 
1000 
1001 /*
1002         We must prevent reentrancy to the lowlevel host driver.  This prevents
1003         it - we enter a loop until the host we want to talk to is not busy.
1004         Race conditions are prevented, as interrupts are disabled in between the
1005         time we check for the host being not busy, and the time we mark it busy
1006         ourselves.
1007 */
1008 
1009         save_flags(flags);
1010         cli();
1011         SCpnt->pid = scsi_pid++;
1012 
1013         while (SCSI_BLOCK(host)) {
1014            restore_flags(flags);
1015            SCSI_SLEEP(&host->host_wait, SCSI_BLOCK(host));
1016            cli();
1017            }
1018 
1019         if (host->block) host_active = host;
1020 
1021         host->host_busy++;
1022         restore_flags(flags);
1023 
1024 /*
1025         Our own function scsi_done (which marks the host as not busy, disables
1026         the timeout counter, etc) will be called by us or by the
1027         scsi_hosts[host].queuecommand() function needs to also call
1028         the completion function for the high level driver.
1029 
1030 */
1031 
1032         memcpy ((void *) SCpnt->data_cmnd , (void *) cmnd, 12);
1033 #if 0
1034         SCpnt->host = host;
1035         SCpnt->target = target;
1036         SCpnt->lun = (SCpnt->data_cmnd[1] >> 5);
1037 #endif
1038         SCpnt->bufflen = bufflen;
1039         SCpnt->buffer = buffer;
1040         SCpnt->flags=0;
1041         SCpnt->retries=0;
1042         SCpnt->allowed=retries;
1043         SCpnt->done = done;
1044         SCpnt->timeout_per_command = timeout;
1045 
1046         memcpy ((void *) SCpnt->cmnd , (void *) cmnd, 12);
1047         /* Zero the sense buffer.  Some host adapters automatically request
1048            sense on error.  0 is not a valid sense code.  */
1049         memset ((void *) SCpnt->sense_buffer, 0, sizeof SCpnt->sense_buffer);
1050         SCpnt->request_buffer = buffer;
1051         SCpnt->request_bufflen = bufflen;
1052         SCpnt->old_use_sg = SCpnt->use_sg;
1053         if (SCpnt->cmd_len == 0)
1054                 SCpnt->cmd_len = COMMAND_SIZE(SCpnt->cmnd[0]);
1055         SCpnt->old_cmd_len = SCpnt->cmd_len;
1056 
1057         /* Start the timer ticking.  */
1058 
1059         SCpnt->internal_timeout = 0;
1060         SCpnt->abort_reason = 0;
1061         internal_cmnd (SCpnt);
1062 
1063 #ifdef DEBUG
1064         printk ("Leaving scsi_do_cmd()\n");
1065 #endif
1066         }
1067 
1068 
1069 
1070 /*
1071         The scsi_done() function disables the timeout timer for the scsi host,
1072         marks the host as not busy, and calls the user specified completion
1073         function for that host's current command.
1074 */
1075 
1076 static void reset (Scsi_Cmnd * SCpnt)
     /*  */
1077 {
1078 #ifdef DEBUG
1079         printk("scsi: reset(%d)\n", SCpnt->host->host_no);
1080 #endif
1081 
1082         SCpnt->flags |= (WAS_RESET | IS_RESETTING);
1083         scsi_reset(SCpnt);
1084 
1085 #ifdef DEBUG
1086         printk("performing request sense\n");
1087 #endif
1088 
1089 #if 0  /* FIXME - remove this when done */
1090         if(SCpnt->flags & NEEDS_JUMPSTART) {
1091           SCpnt->flags &= ~NEEDS_JUMPSTART;
1092           scsi_request_sense (SCpnt);
1093         }
1094 #endif
1095 }
1096 
1097 
1098 
1099 static int check_sense (Scsi_Cmnd * SCpnt)
     /*  */
1100         {
1101   /* If there is no sense information, request it.  If we have already
1102      requested it, there is no point in asking again - the firmware must be
1103      confused. */
1104   if (((SCpnt->sense_buffer[0] & 0x70) >> 4) != 7) {
1105     if(!(SCpnt->flags & ASKED_FOR_SENSE))
1106       return SUGGEST_SENSE;
1107     else
1108       return SUGGEST_RETRY;
1109       }
1110 
1111   SCpnt->flags &= ~ASKED_FOR_SENSE;
1112 
1113 #ifdef DEBUG_INIT
1114         printk("scsi%d : ", SCpnt->host->host_no);
1115         print_sense("", SCpnt);
1116         printk("\n");
1117 #endif
1118                 if (SCpnt->sense_buffer[2] &0xe0)
1119                   return SUGGEST_ABORT;
1120 
1121                 switch (SCpnt->sense_buffer[2] & 0xf)
1122                 {
1123                 case NO_SENSE:
1124                         return 0;
1125                 case RECOVERED_ERROR:
1126                         return SUGGEST_IS_OK;
1127 
1128                 case ABORTED_COMMAND:
1129                         return SUGGEST_RETRY;
1130                 case NOT_READY:
1131                 case UNIT_ATTENTION:
1132                         return SUGGEST_ABORT;
1133 
1134                 /* these three are not supported */
1135                 case COPY_ABORTED:
1136                 case VOLUME_OVERFLOW:
1137                 case MISCOMPARE:
1138 
1139                 case MEDIUM_ERROR:
1140                         return SUGGEST_REMAP;
1141                 case BLANK_CHECK:
1142                 case DATA_PROTECT:
1143                 case HARDWARE_ERROR:
1144                 case ILLEGAL_REQUEST:
1145                 default:
1146                         return SUGGEST_ABORT;
1147                 }
1148               }
1149 
1150 /* This function is the mid-level interrupt routine, which decides how
1151  *  to handle error conditions.  Each invocation of this function must
1152  *  do one and *only* one of the following:
1153  *
1154  *  (1) Call last_cmnd[host].done.  This is done for fatal errors and
1155  *      normal completion, and indicates that the handling for this
1156  *      request is complete.
1157  *  (2) Call internal_cmnd to requeue the command.  This will result in
1158  *      scsi_done being called again when the retry is complete.
1159  *  (3) Call scsi_request_sense.  This asks the host adapter/drive for
1160  *      more information about the error condition.  When the information
1161  *      is available, scsi_done will be called again.
1162  *  (4) Call reset().  This is sort of a last resort, and the idea is that
1163  *      this may kick things loose and get the drive working again.  reset()
1164  *      automatically calls scsi_request_sense, and thus scsi_done will be
1165  *      called again once the reset is complete.
1166  *
1167  *      If none of the above actions are taken, the drive in question
1168  * will hang. If more than one of the above actions are taken by
1169  * scsi_done, then unpredictable behavior will result.
1170  */
1171 static void scsi_done (Scsi_Cmnd * SCpnt)
     /*  */
1172         {
1173         int status=0;
1174         int exit=0;
1175         int checked;
1176         int oldto;
1177         struct Scsi_Host * host = SCpnt->host;
1178         int result = SCpnt->result;
1179         oldto = update_timeout(SCpnt, 0);
1180 
1181 #ifdef DEBUG_TIMEOUT
1182         if(result) printk("Non-zero result in scsi_done %x %d:%d\n",
1183                           result, SCpnt->target, SCpnt->lun);
1184 #endif
1185 
1186         /* If we requested an abort, (and we got it) then fix up the return
1187            status to say why */
1188         if(host_byte(result) == DID_ABORT && SCpnt->abort_reason)
1189           SCpnt->result = result = (result & 0xff00ffff) |
1190             (SCpnt->abort_reason << 16);
1191 
1192 
1193 #define FINISHED 0
1194 #define MAYREDO  1
1195 #define REDO     3
1196 #define PENDING  4
1197 
1198 #ifdef DEBUG
1199         printk("In scsi_done(host = %d, result = %06x)\n", host->host_no, result);
1200 #endif
1201 
1202         if(SCpnt->flags & WAS_SENSE)
1203         {
1204                 SCpnt->use_sg = SCpnt->old_use_sg;
1205                 SCpnt->cmd_len = SCpnt->old_cmd_len;
1206         }
1207 
1208         switch (host_byte(result))
1209         {
1210         case DID_OK:
1211                 if (status_byte(result) && (SCpnt->flags & WAS_SENSE))
1212                         /* Failed to obtain sense information */
1213                         {
1214                         SCpnt->flags &= ~WAS_SENSE;
1215                         SCpnt->internal_timeout &= ~SENSE_TIMEOUT;
1216 
1217                         if (!(SCpnt->flags & WAS_RESET))
1218                                 {
1219                                 printk("scsi%d : target %d lun %d request sense failed, performing reset.\n",
1220                                         SCpnt->host->host_no, SCpnt->target, SCpnt->lun);
1221                                 reset(SCpnt);
1222                                 return;
1223                                 }
1224                         else
1225                                 {
1226                                 exit = (DRIVER_HARD | SUGGEST_ABORT);
1227                                 status = FINISHED;
1228                                 }
1229                         }
1230                 else switch(msg_byte(result))
1231                         {
1232                         case COMMAND_COMPLETE:
1233                         switch (status_byte(result))
1234                         {
1235                         case GOOD:
1236                                 if (SCpnt->flags & WAS_SENSE)
1237                                         {
1238 #ifdef DEBUG
1239         printk ("In scsi_done, GOOD status, COMMAND COMPLETE, parsing sense information.\n");
1240 #endif
1241 
1242                                         SCpnt->flags &= ~WAS_SENSE;
1243                                         SCpnt->internal_timeout &= ~SENSE_TIMEOUT;
1244 
1245                                         switch (checked = check_sense(SCpnt))
1246                                         {
1247                                         case SUGGEST_SENSE:
1248                                         case 0:
1249 #ifdef DEBUG
1250         printk("NO SENSE.  status = REDO\n");
1251 #endif
1252 
1253                                                 update_timeout(SCpnt, oldto);
1254                                                 status = REDO;
1255                                                 break;
1256                                         case SUGGEST_IS_OK:
1257                                                 break;
1258                                         case SUGGEST_REMAP:
1259                                         case SUGGEST_RETRY:
1260 #ifdef DEBUG
1261         printk("SENSE SUGGEST REMAP or SUGGEST RETRY - status = MAYREDO\n");
1262 #endif
1263 
1264                                                 status = MAYREDO;
1265                                                 exit = DRIVER_SENSE | SUGGEST_RETRY;
1266                                                 break;
1267                                         case SUGGEST_ABORT:
1268 #ifdef DEBUG
1269         printk("SENSE SUGGEST ABORT - status = FINISHED");
1270 #endif
1271 
1272                                                 status = FINISHED;
1273                                                 exit =  DRIVER_SENSE | SUGGEST_ABORT;
1274                                                 break;
1275                                         default:
1276                                                 printk ("Internal error %s %d \n", __FILE__,
1277                                                         __LINE__);
1278                                         }
1279                                         }
1280                                 else
1281                                         {
1282 #ifdef DEBUG
1283         printk("COMMAND COMPLETE message returned, status = FINISHED. \n");
1284 #endif
1285 
1286                                         exit =  DRIVER_OK;
1287                                         status = FINISHED;
1288                                         }
1289                                 break;
1290 
1291                         case CHECK_CONDITION:
1292                                 switch (check_sense(SCpnt))
1293                                   {
1294                                   case 0:
1295                                     update_timeout(SCpnt, oldto);
1296                                     status = REDO;
1297                                     break;
1298                                   case SUGGEST_REMAP:
1299                                   case SUGGEST_RETRY:
1300                                     status = MAYREDO;
1301                                     exit = DRIVER_SENSE | SUGGEST_RETRY;
1302                                     break;
1303                                   case SUGGEST_ABORT:
1304                                     status = FINISHED;
1305                                     exit =  DRIVER_SENSE | SUGGEST_ABORT;
1306                                     break;
1307                                   case SUGGEST_SENSE:
1308                                 scsi_request_sense (SCpnt);
1309                                 status = PENDING;
1310                                 break;
1311                                   }
1312                                 break;
1313 
1314                         case CONDITION_GOOD:
1315                         case INTERMEDIATE_GOOD:
1316                         case INTERMEDIATE_C_GOOD:
1317                                 break;
1318 
1319                         case BUSY:
1320                                 update_timeout(SCpnt, oldto);
1321                                 status = REDO;
1322                                 break;
1323 
1324                         case RESERVATION_CONFLICT:
1325                                 printk("scsi%d : RESERVATION CONFLICT performing reset.\n",
1326                                         SCpnt->host->host_no);
1327                                 reset(SCpnt);
1328                                 return;
1329 #if 0
1330                                 exit = DRIVER_SOFT | SUGGEST_ABORT;
1331                                 status = MAYREDO;
1332                                 break;
1333 #endif
1334                         default:
1335                                 printk ("Internal error %s %d \n"
1336                                         "status byte = %d \n", __FILE__,
1337                                         __LINE__, status_byte(result));
1338 
1339                         }
1340                         break;
1341                         default:
1342                                 panic("scsi: unsupported message byte %d received\n", msg_byte(result));
1343                         }
1344                         break;
1345         case DID_TIME_OUT:
1346 #ifdef DEBUG
1347         printk("Host returned DID_TIME_OUT - ");
1348 #endif
1349 
1350                 if (SCpnt->flags & WAS_TIMEDOUT)
1351                         {
1352 #ifdef DEBUG
1353         printk("Aborting\n");
1354 #endif
1355                         exit = (DRIVER_TIMEOUT | SUGGEST_ABORT);
1356                         }
1357                 else
1358                         {
1359 #ifdef DEBUG
1360                         printk ("Retrying.\n");
1361 #endif
1362                         SCpnt->flags  |= WAS_TIMEDOUT;
1363                         SCpnt->internal_timeout &= ~IN_ABORT;
1364                         status = REDO;
1365                         }
1366                 break;
1367         case DID_BUS_BUSY:
1368         case DID_PARITY:
1369                 status = REDO;
1370                 break;
1371         case DID_NO_CONNECT:
1372 #ifdef DEBUG
1373                 printk("Couldn't connect.\n");
1374 #endif
1375                 exit  = (DRIVER_HARD | SUGGEST_ABORT);
1376                 break;
1377         case DID_ERROR:
1378                 status = MAYREDO;
1379                 exit = (DRIVER_HARD | SUGGEST_ABORT);
1380                 break;
1381         case DID_BAD_TARGET:
1382         case DID_ABORT:
1383                 exit = (DRIVER_INVALID | SUGGEST_ABORT);
1384                 break;
1385         case DID_RESET:
1386                 if (SCpnt->flags & IS_RESETTING)
1387                         {
1388                         SCpnt->flags &= ~IS_RESETTING;
1389                         status = REDO;
1390                         break;
1391                         }
1392 
1393                 if(msg_byte(result) == GOOD &&
1394                       status_byte(result) == CHECK_CONDITION) {
1395                         switch (check_sense(SCpnt)) {
1396                         case 0:
1397                             update_timeout(SCpnt, oldto);
1398                             status = REDO;
1399                             break;
1400                         case SUGGEST_REMAP:
1401                         case SUGGEST_RETRY:
1402                             status = MAYREDO;
1403                             exit = DRIVER_SENSE | SUGGEST_RETRY;
1404                             break;
1405                         case SUGGEST_ABORT:
1406                             status = FINISHED;
1407                             exit =  DRIVER_SENSE | SUGGEST_ABORT;
1408                             break;
1409                         case SUGGEST_SENSE:
1410                               scsi_request_sense (SCpnt);
1411                               status = PENDING;
1412                               break;
1413                         }
1414                 } else {
1415                 status=REDO;
1416                 exit = SUGGEST_RETRY;
1417                 }
1418                 break;
1419         default :
1420                 exit = (DRIVER_ERROR | SUGGEST_DIE);
1421         }
1422 
1423         switch (status)
1424                 {
1425                 case FINISHED:
1426                 case PENDING:
1427                         break;
1428                 case MAYREDO:
1429 
1430 #ifdef DEBUG
1431         printk("In MAYREDO, allowing %d retries, have %d\n",
1432                SCpnt->allowed, SCpnt->retries);
1433 #endif
1434 
1435                         if ((++SCpnt->retries) < SCpnt->allowed)
1436                         {
1437                         if ((SCpnt->retries >= (SCpnt->allowed >> 1))
1438                             && !(jiffies < SCpnt->host->last_reset + MIN_RESET_PERIOD)
1439                             && !(SCpnt->flags & WAS_RESET))
1440                                 {
1441                                         printk("scsi%d : resetting for second half of retries.\n",
1442                                                 SCpnt->host->host_no);
1443                                         reset(SCpnt);
1444                                         break;
1445                                 }
1446 
1447                         }
1448                         else
1449                                 {
1450                                 status = FINISHED;
1451                                 break;
1452                                 }
1453                         /* fall through to REDO */
1454 
1455                 case REDO:
1456 
1457                         if (SCpnt->flags & WAS_SENSE)
1458                                 scsi_request_sense(SCpnt);
1459                         else
1460                           {
1461                             memcpy ((void *) SCpnt->cmnd,
1462                                     (void*) SCpnt->data_cmnd,
1463                                     sizeof(SCpnt->data_cmnd));
1464                             SCpnt->request_buffer = SCpnt->buffer;
1465                             SCpnt->request_bufflen = SCpnt->bufflen;
1466                             SCpnt->use_sg = SCpnt->old_use_sg;
1467                             SCpnt->cmd_len = SCpnt->old_cmd_len;
1468                             internal_cmnd (SCpnt);
1469                           }
1470                         break;
1471                 default:
1472                         INTERNAL_ERROR;
1473                 }
1474 
1475 
1476         if (status == FINISHED) {
1477 #ifdef DEBUG
1478            printk("Calling done function - at address %08x\n", SCpnt->done);
1479 #endif
1480            host->host_busy--; /* Indicate that we are free */
1481 
1482            if (host->block && host->host_busy == 0) {
1483               host_active = NULL;
1484 
1485               /* For block devices "wake_up" is done in end_scsi_request */
1486               if (MAJOR(SCpnt->request.dev) != SCSI_DISK_MAJOR &&
1487                         MAJOR(SCpnt->request.dev) != SCSI_CDROM_MAJOR) {
1488                  struct Scsi_Host * next;
1489 
1490                  for (next = host->block; next != host; next = next->block)
1491                     wake_up(&next->host_wait);
1492                  }
1493 
1494               }
1495 
1496            wake_up(&host->host_wait);
1497            SCpnt->result = result | ((exit & 0xff) << 24);
1498            SCpnt->use_sg = SCpnt->old_use_sg;
1499            SCpnt->cmd_len = SCpnt->old_cmd_len;
1500            SCpnt->done (SCpnt);
1501            }
1502 
1503 #undef FINISHED
1504 #undef REDO
1505 #undef MAYREDO
1506 #undef PENDING
1507         }
1508 
1509 /*
1510         The scsi_abort function interfaces with the abort() function of the host
1511         we are aborting, and causes the current command to not complete.  The
1512         caller should deal with any error messages or status returned on the
1513         next call.
1514 
1515         This will not be called reentrantly for a given host.
1516 */
1517 
1518 /*
1519         Since we're nice guys and specified that abort() and reset()
1520         can be non-reentrant.  The internal_timeout flags are used for
1521         this.
1522 */
1523 
1524 
1525 int scsi_abort (Scsi_Cmnd * SCpnt, int why, int pid)
     /*  */
1526         {
1527         int oldto;
1528         unsigned long flags;
1529         struct Scsi_Host * host = SCpnt->host;
1530 
1531         while(1)
1532                 {
1533                 save_flags(flags);
1534                 cli();
1535 
1536                 /*
1537                  * Protect against races here.  If the command is done, or we are
1538                  * on a different command forget it.
1539                  */
1540                 if (SCpnt->request.dev == -1 || pid != SCpnt->pid) {
1541                   restore_flags(flags);
1542                   return 0;
1543                 }
1544 
1545                 if (SCpnt->internal_timeout & IN_ABORT)
1546                         {
1547                         restore_flags(flags);
1548                         while (SCpnt->internal_timeout & IN_ABORT);
1549                         }
1550                 else
1551                         {
1552                         SCpnt->internal_timeout |= IN_ABORT;
1553                         oldto = update_timeout(SCpnt, ABORT_TIMEOUT);
1554 
1555                         if ((SCpnt->flags & IS_RESETTING) &&
1556                             SCpnt->device->soft_reset) {
1557                           /* OK, this command must have died when we did the
1558                              reset.  The device itself must have lied. */
1559                           printk("Stale command on %d:%d appears to have died when"
1560                                  " the bus was reset\n", SCpnt->target, SCpnt->lun);
1561                         }
1562 
1563                         restore_flags(flags);
1564                         if (!host->host_busy) {
1565                           SCpnt->internal_timeout &= ~IN_ABORT;
1566                           update_timeout(SCpnt, oldto);
1567                           return 0;
1568                         }
1569                         printk("scsi : aborting command due to timeout : pid %lu, scsi%d, id %d, lun %d ",
1570                                SCpnt->pid, SCpnt->host->host_no, (int) SCpnt->target, (int)
1571                                SCpnt->lun);
1572                         print_command (SCpnt->cmnd);
1573                         if (SCpnt->request.dev == -1 || pid != SCpnt->pid)
1574                           return 0;
1575                         SCpnt->abort_reason = why;
1576                         switch(host->hostt->abort(SCpnt)) {
1577                           /* We do not know how to abort.  Try waiting another
1578                              time increment and see if this helps. Set the
1579                              WAS_TIMEDOUT flag set so we do not try this twice
1580                              */
1581                         case SCSI_ABORT_BUSY: /* Tough call - returning 1 from
1582                                                  this is too severe */
1583                         case SCSI_ABORT_SNOOZE:
1584                           if(why == DID_TIME_OUT) {
1585                             save_flags(flags);
1586                             cli();
1587                             SCpnt->internal_timeout &= ~IN_ABORT;
1588                             if(SCpnt->flags & WAS_TIMEDOUT) {
1589                               restore_flags(flags);
1590                               return 1; /* Indicate we cannot handle this.
1591                                            We drop down into the reset handler
1592                                            and try again */
1593                             } else {
1594                               SCpnt->flags |= WAS_TIMEDOUT;
1595                               oldto = SCpnt->timeout_per_command;
1596                               update_timeout(SCpnt, oldto);
1597                             }
1598                             restore_flags(flags);
1599                           }
1600                           return 0;
1601                         case SCSI_ABORT_PENDING:
1602                           if(why != DID_TIME_OUT) {
1603                             save_flags(flags);
1604                             cli();
1605                             update_timeout(SCpnt, oldto);
1606                             restore_flags(flags);
1607                           }
1608                           return 0;
1609                         case SCSI_ABORT_SUCCESS:
1610                           /* We should have already aborted this one.  No
1611                              need to adjust timeout */
1612                         case SCSI_ABORT_NOT_RUNNING:
1613                           SCpnt->internal_timeout &= ~IN_ABORT;
1614                           update_timeout(SCpnt, 0);
1615                           return 0;
1616                         case SCSI_ABORT_ERROR:
1617                         default:
1618                           SCpnt->internal_timeout &= ~IN_ABORT;
1619                           return 1;
1620                         }
1621                       }
1622               }
1623       }
1624 
1625 int scsi_reset (Scsi_Cmnd * SCpnt)
     /*  */
1626         {
1627         int temp, oldto;
1628         unsigned long flags;
1629         Scsi_Cmnd * SCpnt1;
1630         struct Scsi_Host * host = SCpnt->host;
1631 
1632 #ifdef DEBUG
1633         printk("Danger Will Robinson! - SCSI bus for host %d is being reset.\n",host->host_no);
1634 #endif
1635         while (1) {
1636                 save_flags(flags);
1637                 cli();
1638                 if (SCpnt->internal_timeout & IN_RESET)
1639                         {
1640                         restore_flags(flags);
1641                         while (SCpnt->internal_timeout & IN_RESET);
1642                         }
1643                 else
1644                         {
1645                         SCpnt->internal_timeout |= IN_RESET;
1646                         oldto = update_timeout(SCpnt, RESET_TIMEOUT);
1647 
1648                         if (host->host_busy)
1649                                 {
1650                                 restore_flags(flags);
1651                                 SCpnt1 = host->host_queue;
1652                                 while(SCpnt1) {
1653                                   if (SCpnt1->request.dev > 0) {
1654 #if 0
1655                                     if (!(SCpnt1->flags & IS_RESETTING) &&
1656                                       !(SCpnt1->internal_timeout & IN_ABORT))
1657                                     scsi_abort(SCpnt1, DID_RESET, SCpnt->pid);
1658 #endif
1659                                     SCpnt1->flags |= IS_RESETTING;
1660                                   }
1661                                   SCpnt1 = SCpnt1->next;
1662                                 }
1663 
1664                                 host->last_reset = jiffies;
1665                                 temp = host->hostt->reset(SCpnt);
1666                                 host->last_reset = jiffies;
1667                                 }
1668                         else
1669                                 {
1670                                 if (!host->block) host->host_busy++;
1671                                 restore_flags(flags);
1672                                 host->last_reset = jiffies;
1673                                 temp = host->hostt->reset(SCpnt);
1674                                 host->last_reset = jiffies;
1675                                 if (!host->block) host->host_busy--;
1676                                 }
1677 
1678 #ifdef DEBUG
1679                         printk("scsi reset function returned %d\n", temp);
1680 #endif
1681                         switch(temp) {
1682                         case SCSI_RESET_SUCCESS:
1683                           save_flags(flags);
1684                           cli();
1685                           SCpnt->internal_timeout &= ~IN_RESET;
1686                           update_timeout(SCpnt, oldto);
1687                           restore_flags(flags);
1688                           return 0;
1689                         case SCSI_RESET_PENDING:
1690                           return 0;
1691                         case SCSI_RESET_PUNT:
1692                         case SCSI_RESET_WAKEUP:
1693                           SCpnt->internal_timeout &= ~IN_RESET;
1694                           scsi_request_sense (SCpnt);
1695                           return 0;
1696                         case SCSI_RESET_SNOOZE:
1697                           /* In this case, we set the timeout field to 0
1698                              so that this command does not time out any more,
1699                              and we return 1 so that we get a message on the
1700                              screen. */
1701                           save_flags(flags);
1702                           cli();
1703                           SCpnt->internal_timeout &= ~IN_RESET;
1704                           update_timeout(SCpnt, 0);
1705                           restore_flags(flags);
1706                           /* If you snooze, you lose... */
1707                         case SCSI_RESET_ERROR:
1708                         default:
1709                           return 1;
1710                         }
1711 
1712                         return temp;
1713                         }
1714                 }
1715         }
1716 
1717 
1718 static void scsi_main_timeout(void)
     /*  */
1719         {
1720         /*
1721                 We must not enter update_timeout with a timeout condition still pending.
1722         */
1723 
1724         int timed_out, pid;
1725         unsigned long flags;
1726         struct Scsi_Host * host;
1727         Scsi_Cmnd * SCpnt = NULL;
1728 
1729         do {
1730                 save_flags(flags);
1731                 cli();
1732 
1733                 update_timeout(NULL, 0);
1734         /*
1735                 Find all timers such that they have 0 or negative (shouldn't happen)
1736                 time remaining on them.
1737         */
1738 
1739                 timed_out = 0;
1740                 for(host = scsi_hostlist; host; host = host->next) {
1741                   for(SCpnt = host->host_queue; SCpnt; SCpnt = SCpnt->next)
1742                     if (SCpnt->timeout == -1)
1743                       {
1744                         SCpnt->timeout = 0;
1745                         pid = SCpnt->pid;
1746                         restore_flags(flags);
1747                         scsi_times_out(SCpnt, pid);
1748                         ++timed_out;
1749                         save_flags(flags);
1750                         cli();
1751                       }
1752                 }
1753               } while (timed_out);
1754         restore_flags(flags);
1755       }
1756 
1757 /*
1758         The strategy is to cause the timer code to call scsi_times_out()
1759         when the soonest timeout is pending.
1760         The arguments are used when we are queueing a new command, because
1761         we do not want to subtract the time used from this time, but when we
1762         set the timer, we want to take this value into account.
1763 */
1764 
1765 static int update_timeout(Scsi_Cmnd * SCset, int timeout)
     /*  */
1766         {
1767         unsigned int least, used;
1768         unsigned int oldto;
1769         unsigned long flags;
1770         struct Scsi_Host * host;
1771         Scsi_Cmnd * SCpnt = NULL;
1772 
1773         save_flags(flags);
1774         cli();
1775 
1776 /*
1777         Figure out how much time has passed since the last time the timeouts
1778         were updated
1779 */
1780         used = (time_start) ? (jiffies - time_start) : 0;
1781 
1782 /*
1783         Find out what is due to timeout soonest, and adjust all timeouts for
1784         the amount of time that has passed since the last time we called
1785         update_timeout.
1786 */
1787 
1788         oldto = 0;
1789 
1790         if(SCset){
1791           oldto = SCset->timeout - used;
1792           SCset->timeout = timeout + used;
1793         }
1794 
1795         least = 0xffffffff;
1796 
1797         for(host = scsi_hostlist; host; host = host->next)
1798           for(SCpnt = host->host_queue; SCpnt; SCpnt = SCpnt->next)
1799             if (SCpnt->timeout > 0) {
1800               SCpnt->timeout -= used;
1801               if(SCpnt->timeout <= 0) SCpnt->timeout = -1;
1802               if(SCpnt->timeout > 0 && SCpnt->timeout < least)
1803                 least = SCpnt->timeout;
1804             }
1805 
1806 /*
1807         If something is due to timeout again, then we will set the next timeout
1808         interrupt to occur.  Otherwise, timeouts are disabled.
1809 */
1810 
1811         if (least != 0xffffffff)
1812                 {
1813                 time_start = jiffies;
1814                 timer_table[SCSI_TIMER].expires = (time_elapsed = least) + jiffies;
1815                 timer_active |= 1 << SCSI_TIMER;
1816                 }
1817         else
1818                 {
1819                 timer_table[SCSI_TIMER].expires = time_start = time_elapsed = 0;
1820                 timer_active &= ~(1 << SCSI_TIMER);
1821                 }
1822         restore_flags(flags);
1823         return oldto;
1824         }
1825 
1826 
1827 static unsigned char * dma_malloc_freelist = NULL;
1828 static int scsi_need_isa_bounce_buffers;
1829 static unsigned int dma_sectors = 0;
1830 unsigned int dma_free_sectors = 0;
1831 unsigned int need_isa_buffer = 0;
1832 static unsigned char ** dma_malloc_pages = NULL;
1833 #define MALLOC_PAGEBITS 12
1834 
1835 static int scsi_register_host(Scsi_Host_Template *);
1836 static void scsi_unregister_host(Scsi_Host_Template *);
1837 
1838 void *scsi_malloc(unsigned int len)
     /*  */
1839 {
1840   unsigned int nbits, mask;
1841   unsigned long flags;
1842   int i, j;
1843   if((len & 0x1ff) || len > (1<<MALLOC_PAGEBITS))
1844     return NULL;
1845 
1846   save_flags(flags);
1847   cli();
1848   nbits = len >> 9;
1849   mask = (1 << nbits) - 1;
1850 
1851   for(i=0;i < (dma_sectors >> (MALLOC_PAGEBITS - 9)); i++)
1852     for(j=0; j<=(sizeof(*dma_malloc_freelist) * 8) - nbits; j++){
1853       if ((dma_malloc_freelist[i] & (mask << j)) == 0){
1854         dma_malloc_freelist[i] |= (mask << j);
1855         restore_flags(flags);
1856         dma_free_sectors -= nbits;
1857 #ifdef DEBUG
1858         printk("SMalloc: %d %x ",len, dma_malloc_pages[i] + (j << 9));
1859 #endif
1860         return (void *) ((unsigned long) dma_malloc_pages[i] + (j << 9));
1861       }
1862     }
1863   restore_flags(flags);
1864   return NULL;  /* Nope.  No more */
1865 }
1866 
1867 int scsi_free(void *obj, unsigned int len)
     /*  */
1868 {
1869   int page, sector, nbits, mask;
1870   long offset;
1871   unsigned long flags;
1872 
1873 #ifdef DEBUG
1874   printk("Sfree %x %d\n",obj, len);
1875 #endif
1876 
1877    offset = -1;
1878   for (page = 0; page < (dma_sectors >> 3); page++)
1879         if ((unsigned long) obj >= (unsigned long) dma_malloc_pages[page] &&
1880                 (unsigned long) obj < (unsigned long) dma_malloc_pages[page] + (1 << MALLOC_PAGEBITS))
1881                 {
1882                         offset = ((unsigned long) obj) - ((unsigned long)dma_malloc_pages[page]);
1883                         break;
1884                 }
1885 
1886   if (page == (dma_sectors >> 3)) panic("Bad offset");
1887   sector = offset >> 9;
1888   if(sector >= dma_sectors) panic ("Bad page");
1889 
1890   sector = (offset >> 9) & (sizeof(*dma_malloc_freelist) * 8 - 1);
1891   nbits = len >> 9;
1892   mask = (1 << nbits) - 1;
1893 
1894   if ((mask << sector) > 0xffff) panic ("Bad memory alignment");
1895 
1896   save_flags(flags);
1897   cli();
1898   if(dma_malloc_freelist[page] & (mask << sector) != (mask<<sector))
1899     panic("Trying to free unused memory");
1900 
1901   dma_free_sectors += nbits;
1902   dma_malloc_freelist[page] &= ~(mask << sector);
1903   restore_flags(flags);
1904   return 0;
1905 }
1906 
1907 
1908 /* These are special functions that can be used to obtain memory at boot time.
1909    They act line a malloc function, but they simply take memory from the
1910    pool */
1911 
1912 static unsigned long scsi_init_memory_start = 0;
1913 static unsigned long scsi_memory_lower_value = 0;
1914 static unsigned long scsi_memory_upper_value = 0;
1915 int scsi_loadable_module_flag; /* Set after we scan builtin drivers */
1916 
1917 void * scsi_init_malloc(unsigned int size, int priority)
     /*  */
1918 {
1919   unsigned long retval;
1920 
1921 /* Use the statically allocated memory instead of kmalloc  (DB) */
1922 #if defined(USE_STATIC_SCSI_MEMORY)
1923   if(scsi_loadable_module_flag && !(priority & GFP_DMA))
1924 #else
1925   if(scsi_loadable_module_flag)
1926 #endif
1927     retval = (unsigned long) kmalloc(size, priority);
1928   else {
1929     /*
1930      * Keep all memory aligned on 16-byte boundaries. Some host adaptors
1931      * (e.g. BusLogic BT-445S) require DMA buffers to be aligned that way.
1932      */
1933     size = (size + 15) & ~15;
1934 
1935     if(scsi_loadable_module_flag &&
1936        (scsi_init_memory_start + size) > scsi_memory_upper_value) {
1937        retval = 0;
1938        printk("scsi_init_malloc: no more statically allocated memory.\n");
1939        }
1940     else {
1941        retval = scsi_init_memory_start;
1942        scsi_init_memory_start += size;
1943        }
1944     }
1945   memset((void *) retval, 0, size);
1946   return (void *) retval;
1947 }
1948 
1949 
1950 void scsi_init_free(char * ptr, unsigned int size)
     /*  */
1951 { /* We need to compare addresses to see whether this was kmalloc'd or not */
1952 
1953   if((unsigned long) ptr >= scsi_init_memory_start ||
1954      (unsigned long) ptr <  scsi_memory_lower_value) kfree(ptr);
1955   else {
1956     size = (size + 15) & ~15; /* Use the same alignment as scsi_init_malloc() */
1957 
1958     if(((unsigned long) ptr) + size == scsi_init_memory_start)
1959       scsi_init_memory_start = (unsigned long) ptr;
1960     }
1961 }
1962 
1963 /*
1964         scsi_dev_init() is our initialization routine, which in turn calls host
1965         initialization, bus scanning, and sd/st initialization routines.  It
1966         should be called from main().
1967 */
1968 
1969 unsigned long scsi_dev_init (unsigned long memory_start,unsigned long memory_end)
     /*  */
1970         {
1971         struct Scsi_Host * host = NULL;
1972         Scsi_Device * SDpnt;
1973         struct Scsi_Host * shpnt;
1974         struct Scsi_Device_Template * sdtpnt;
1975         Scsi_Cmnd * SCpnt;
1976         int i;
1977 #ifdef FOO_ON_YOU
1978         return;
1979 #endif
1980 
1981         /* Init a few things so we can "malloc" memory. */
1982         scsi_loadable_module_flag = 0;
1983         /* Align everything on 16-byte boundaries. */
1984         scsi_init_memory_start = (memory_start + 15) & ~ 15;
1985         scsi_memory_lower_value = scsi_init_memory_start;
1986 
1987         timer_table[SCSI_TIMER].fn = scsi_main_timeout;
1988         timer_table[SCSI_TIMER].expires = 0;
1989 
1990         /* initialize all hosts */
1991         scsi_init();
1992 
1993         scsi_devices = (Scsi_Device *) NULL;
1994 
1995         for (shpnt = scsi_hostlist; shpnt; shpnt = shpnt->next)
1996           scan_scsis(shpnt);           /* scan for scsi devices */
1997 
1998         printk("scsi : detected ");
1999         for (sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2000           if (sdtpnt->dev_noticed && sdtpnt->name)
2001             printk("%d SCSI %s%s ", sdtpnt->dev_noticed, sdtpnt->name,
2002             (sdtpnt->dev_noticed != 1) ? "s" : "");
2003         printk("total.\n");
2004 
2005         for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2006           if(sdtpnt->init && sdtpnt->dev_noticed) (*sdtpnt->init)();
2007 
2008         for (SDpnt=scsi_devices; SDpnt; SDpnt = SDpnt->next) {
2009           int j;
2010           SDpnt->scsi_request_fn = NULL;
2011           for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2012               if(sdtpnt->attach) (*sdtpnt->attach)(SDpnt);
2013 
2014           if(SDpnt->attached){
2015             for(j=0;j<SDpnt->host->cmd_per_lun;j++){
2016               SCpnt = (Scsi_Cmnd *) scsi_init_malloc(sizeof(Scsi_Cmnd), GFP_ATOMIC);
2017               SCpnt->host = SDpnt->host;
2018               SCpnt->device = SDpnt;
2019               SCpnt->target = SDpnt->id;
2020               SCpnt->lun = SDpnt->lun;
2021               SCpnt->request.dev = -1; /* Mark not busy */
2022               SCpnt->use_sg = 0;
2023               SCpnt->old_use_sg = 0;
2024               SCpnt->old_cmd_len = 0;
2025               SCpnt->timeout = 0;
2026               SCpnt->underflow = 0;
2027               SCpnt->transfersize = 0;
2028               SCpnt->host_scribble = NULL;
2029               host = SDpnt->host;
2030               if(host->host_queue)
2031                 host->host_queue->prev = SCpnt;
2032               SCpnt->next = host->host_queue;
2033               SCpnt->prev = NULL;
2034               host->host_queue = SCpnt;
2035             }
2036           }
2037         }
2038 
2039         if (scsi_devicelist)
2040           dma_sectors = 16;  /* Base value we use */
2041 
2042         if (memory_end-1 > ISA_DMA_THRESHOLD)
2043           scsi_need_isa_bounce_buffers = 1;
2044         else
2045           scsi_need_isa_bounce_buffers = 0;
2046 
2047         for (SDpnt=scsi_devices; SDpnt; SDpnt = SDpnt->next) {
2048           host = SDpnt->host;
2049 
2050           if(SDpnt->type != TYPE_TAPE)
2051             dma_sectors += ((host->sg_tablesize *
2052                              sizeof(struct scatterlist) + 511) >> 9) *
2053                                host->cmd_per_lun;
2054 
2055           if(host->unchecked_isa_dma &&
2056              memory_end - 1 > ISA_DMA_THRESHOLD &&
2057              SDpnt->type != TYPE_TAPE) {
2058             dma_sectors += (PAGE_SIZE >> 9) * host->sg_tablesize *
2059               host->cmd_per_lun;
2060             need_isa_buffer++;
2061           }
2062         }
2063 
2064         dma_sectors = (dma_sectors + 15) & 0xfff0;
2065         dma_free_sectors = dma_sectors;  /* This must be a multiple of 16 */
2066 
2067         dma_malloc_freelist = (unsigned char *)
2068           scsi_init_malloc(dma_sectors >> 3, GFP_ATOMIC);
2069         memset(dma_malloc_freelist, 0, dma_sectors >> 3);
2070 
2071         dma_malloc_pages = (unsigned char **)
2072           scsi_init_malloc(dma_sectors >> 1, GFP_ATOMIC);
2073         memset(dma_malloc_pages, 0, dma_sectors >> 1);
2074 
2075         for(i=0; i< dma_sectors >> 3; i++)
2076           dma_malloc_pages[i] = (unsigned char *)
2077             scsi_init_malloc(PAGE_SIZE, GFP_ATOMIC | GFP_DMA);
2078 
2079 
2080         /* OK, now we finish the initialization by doing spin-up, read
2081            capacity, etc, etc */
2082         for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2083           if(sdtpnt->finish && sdtpnt->nr_dev)
2084             (*sdtpnt->finish)();
2085 
2086         scsi_loadable_module_flag = 1;
2087 
2088 
2089 /* This allocates statically some extra memory to be used for modules,
2090    until the kmalloc problem is fixed (DB) */
2091 
2092 #if defined(USE_STATIC_SCSI_MEMORY)
2093         scsi_memory_upper_value = scsi_init_memory_start + 256 * 1024;
2094         printk ("SCSI memory: total %ldKb, used %ldKb, free %ldKb.\n",
2095                 (scsi_memory_upper_value - scsi_memory_lower_value) / 1024,
2096                 (scsi_init_memory_start - scsi_memory_lower_value) / 1024,
2097                 (scsi_memory_upper_value - scsi_init_memory_start) / 1024);
2098         return scsi_memory_upper_value;
2099 #else
2100         return scsi_init_memory_start;
2101 #endif
2102         }
2103 
2104 static void print_inquiry(unsigned char *data)
     /*  */
2105 {
2106         int i;
2107 
2108         printk("  Vendor: ");
2109         for (i = 8; i < 16; i++)
2110                 {
2111                 if (data[i] >= 0x20 && i < data[4] + 5)
2112                         printk("%c", data[i]);
2113                 else
2114                         printk(" ");
2115                 }
2116 
2117         printk("  Model: ");
2118         for (i = 16; i < 32; i++)
2119                 {
2120                 if (data[i] >= 0x20 && i < data[4] + 5)
2121                         printk("%c", data[i]);
2122                 else
2123                         printk(" ");
2124                 }
2125 
2126         printk("  Rev: ");
2127         for (i = 32; i < 36; i++)
2128                 {
2129                 if (data[i] >= 0x20 && i < data[4] + 5)
2130                         printk("%c", data[i]);
2131                 else
2132                         printk(" ");
2133                 }
2134 
2135         printk("\n");
2136 
2137         i = data[0] & 0x1f;
2138 
2139         printk("  Type:   %s ",
2140                i < MAX_SCSI_DEVICE_CODE ? scsi_device_types[i] : "Unknown          " );
2141         printk("                 ANSI SCSI revision: %02x", data[2] & 0x07);
2142         if ((data[2] & 0x07) == 1 && (data[3] & 0x0f) == 1)
2143           printk(" CCS\n");
2144         else
2145           printk("\n");
2146 }
2147 
2148 /*
2149  * This entry point should be called by a loadable module if it is trying
2150  * add a low level scsi driver to the system.
2151  */
2152 static int scsi_register_host(Scsi_Host_Template * tpnt)
     /*  */
2153 {
2154   int pcount;
2155   struct Scsi_Host * shpnt;
2156   struct Scsi_Host * host = NULL;
2157   unsigned long flags;
2158   Scsi_Device * SDpnt;
2159   Scsi_Cmnd * SCpnt;
2160   struct Scsi_Device_Template * sdtpnt;
2161   int j, i;
2162   const char * name;
2163 
2164   if (tpnt->next || !tpnt->detect) return 1;  /* Must be already loaded, or
2165                                                no detect routine available */
2166   pcount = next_scsi_host;
2167   if ((tpnt->present = tpnt->detect(tpnt)))
2168     {
2169       if(pcount == next_scsi_host) {
2170         if(tpnt->present > 1) {
2171           printk("Failure to register low-level scsi driver");
2172           scsi_unregister_host(tpnt);
2173           return 1;
2174         }
2175         /* The low-level driver failed to register a driver.  We
2176            can do this now. */
2177         scsi_register(tpnt,0);
2178       }
2179       tpnt->next = scsi_hosts; /* Add to the linked list */
2180       scsi_hosts = tpnt;
2181 
2182       for(shpnt=scsi_hostlist; shpnt; shpnt = shpnt->next)
2183         if(shpnt->hostt == tpnt)
2184           {
2185             if(tpnt->info)
2186               name = tpnt->info(shpnt);
2187             else
2188               name = tpnt->name;
2189             printk ("scsi%d : %s\n", /* And print a little message */
2190                     shpnt->host_no, name);
2191           }
2192 
2193       printk ("scsi : %d host%s.\n", next_scsi_host,
2194                 (next_scsi_host == 1) ? "" : "s");
2195 
2196       scsi_make_blocked_list();
2197 
2198       /* The next step is to call scan_scsis here.  This generates the
2199          Scsi_Devices entries */
2200 
2201       for(shpnt=scsi_hostlist; shpnt; shpnt = shpnt->next)
2202         if(shpnt->hostt == tpnt) scan_scsis(shpnt);
2203 
2204       for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2205         if(sdtpnt->init && sdtpnt->dev_noticed) (*sdtpnt->init)();
2206 
2207       /* Next we create the Scsi_Cmnd structures for this host */
2208 
2209       for(SDpnt = scsi_devices; SDpnt; SDpnt = SDpnt->next)
2210         if(SDpnt->host->hostt == tpnt)
2211           {
2212             for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2213               if(sdtpnt->attach) (*sdtpnt->attach)(SDpnt);
2214             if(SDpnt->attached){
2215               for(j=0;j<SDpnt->host->cmd_per_lun;j++){
2216                 SCpnt = (Scsi_Cmnd *) scsi_init_malloc(sizeof(Scsi_Cmnd), GFP_ATOMIC);
2217                 SCpnt->host = SDpnt->host;
2218                 SCpnt->device = SDpnt;
2219                 SCpnt->target = SDpnt->id;
2220                 SCpnt->lun = SDpnt->lun;
2221                 SCpnt->request.dev = -1; /* Mark not busy */
2222                 SCpnt->request.sem = NULL;
2223                 SCpnt->use_sg = 0;
2224                 SCpnt->old_use_sg = 0;
2225                 SCpnt->underflow = 0;
2226                 SCpnt->timeout = 0;
2227                 SCpnt->transfersize = 0;
2228                 SCpnt->host_scribble = NULL;
2229                 host = SDpnt->host;
2230                 SCpnt->next = host->host_queue;
2231                 SCpnt->prev = NULL;
2232                 host->host_queue = SCpnt;
2233                 if(host->host_queue)
2234                   host->host_queue->prev = SCpnt;
2235               }
2236             }
2237           }
2238         /* Next, check to see if we need to extend the DMA buffer pool */
2239       {
2240           unsigned char * new_dma_malloc_freelist = NULL;
2241           unsigned int new_dma_sectors = 0;
2242           unsigned int new_need_isa_buffer = 0;
2243           unsigned char ** new_dma_malloc_pages = NULL;
2244 
2245           if (scsi_devicelist)
2246             new_dma_sectors = 16;  /* Base value we use */
2247 
2248           for (SDpnt=scsi_devices; SDpnt; SDpnt = SDpnt->next) {
2249             host = SDpnt->host;
2250 
2251             if(SDpnt->type != TYPE_TAPE)
2252               new_dma_sectors += ((host->sg_tablesize *
2253                                    sizeof(struct scatterlist) + 511) >> 9) *
2254                                      host->cmd_per_lun;
2255 
2256             if(host->unchecked_isa_dma &&
2257                scsi_need_isa_bounce_buffers &&
2258                SDpnt->type != TYPE_TAPE) {
2259               new_dma_sectors += (PAGE_SIZE >> 9) * host->sg_tablesize *
2260                 host->cmd_per_lun;
2261               new_need_isa_buffer++;
2262             }
2263           }
2264 
2265           new_dma_sectors = (new_dma_sectors + 15) & 0xfff0;
2266 
2267           new_dma_malloc_freelist = (unsigned char *)
2268             scsi_init_malloc(new_dma_sectors >> 3, GFP_ATOMIC);
2269           memset(new_dma_malloc_freelist, 0, new_dma_sectors >> 3);
2270 
2271           new_dma_malloc_pages = (unsigned char **)
2272             scsi_init_malloc(new_dma_sectors >> 1, GFP_ATOMIC);
2273           memset(new_dma_malloc_pages, 0, new_dma_sectors >> 1);
2274 
2275           for(i=dma_sectors >> 3; i< new_dma_sectors >> 3; i++)
2276             new_dma_malloc_pages[i] = (unsigned char *)
2277               scsi_init_malloc(PAGE_SIZE, GFP_ATOMIC | GFP_DMA);
2278 
2279 
2280           /* When we dick with the actual DMA list, we need to protect things */
2281 
2282           save_flags(flags);
2283           cli();
2284           memcpy(new_dma_malloc_freelist, dma_malloc_freelist, dma_sectors >> 3);
2285           scsi_init_free(dma_malloc_freelist, dma_sectors>>3);
2286           dma_malloc_freelist = new_dma_malloc_freelist;
2287 
2288           memcpy(new_dma_malloc_pages, dma_malloc_pages, dma_sectors >> 1);
2289           scsi_init_free((char *) dma_malloc_pages, dma_sectors>>1);
2290 
2291           dma_free_sectors += new_dma_sectors - dma_sectors;
2292           dma_malloc_pages = new_dma_malloc_pages;
2293           dma_sectors = new_dma_sectors;
2294           need_isa_buffer = new_need_isa_buffer;
2295           restore_flags(flags);
2296 
2297 
2298         }
2299       /* This does any final handling that is required. */
2300       for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2301         if(sdtpnt->finish && sdtpnt->nr_dev)
2302           (*sdtpnt->finish)();
2303     }
2304 
2305 #if defined(USE_STATIC_SCSI_MEMORY)
2306   printk ("SCSI memory: total %ldKb, used %ldKb, free %ldKb.\n",
2307           (scsi_memory_upper_value - scsi_memory_lower_value) / 1024,
2308           (scsi_init_memory_start - scsi_memory_lower_value) / 1024,
2309           (scsi_memory_upper_value - scsi_init_memory_start) / 1024);
2310 #endif
2311 
2312   return 0;
2313 }
2314 
2315 /*
2316  * Similarly, this entry point should be called by a loadable module if it
2317  * is trying to remove a low level scsi driver from the system.
2318  */
2319 static void scsi_unregister_host(Scsi_Host_Template * tpnt)
     /*  */
2320 {
2321   Scsi_Host_Template * SHT, *SHTp;
2322   Scsi_Device *sdpnt, * sdppnt, * sdpnt1;
2323   Scsi_Cmnd * SCpnt;
2324   unsigned long flags;
2325   struct Scsi_Device_Template * sdtpnt;
2326   struct Scsi_Host * shpnt, *sh1;
2327   int pcount;
2328 
2329   /* First verify that this host adapter is completely free with no pending
2330      commands */
2331 
2332   for(sdpnt = scsi_devices; sdpnt; sdpnt = sdpnt->next)
2333     if(sdpnt->host->hostt == tpnt && sdpnt->host->hostt->usage_count
2334                                  && *sdpnt->host->hostt->usage_count) return;
2335 
2336   for(shpnt = scsi_hostlist; shpnt; shpnt = shpnt->next)
2337     {
2338       if (shpnt->hostt != tpnt) continue;
2339       for(SCpnt = shpnt->host_queue; SCpnt; SCpnt = SCpnt->next)
2340         {
2341           save_flags(flags);
2342           cli();
2343           if(SCpnt->request.dev != -1) {
2344             restore_flags(flags);
2345             for(SCpnt = shpnt->host_queue; SCpnt; SCpnt = SCpnt->next)
2346               if(SCpnt->request.dev == 0xffe0) SCpnt->request.dev = -1;
2347             printk("Device busy???\n");
2348             return;
2349           }
2350           SCpnt->request.dev = 0xffe0;  /* Mark as busy */
2351           restore_flags(flags);
2352         }
2353     }
2354   /* Next we detach the high level drivers from the Scsi_Device structures */
2355 
2356   for(sdpnt = scsi_devices; sdpnt; sdpnt = sdpnt->next)
2357     if(sdpnt->host->hostt == tpnt)
2358       {
2359         for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2360           if(sdtpnt->detach) (*sdtpnt->detach)(sdpnt);
2361         /* If something still attached, punt */
2362         if (sdpnt->attached) {
2363           printk("Attached usage count = %d\n", sdpnt->attached);
2364           return;
2365         }
2366       }
2367 
2368   /* Next we free up the Scsi_Cmnd structures for this host */
2369 
2370   for(sdpnt = scsi_devices; sdpnt; sdpnt = sdpnt->next)
2371     if(sdpnt->host->hostt == tpnt)
2372       while (sdpnt->host->host_queue) {
2373         SCpnt = sdpnt->host->host_queue->next;
2374         scsi_init_free((char *) sdpnt->host->host_queue, sizeof(Scsi_Cmnd));
2375         sdpnt->host->host_queue = SCpnt;
2376         if (SCpnt) SCpnt->prev = NULL;
2377       }
2378 
2379   /* Next free up the Scsi_Device structures for this host */
2380 
2381   sdppnt = NULL;
2382   for(sdpnt = scsi_devices; sdpnt; sdpnt = sdpnt1)
2383     {
2384       sdpnt1 = sdpnt->next;
2385       if (sdpnt->host->hostt == tpnt) {
2386         if (sdppnt)
2387           sdppnt->next = sdpnt->next;
2388         else
2389           scsi_devices = sdpnt->next;
2390         scsi_init_free((char *) sdpnt, sizeof (Scsi_Device));
2391       } else
2392         sdppnt = sdpnt;
2393     }
2394 
2395   /* Next we go through and remove the instances of the individual hosts
2396      that were detected */
2397 
2398   shpnt = scsi_hostlist;
2399   while(shpnt) {
2400    sh1 = shpnt->next;
2401     if(shpnt->hostt == tpnt) {
2402       if(shpnt->loaded_as_module) {
2403         pcount = next_scsi_host;
2404         if(tpnt->release)
2405           (*tpnt->release)(shpnt);
2406         else {
2407           /* This is the default case for the release function.  It should do the right
2408              thing for most correctly written host adapters. */
2409           if (shpnt->irq) free_irq(shpnt->irq);
2410           if (shpnt->dma_channel != 0xff) free_dma(shpnt->dma_channel);
2411           if (shpnt->io_port && shpnt->n_io_port)
2412             release_region(shpnt->io_port, shpnt->n_io_port);
2413         }
2414         if(pcount == next_scsi_host) scsi_unregister(shpnt);
2415         tpnt->present--;
2416       }
2417     }
2418     shpnt = sh1;
2419   }
2420 
2421   printk ("scsi : %d host%s.\n", next_scsi_host,
2422           (next_scsi_host == 1) ? "" : "s");
2423 
2424 #if defined(USE_STATIC_SCSI_MEMORY)
2425   printk ("SCSI memory: total %ldKb, used %ldKb, free %ldKb.\n",
2426           (scsi_memory_upper_value - scsi_memory_lower_value) / 1024,
2427           (scsi_init_memory_start - scsi_memory_lower_value) / 1024,
2428           (scsi_memory_upper_value - scsi_init_memory_start) / 1024);
2429 #endif
2430 
2431   scsi_make_blocked_list();
2432 
2433   /* There were some hosts that were loaded at boot time, so we cannot
2434      do any more than this */
2435   if (tpnt->present) return;
2436 
2437   /* OK, this is the very last step.  Remove this host adapter from the
2438      linked list. */
2439   for(SHTp=NULL, SHT=scsi_hosts; SHT; SHTp=SHT, SHT=SHT->next)
2440     if(SHT == tpnt) {
2441       if(SHTp)
2442         SHTp->next = SHT->next;
2443       else
2444         scsi_hosts = SHT->next;
2445       SHT->next = NULL;
2446       break;
2447     }
2448 }
2449 
2450 int scsi_register_module(int module_type, void * ptr)
     /*  */
2451 {
2452   switch(module_type){
2453   case MODULE_SCSI_HA:
2454     return scsi_register_host((Scsi_Host_Template *) ptr);
2455     /* The rest of these are not yet implemented */
2456 
2457     /* Load constants.o */
2458   case MODULE_SCSI_CONST:
2459 
2460     /* Load specialized ioctl handler for some device.  Intended for cdroms that
2461        have non-SCSI2 audio command sets. */
2462   case MODULE_SCSI_IOCTL:
2463 
2464     /* Load upper level device handler of some kind */
2465   case MODULE_SCSI_DEV:
2466   default:
2467     return 1;
2468   }
2469 }
2470 
2471 void scsi_unregister_module(int module_type, void * ptr)
     /*  */
2472 {
2473   switch(module_type) {
2474   case MODULE_SCSI_HA:
2475     scsi_unregister_host((Scsi_Host_Template *) ptr);
2476     break;
2477     /* The rest of these are not yet implemented. */
2478   case MODULE_SCSI_CONST:
2479   case MODULE_SCSI_IOCTL:
2480   case MODULE_SCSI_DEV:
2481   default:
2482   }
2483   return;
2484 }
2485 
2486 #ifdef DEBUG_TIMEOUT
2487 static void
2488 scsi_dump_status(void)
     /*  */
2489 {
2490   int i;
2491   struct Scsi_Host * shpnt;
2492   Scsi_Cmnd * SCpnt;
2493   printk("Dump of scsi parameters:\n");
2494   i = 0;
2495   for(shpnt = scsi_hostlist; shpnt; shpnt = shpnt->next)
2496     for(SCpnt=shpnt->host_queue; SCpnt; SCpnt = SCpnt->next)
2497       {
2498         /*  (0) 0:0:0 (802 123434 8 8 0) (3 3 2) (%d %d %d) %d %x      */
2499         printk("(%d) %d:%d:%d (%4.4x %ld %ld %ld %ld) (%d %d %x) (%d %d %d) %x %x %x\n",
2500                i++, SCpnt->host->host_no,
2501                SCpnt->target,
2502                SCpnt->lun,
2503                SCpnt->request.dev,
2504                SCpnt->request.sector,
2505                SCpnt->request.nr_sectors,
2506                SCpnt->request.current_nr_sectors,
2507                SCpnt->use_sg,
2508                SCpnt->retries,
2509                SCpnt->allowed,
2510                SCpnt->flags,
2511                SCpnt->timeout_per_command,
2512                SCpnt->timeout,
2513                SCpnt->internal_timeout,
2514                SCpnt->cmnd[0],
2515                SCpnt->sense_buffer[2],
2516                SCpnt->result);
2517       }
2518   printk("wait_for_request = %p\n", wait_for_request);
2519   /* Now dump the request lists for each block device */
2520   printk("Dump of pending block device requests\n");
2521   for(i=0; i<MAX_BLKDEV; i++)
2522     if(blk_dev[i].current_request)
2523       {
2524         struct request * req;
2525         printk("%d: ", i);
2526         req = blk_dev[i].current_request;
2527         while(req) {
2528           printk("(%x %d %ld %ld %ld) ",
2529                  req->dev,
2530                  req->cmd,
2531                  req->sector,
2532                  req->nr_sectors,
2533                  req->current_nr_sectors);
2534           req = req->next;
2535         }
2536         printk("\n");
2537       }
2538 }
2539 #endif
2540 
2541 /*
2542  * Overrides for Emacs so that we follow Linus's tabbing style.
2543  * Emacs will notice this stuff at the end of the file and automatically
2544  * adjust the settings for this buffer only.  This must remain at the end
2545  * of the file.
2546  * ---------------------------------------------------------------------------
2547  * Local variables:
2548  * c-indent-level: 8
2549  * c-brace-imaginary-offset: 0
2550  * c-brace-offset: -8
2551  * c-argdecl-indent: 8
2552  * c-label-offset: -8
2553  * c-continued-statement-offset: 8
2554  * c-continued-brace-offset: 0
2555  * End:
2556  */