drivers/scsi/sd.c

/* */
This source file includes following definitions.
sd_open
sd_release
sd_geninit
rw_intr
do_sd_request
requeue_sd_request
check_scsidisk_media_change
sd_init_done
sd_init_onedisk
sd_init
sd_finish
sd_detect
sd_attach
revalidate_scsidisk
fop_revalidate_scsidisk
   1 /*
   2  *      sd.c Copyright (C) 1992 Drew Eckhardt 
   3  *           Copyright (C) 1993, 1994 Eric Youngdale
   4  *      Linux scsi disk driver by
   5  *              Drew Eckhardt 
   6  *
   7  *      <drew@colorado.edu>
   8  *
   9  *       Modified by Eric Youngdale ericy@cais.com to
  10  *       add scatter-gather, multiple outstanding request, and other
  11  *       enhancements.
  12  */
  13 
  14 #include <linux/fs.h>
  15 #include <linux/kernel.h>
  16 #include <linux/sched.h>
  17 #include <linux/string.h>
  18 #include <linux/errno.h>
  19 #include <asm/system.h>
  20 
  21 #define MAJOR_NR SCSI_DISK_MAJOR
  22 #include "../block/blk.h"
  23 #include "scsi.h"
  24 #include "hosts.h"
  25 #include "sd.h"
  26 #include "scsi_ioctl.h"
  27 #include "constants.h"
  28 
  29 #include <linux/genhd.h>
  30 
  31 /*
  32 static const char RCSid[] = "$Header:";
  33 */
  34 
  35 #define MAX_RETRIES 5
  36 
  37 /*
  38  *      Time out in seconds for disks and Magneto-opticals (which are slower).
  39  */
  40 
  41 #define SD_TIMEOUT 600
  42 #define SD_MOD_TIMEOUT 750
  43 
  44 #define CLUSTERABLE_DEVICE(SC) (SC->host->hostt->use_clustering && \
  45                             SC->device->type != TYPE_MOD)
  46 
  47 struct hd_struct * sd;
  48 
  49 Scsi_Disk * rscsi_disks;
  50 static int * sd_sizes;
  51 static int * sd_blocksizes;
  52 
  53 extern int sd_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
  54 
  55 static int check_scsidisk_media_change(dev_t);
  56 static int fop_revalidate_scsidisk(dev_t);
  57 
  58 static sd_init_onedisk(int);
  59 
  60 static void requeue_sd_request (Scsi_Cmnd * SCpnt);
  61 
  62 static void sd_init(void);
  63 static void sd_finish(void);
  64 static void sd_attach(Scsi_Device *);
  65 static int sd_detect(Scsi_Device *);
  66 
  67 struct Scsi_Device_Template sd_template = {NULL, "disk", "sd", TYPE_DISK, 
  68                                              SCSI_DISK_MAJOR, 0, 0, 0, 1,
  69                                              sd_detect, sd_init,
  70                                              sd_finish, sd_attach, NULL};
  71 
  72 static int sd_open(struct inode * inode, struct file * filp)
     /*  */
  73 {
  74         int target;
  75         target =  DEVICE_NR(MINOR(inode->i_rdev));
  76 
  77         if(target >= sd_template.dev_max || !rscsi_disks[target].device)
  78           return -ENXIO;   /* No such device */
  79         
  80 /* Make sure that only one process can do a check_change_disk at one time.
  81  This is also used to lock out further access when the partition table is being re-read. */
  82 
  83         while (rscsi_disks[target].device->busy);
  84 
  85         if(rscsi_disks[target].device->removable) {
  86           check_disk_change(inode->i_rdev);
  87 
  88           if(!rscsi_disks[target].device->access_count)
  89             sd_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
  90         };
  91         rscsi_disks[target].device->access_count++;
  92         return 0;
  93 }
  94 
  95 static void sd_release(struct inode * inode, struct file * file)
     /*  */
  96 {
  97         int target;
  98         sync_dev(inode->i_rdev);
  99 
 100         target =  DEVICE_NR(MINOR(inode->i_rdev));
 101 
 102         rscsi_disks[target].device->access_count--;
 103 
 104         if(rscsi_disks[target].device->removable) {
 105           if(!rscsi_disks[target].device->access_count)
 106             sd_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
 107         };
 108 }
 109 
 110 static void sd_geninit(void);
 111 
 112 static struct file_operations sd_fops = {
 113         NULL,                   /* lseek - default */
 114         block_read,             /* read - general block-dev read */
 115         block_write,            /* write - general block-dev write */
 116         NULL,                   /* readdir - bad */
 117         NULL,                   /* select */
 118         sd_ioctl,               /* ioctl */
 119         NULL,                   /* mmap */
 120         sd_open,                /* open code */
 121         sd_release,             /* release */
 122         block_fsync,            /* fsync */
 123         NULL,                   /* fasync */
 124         check_scsidisk_media_change,  /* Disk change */
 125         fop_revalidate_scsidisk     /* revalidate */
 126 };
 127 
 128 static struct gendisk sd_gendisk = {
 129         MAJOR_NR,               /* Major number */
 130         "sd",           /* Major name */
 131         4,              /* Bits to shift to get real from partition */
 132         1 << 4,         /* Number of partitions per real */
 133         0,              /* maximum number of real */
 134         sd_geninit,     /* init function */
 135         NULL,           /* hd struct */
 136         NULL,   /* block sizes */
 137         0,              /* number */
 138         NULL,   /* internal */
 139         NULL            /* next */
 140 };
 141 
 142 static void sd_geninit (void)
     /*  */
 143 {
 144         int i;
 145 
 146         for (i = 0; i < sd_template.dev_max; ++i)
 147           if(rscsi_disks[i].device) 
 148             sd[i << 4].nr_sects = rscsi_disks[i].capacity;
 149         sd_gendisk.nr_real = sd_template.dev_max;
 150 }
 151 
 152 /*
 153         rw_intr is the interrupt routine for the device driver.  It will
 154         be notified on the end of a SCSI read / write, and
 155         will take on of several actions based on success or failure.
 156 */
 157 
 158 static void rw_intr (Scsi_Cmnd *SCpnt)
     /*  */
 159 {
 160   int result = SCpnt->result;
 161   int this_count = SCpnt->bufflen >> 9;
 162 
 163 #ifdef DEBUG
 164   printk("sd%c : rw_intr(%d, %d)\n", 'a' + MINOR(SCpnt->request.dev), SCpnt->host->host_no, result);
 165 #endif
 166 
 167 /*
 168   First case : we assume that the command succeeded.  One of two things will
 169   happen here.  Either we will be finished, or there will be more
 170   sectors that we were unable to read last time.
 171 */
 172 
 173   if (!result) {
 174 
 175 #ifdef DEBUG
 176     printk("sd%c : %d sectors remain.\n", 'a' + MINOR(SCpnt->request.dev), SCpnt->request.nr_sectors);
 177     printk("use_sg is %d\n ",SCpnt->use_sg);
 178 #endif
 179     if (SCpnt->use_sg) {
 180       struct scatterlist * sgpnt;
 181       int i;
 182       sgpnt = (struct scatterlist *) SCpnt->buffer;
 183       for(i=0; i<SCpnt->use_sg; i++) {
 184 #ifdef DEBUG
 185         printk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
 186 #endif
 187         if (sgpnt[i].alt_address) {
 188           if (SCpnt->request.cmd == READ)
 189             memcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
 190           scsi_free(sgpnt[i].address, sgpnt[i].length);
 191         };
 192       };
 193       scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
 194     } else {
 195       if (SCpnt->buffer != SCpnt->request.buffer) {
 196 #ifdef DEBUG
 197         printk("nosg: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
 198                    SCpnt->bufflen);
 199 #endif  
 200           if (SCpnt->request.cmd == READ)
 201             memcpy(SCpnt->request.buffer, SCpnt->buffer,
 202                    SCpnt->bufflen);
 203           scsi_free(SCpnt->buffer, SCpnt->bufflen);
 204       };
 205     };
 206 /*
 207  *      If multiple sectors are requested in one buffer, then
 208  *      they will have been finished off by the first command.  If
 209  *      not, then we have a multi-buffer command.
 210  */
 211     if (SCpnt->request.nr_sectors > this_count)
 212       {
 213         SCpnt->request.errors = 0;
 214         
 215         if (!SCpnt->request.bh)
 216           {
 217 #ifdef DEBUG
 218             printk("sd%c : handling page request, no buffer\n",
 219                    'a' + MINOR(SCpnt->request.dev));
 220 #endif
 221 /*
 222   The SCpnt->request.nr_sectors field is always done in 512 byte sectors,
 223   even if this really isn't the case.
 224 */
 225             panic("sd.c: linked page request (%lx %x)",
 226                   SCpnt->request.sector, this_count);
 227           }
 228       }
 229     end_scsi_request(SCpnt, 1, this_count);
 230     requeue_sd_request(SCpnt);
 231     return;
 232   }
 233 
 234 /* Free up any indirection buffers we allocated for DMA purposes. */
 235     if (SCpnt->use_sg) {
 236       struct scatterlist * sgpnt;
 237       int i;
 238       sgpnt = (struct scatterlist *) SCpnt->buffer;
 239       for(i=0; i<SCpnt->use_sg; i++) {
 240 #ifdef DEBUG
 241         printk("err: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
 242                    SCpnt->bufflen);
 243 #endif
 244         if (sgpnt[i].alt_address) {
 245           scsi_free(sgpnt[i].address, sgpnt[i].length);
 246         };
 247       };
 248       scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
 249     } else {
 250 #ifdef DEBUG
 251       printk("nosgerr: %x %x %d\n",SCpnt->request.buffer, SCpnt->buffer,
 252                    SCpnt->bufflen);
 253 #endif
 254       if (SCpnt->buffer != SCpnt->request.buffer)
 255         scsi_free(SCpnt->buffer, SCpnt->bufflen);
 256     };
 257 
 258 /*
 259         Now, if we were good little boys and girls, Santa left us a request
 260         sense buffer.  We can extract information from this, so we
 261         can choose a block to remap, etc.
 262 */
 263 
 264         if (driver_byte(result) != 0) {
 265           if (suggestion(result) == SUGGEST_REMAP) {
 266 #ifdef REMAP
 267 /*
 268         Not yet implemented.  A read will fail after being remapped,
 269         a write will call the strategy routine again.
 270 */
 271             if rscsi_disks[DEVICE_NR(SCpnt->request.dev)].remap
 272               {
 273                 result = 0;
 274               }
 275             else
 276               
 277 #endif
 278             }
 279 
 280           if ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
 281             if ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
 282               if(rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->removable) {
 283               /* detected disc change.  set a bit and quietly refuse    */
 284               /* further access.                                        */
 285               
 286                 rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
 287                 end_scsi_request(SCpnt, 0, this_count);
 288                 requeue_sd_request(SCpnt);
 289                 return;
 290               }
 291             }
 292           }
 293           
 294 
 295 /*      If we had an ILLEGAL REQUEST returned, then we may have
 296 performed an unsupported command.  The only thing this should be would
 297 be a ten byte read where only a six byte read was supported.  Also,
 298 on a system where READ CAPACITY failed, we have have read past the end
 299 of the  disk. 
 300 */
 301 
 302           if (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
 303             if (rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten) {
 304               rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten = 0;
 305               requeue_sd_request(SCpnt);
 306               result = 0;
 307             } else {
 308             }
 309           }
 310         }  /* driver byte != 0 */
 311         if (result) {
 312                 printk("SCSI disk error : host %d id %d lun %d return code = %x\n",
 313                        rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->host->host_no,
 314                        rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->id,
 315                        rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->lun, result);
 316 
 317                 if (driver_byte(result) & DRIVER_SENSE)
 318                         print_sense("sd", SCpnt);
 319                 end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
 320                 requeue_sd_request(SCpnt);
 321                 return;
 322         }
 323 }
 324 
 325 /*
 326         requeue_sd_request() is the request handler function for the sd driver.
 327         Its function in life is to take block device requests, and translate
 328         them to SCSI commands.
 329 */
 330 
 331 static void do_sd_request (void)
     /*  */
 332 {
 333   Scsi_Cmnd * SCpnt = NULL;
 334   struct request * req = NULL;
 335   int flag = 0;
 336   while (1==1){
 337     cli();
 338     if (CURRENT != NULL && CURRENT->dev == -1) {
 339       sti();
 340       return;
 341     };
 342 
 343     INIT_SCSI_REQUEST;
 344 
 345 
 346 /* We have to be careful here.  allocate_device will get a free pointer, but
 347    there is no guarantee that it is queueable.  In normal usage, we want to
 348    call this, because other types of devices may have the host all tied up,
 349    and we want to make sure that we have at least one request pending for this
 350    type of device.   We can also come through here while servicing an
 351    interrupt, because of the need to start another command.  If we call
 352    allocate_device more than once, then the system can wedge if the command
 353    is not queueable.  The request_queueable function is safe because it checks
 354    to make sure that the host is able to take another command before it returns
 355    a pointer.  */
 356 
 357     if (flag++ == 0)
 358       SCpnt = allocate_device(&CURRENT,
 359                               rscsi_disks[DEVICE_NR(MINOR(CURRENT->dev))].device, 0); 
 360     else SCpnt = NULL;
 361     sti();
 362 
 363 /* This is a performance enhancement.  We dig down into the request list and
 364    try and find a queueable request (i.e. device not busy, and host able to
 365    accept another command.  If we find one, then we queue it. This can
 366    make a big difference on systems with more than one disk drive.  We want
 367    to have the interrupts off when monkeying with the request list, because
 368    otherwise the kernel might try and slip in a request in between somewhere. */
 369 
 370     if (!SCpnt && sd_template.nr_dev > 1){
 371       struct request *req1;
 372       req1 = NULL;
 373       cli();
 374       req = CURRENT;
 375       while(req){
 376         SCpnt = request_queueable(req,
 377                                   rscsi_disks[DEVICE_NR(MINOR(req->dev))].device);
 378         if(SCpnt) break;
 379         req1 = req;
 380         req = req->next;
 381       };
 382       if (SCpnt && req->dev == -1) {
 383         if (req == CURRENT) 
 384           CURRENT = CURRENT->next;
 385         else
 386           req1->next = req->next;
 387       };
 388       sti();
 389     };
 390     
 391     if (!SCpnt) return; /* Could not find anything to do */
 392         
 393     /* Queue command */
 394     requeue_sd_request(SCpnt);
 395   };  /* While */
 396 }    
 397 
 398 static void requeue_sd_request (Scsi_Cmnd * SCpnt)
     /*  */
 399 {
 400         int dev, block, this_count;
 401         unsigned char cmd[10];
 402         int bounce_size, contiguous;
 403         int max_sg;
 404         struct buffer_head * bh, *bhp;
 405         char * buff, *bounce_buffer;
 406 
 407 repeat:
 408 
 409         if(SCpnt->request.dev <= 0) {
 410           do_sd_request();
 411           return;
 412         }
 413 
 414         dev =  MINOR(SCpnt->request.dev);
 415         block = SCpnt->request.sector;
 416         this_count = 0;
 417 
 418 #ifdef DEBUG
 419         printk("Doing sd request, dev = %d, block = %d\n", dev, block);
 420 #endif
 421 
 422         if (dev >= (sd_template.dev_max << 4) || 
 423             !rscsi_disks[DEVICE_NR(dev)].device ||
 424             block + SCpnt->request.nr_sectors > sd[dev].nr_sects)
 425                 {
 426                 end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 427                 goto repeat;
 428                 }
 429 
 430         block += sd[dev].start_sect;
 431         dev = DEVICE_NR(dev);
 432 
 433         if (rscsi_disks[dev].device->changed)
 434                 {
 435 /*
 436  * quietly refuse to do anything to a changed disc until the changed bit has been reset
 437  */
 438                 /* printk("SCSI disk has been changed.  Prohibiting further I/O.\n");   */
 439                 end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 440                 goto repeat;
 441                 }
 442 
 443 #ifdef DEBUG
 444         printk("sd%c : real dev = /dev/sd%c, block = %d\n", 'a' + MINOR(SCpnt->request.dev), dev, block);
 445 #endif
 446 
 447         switch (SCpnt->request.cmd)
 448                 {
 449                 case WRITE :
 450                         if (!rscsi_disks[dev].device->writeable)
 451                                 {
 452                                 end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 453                                 goto repeat;
 454                                 }
 455                         cmd[0] = WRITE_6;
 456                         break;
 457                 case READ :
 458                         cmd[0] = READ_6;
 459                         break;
 460                 default :
 461                         panic ("Unknown sd command %d\n", SCpnt->request.cmd);
 462                       }
 463 
 464         SCpnt->this_count = 0;
 465 
 466         /* If the host adapter can deal with very large scatter-gather
 467            requests, it is a waste of time to cluster */
 468         contiguous = (!CLUSTERABLE_DEVICE(SCpnt) ? 0 :1);
 469         bounce_buffer = NULL;
 470         bounce_size = (SCpnt->request.nr_sectors << 9);
 471 
 472         /* First see if we need a bounce buffer for this request.  If we do, make sure
 473            that we can allocate a buffer.  Do not waste space by allocating a bounce
 474            buffer if we are straddling the 16Mb line */
 475 
 476         
 477         if (contiguous && SCpnt->request.bh &&
 478             ((int) SCpnt->request.bh->b_data) + (SCpnt->request.nr_sectors << 9) - 1 > 
 479             ISA_DMA_THRESHOLD && SCpnt->host->unchecked_isa_dma) {
 480           if(((int) SCpnt->request.bh->b_data) > ISA_DMA_THRESHOLD)
 481             bounce_buffer = (char *) scsi_malloc(bounce_size);
 482           if(!bounce_buffer) contiguous = 0;
 483         };
 484 
 485         if(contiguous && SCpnt->request.bh && SCpnt->request.bh->b_reqnext)
 486           for(bh = SCpnt->request.bh, bhp = bh->b_reqnext; bhp; bh = bhp, 
 487               bhp = bhp->b_reqnext) {
 488             if(!CONTIGUOUS_BUFFERS(bh,bhp)) { 
 489               if(bounce_buffer) scsi_free(bounce_buffer, bounce_size);
 490               contiguous = 0;
 491               break;
 492             } 
 493           };
 494         if (!SCpnt->request.bh || contiguous) {
 495 
 496           /* case of page request (i.e. raw device), or unlinked buffer */
 497           this_count = SCpnt->request.nr_sectors;
 498           buff = SCpnt->request.buffer;
 499           SCpnt->use_sg = 0;
 500 
 501         } else if (SCpnt->host->sg_tablesize == 0 ||
 502                    (need_isa_buffer && 
 503                     dma_free_sectors <= 10)) {
 504 
 505           /* Case of host adapter that cannot scatter-gather.  We also
 506            come here if we are running low on DMA buffer memory.  We set
 507            a threshold higher than that we would need for this request so
 508            we leave room for other requests.  Even though we would not need
 509            it all, we need to be conservative, because if we run low enough
 510            we have no choice but to panic. */
 511 
 512           if (SCpnt->host->sg_tablesize != 0 &&
 513               need_isa_buffer && 
 514               dma_free_sectors <= 10)
 515             printk("Warning: SCSI DMA buffer space running low.  Using non scatter-gather I/O.\n");
 516 
 517           this_count = SCpnt->request.current_nr_sectors;
 518           buff = SCpnt->request.buffer;
 519           SCpnt->use_sg = 0;
 520 
 521         } else {
 522 
 523           /* Scatter-gather capable host adapter */
 524           struct scatterlist * sgpnt;
 525           int count, this_count_max;
 526           int counted;
 527 
 528           bh = SCpnt->request.bh;
 529           this_count = 0;
 530           this_count_max = (rscsi_disks[dev].ten ? 0xffff : 0xff);
 531           count = 0;
 532           bhp = NULL;
 533           while(bh) {
 534             if ((this_count + (bh->b_size >> 9)) > this_count_max) break;
 535             if(!bhp || !CONTIGUOUS_BUFFERS(bhp,bh) ||
 536                !CLUSTERABLE_DEVICE(SCpnt) ||
 537                (SCpnt->host->unchecked_isa_dma &&
 538                ((unsigned int) bh->b_data-1) == ISA_DMA_THRESHOLD)) {
 539               if (count < SCpnt->host->sg_tablesize) count++;
 540               else break;
 541             };
 542             this_count += (bh->b_size >> 9);
 543             bhp = bh;
 544             bh = bh->b_reqnext;
 545           };
 546 #if 0
 547           if(SCpnt->host->unchecked_isa_dma &&
 548              ((unsigned int) SCpnt->request.bh->b_data-1) == ISA_DMA_THRESHOLD) count--;
 549 #endif
 550           SCpnt->use_sg = count;  /* Number of chains */
 551           count = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
 552           while( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
 553             count = count << 1;
 554           SCpnt->sglist_len = count;
 555           max_sg = count / sizeof(struct scatterlist);
 556           if(SCpnt->host->sg_tablesize < max_sg) max_sg = SCpnt->host->sg_tablesize;
 557           sgpnt = (struct scatterlist * ) scsi_malloc(count);
 558           memset(sgpnt, 0, count);  /* Zero so it is easy to fill */
 559           if (!sgpnt) {
 560             printk("Warning - running *really* short on DMA buffers\n");
 561             SCpnt->use_sg = 0;  /* No memory left - bail out */
 562             this_count = SCpnt->request.current_nr_sectors;
 563             buff = SCpnt->request.buffer;
 564           } else {
 565             buff = (char *) sgpnt;
 566             counted = 0;
 567             for(count = 0, bh = SCpnt->request.bh, bhp = bh->b_reqnext;
 568                 count < SCpnt->use_sg && bh; 
 569                 count++, bh = bhp) {
 570 
 571               bhp = bh->b_reqnext;
 572 
 573               if(!sgpnt[count].address) sgpnt[count].address = bh->b_data;
 574               sgpnt[count].length += bh->b_size;
 575               counted += bh->b_size >> 9;
 576 
 577               if (((int) sgpnt[count].address) + sgpnt[count].length - 1 > 
 578                   ISA_DMA_THRESHOLD && (SCpnt->host->unchecked_isa_dma) &&
 579                   !sgpnt[count].alt_address) {
 580                 sgpnt[count].alt_address = sgpnt[count].address;
 581                 /* We try and avoid exhausting the DMA pool, since it is easier
 582                    to control usage here.  In other places we might have a more
 583                    pressing need, and we would be screwed if we ran out */
 584                 if(dma_free_sectors < (sgpnt[count].length >> 9) + 10) {
 585                   sgpnt[count].address = NULL;
 586                 } else {
 587                   sgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
 588                 };
 589 /* If we start running low on DMA buffers, we abort the scatter-gather
 590    operation, and free all of the memory we have allocated.  We want to
 591    ensure that all scsi operations are able to do at least a non-scatter/gather
 592    operation */
 593                 if(sgpnt[count].address == NULL){ /* Out of dma memory */
 594 #if 0
 595                   printk("Warning: Running low on SCSI DMA buffers");
 596                   /* Try switching back to a non scatter-gather operation. */
 597                   while(--count >= 0){
 598                     if(sgpnt[count].alt_address) 
 599                       scsi_free(sgpnt[count].address, sgpnt[count].length);
 600                   };
 601                   this_count = SCpnt->request.current_nr_sectors;
 602                   buff = SCpnt->request.buffer;
 603                   SCpnt->use_sg = 0;
 604                   scsi_free(sgpnt, SCpnt->sglist_len);
 605 #endif
 606                   SCpnt->use_sg = count;
 607                   this_count = counted -= bh->b_size >> 9;
 608                   break;
 609                 };
 610 
 611               };
 612 
 613               /* Only cluster buffers if we know that we can supply DMA buffers
 614                  large enough to satisfy the request.  Do not cluster a new
 615                  request if this would mean that we suddenly need to start
 616                  using DMA bounce buffers */
 617               if(bhp && CONTIGUOUS_BUFFERS(bh,bhp) && CLUSTERABLE_DEVICE(SCpnt)) {
 618                 char * tmp;
 619 
 620                 if (((int) sgpnt[count].address) + sgpnt[count].length +
 621                     bhp->b_size - 1 > ISA_DMA_THRESHOLD && 
 622                     (SCpnt->host->unchecked_isa_dma) &&
 623                     !sgpnt[count].alt_address) continue;
 624 
 625                 if(!sgpnt[count].alt_address) {count--; continue; }
 626                 if(dma_free_sectors > 10)
 627                   tmp = (char *) scsi_malloc(sgpnt[count].length + bhp->b_size);
 628                 else {
 629                   tmp = NULL;
 630                   max_sg = SCpnt->use_sg;
 631                 };
 632                 if(tmp){
 633                   scsi_free(sgpnt[count].address, sgpnt[count].length);
 634                   sgpnt[count].address = tmp;
 635                   count--;
 636                   continue;
 637                 };
 638 
 639                 /* If we are allowed another sg chain, then increment counter so we
 640                    can insert it.  Otherwise we will end up truncating */
 641 
 642                 if (SCpnt->use_sg < max_sg) SCpnt->use_sg++;
 643               };  /* contiguous buffers */
 644             }; /* for loop */
 645 
 646             this_count = counted; /* This is actually how many we are going to transfer */
 647 
 648             if(count < SCpnt->use_sg || SCpnt->use_sg > SCpnt->host->sg_tablesize){
 649               bh = SCpnt->request.bh;
 650               printk("Use sg, count %d %x %d\n", SCpnt->use_sg, count, dma_free_sectors);
 651               printk("maxsg = %x, counted = %d this_count = %d\n", max_sg, counted, this_count);
 652               while(bh){
 653                 printk("[%p %lx] ", bh->b_data, bh->b_size);
 654                 bh = bh->b_reqnext;
 655               };
 656               if(SCpnt->use_sg < 16)
 657                 for(count=0; count<SCpnt->use_sg; count++)
 658                   printk("{%d:%p %p %d}  ", count,
 659                          sgpnt[count].address,
 660                          sgpnt[count].alt_address,
 661                          sgpnt[count].length);
 662               panic("Ooops");
 663             };
 664 
 665             if (SCpnt->request.cmd == WRITE)
 666               for(count=0; count<SCpnt->use_sg; count++)
 667                 if(sgpnt[count].alt_address)
 668                   memcpy(sgpnt[count].address, sgpnt[count].alt_address, 
 669                          sgpnt[count].length);
 670           };  /* Able to malloc sgpnt */
 671         };  /* Host adapter capable of scatter-gather */
 672 
 673 /* Now handle the possibility of DMA to addresses > 16Mb */
 674 
 675         if(SCpnt->use_sg == 0){
 676           if (((int) buff) + (this_count << 9) - 1 > ISA_DMA_THRESHOLD && 
 677             (SCpnt->host->unchecked_isa_dma)) {
 678             if(bounce_buffer)
 679               buff = bounce_buffer;
 680             else
 681               buff = (char *) scsi_malloc(this_count << 9);
 682             if(buff == NULL) {  /* Try backing off a bit if we are low on mem*/
 683               this_count = SCpnt->request.current_nr_sectors;
 684               buff = (char *) scsi_malloc(this_count << 9);
 685               if(!buff) panic("Ran out of DMA buffers.");
 686             };
 687             if (SCpnt->request.cmd == WRITE)
 688               memcpy(buff, (char *)SCpnt->request.buffer, this_count << 9);
 689           };
 690         };
 691 #ifdef DEBUG
 692         printk("sd%c : %s %d/%d 512 byte blocks.\n", 'a' + MINOR(SCpnt->request.dev),
 693                 (SCpnt->request.cmd == WRITE) ? "writing" : "reading",
 694                 this_count, SCpnt->request.nr_sectors);
 695 #endif
 696 
 697         cmd[1] = (SCpnt->lun << 5) & 0xe0;
 698 
 699         if (rscsi_disks[dev].sector_size == 1024){
 700           if(block & 1) panic("sd.c:Bad block number requested");
 701           if(this_count & 1) panic("sd.c:Bad block number requested");
 702           block = block >> 1;
 703           this_count = this_count >> 1;
 704         };
 705 
 706         if (rscsi_disks[dev].sector_size == 256){
 707           block = block << 1;
 708           this_count = this_count << 1;
 709         };
 710 
 711         if (((this_count > 0xff) ||  (block > 0x1fffff)) && rscsi_disks[dev].ten)
 712                 {
 713                 if (this_count > 0xffff)
 714                         this_count = 0xffff;
 715 
 716                 cmd[0] += READ_10 - READ_6 ;
 717                 cmd[2] = (unsigned char) (block >> 24) & 0xff;
 718                 cmd[3] = (unsigned char) (block >> 16) & 0xff;
 719                 cmd[4] = (unsigned char) (block >> 8) & 0xff;
 720                 cmd[5] = (unsigned char) block & 0xff;
 721                 cmd[6] = cmd[9] = 0;
 722                 cmd[7] = (unsigned char) (this_count >> 8) & 0xff;
 723                 cmd[8] = (unsigned char) this_count & 0xff;
 724                 }
 725         else
 726                 {
 727                 if (this_count > 0xff)
 728                         this_count = 0xff;
 729 
 730                 cmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
 731                 cmd[2] = (unsigned char) ((block >> 8) & 0xff);
 732                 cmd[3] = (unsigned char) block & 0xff;
 733                 cmd[4] = (unsigned char) this_count;
 734                 cmd[5] = 0;
 735                 }
 736 
 737 /*
 738  * We shouldn't disconnect in the middle of a sector, so with a dumb 
 739  * host adapter, it's safe to assume that we can at least transfer 
 740  * this many bytes between each connect / disconnect.  
 741  */
 742 
 743         SCpnt->transfersize = rscsi_disks[dev].sector_size;
 744         SCpnt->underflow = this_count << 9; 
 745         scsi_do_cmd (SCpnt, (void *) cmd, buff, 
 746                      this_count * rscsi_disks[dev].sector_size,
 747                      rw_intr, 
 748                      (SCpnt->device->type == TYPE_DISK ? 
 749                                      SD_TIMEOUT : SD_MOD_TIMEOUT),
 750                      MAX_RETRIES);
 751 }
 752 
 753 static int check_scsidisk_media_change(dev_t full_dev){
     /*  */
 754         int retval;
 755         int target;
 756         struct inode inode;
 757         int flag = 0;
 758 
 759         target =  DEVICE_NR(MINOR(full_dev));
 760 
 761         if (target >= sd_template.dev_max ||
 762             !rscsi_disks[target].device) {
 763                 printk("SCSI disk request error: invalid device.\n");
 764                 return 0;
 765         };
 766 
 767         if(!rscsi_disks[target].device->removable) return 0;
 768 
 769         inode.i_rdev = full_dev;  /* This is all we really need here */
 770         retval = sd_ioctl(&inode, NULL, SCSI_IOCTL_TEST_UNIT_READY, 0);
 771 
 772         if(retval){ /* Unable to test, unit probably not ready.  This usually
 773                      means there is no disc in the drive.  Mark as changed,
 774                      and we will figure it out later once the drive is
 775                      available again.  */
 776 
 777           rscsi_disks[target].device->changed = 1;
 778           return 1; /* This will force a flush, if called from
 779                        check_disk_change */
 780         };
 781 
 782         retval = rscsi_disks[target].device->changed;
 783         if(!flag) rscsi_disks[target].device->changed = 0;
 784         return retval;
 785 }
 786 
 787 static void sd_init_done (Scsi_Cmnd * SCpnt)
     /*  */
 788 {
 789   struct request * req;
 790   
 791   req = &SCpnt->request;
 792   req->dev = 0xfffe; /* Busy, but indicate request done */
 793   
 794   if (req->sem != NULL) {
 795     up(req->sem);
 796   }
 797 }
 798 
 799 static int sd_init_onedisk(int i)
     /*  */
 800 {
 801   int j = 0;
 802   unsigned char cmd[10];
 803   unsigned char *buffer;
 804   char spintime;
 805   int the_result, retries;
 806   Scsi_Cmnd * SCpnt;
 807 
 808   /* We need to retry the READ_CAPACITY because a UNIT_ATTENTION is considered
 809      a fatal error, and many devices report such an error just after a scsi
 810      bus reset. */
 811 
 812   SCpnt = allocate_device(NULL, rscsi_disks[i].device, 1);
 813   buffer = (unsigned char *) scsi_malloc(512);
 814 
 815   spintime = 0;
 816 
 817   /* Spin up drives, as required.  Only do this at boot time */
 818   if (current == task[0]){
 819     do{
 820       cmd[0] = TEST_UNIT_READY;
 821       cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
 822       memset ((void *) &cmd[2], 0, 8);
 823       SCpnt->request.dev = 0xffff;  /* Mark as really busy again */
 824       SCpnt->sense_buffer[0] = 0;
 825       SCpnt->sense_buffer[2] = 0;
 826       
 827       scsi_do_cmd (SCpnt,
 828                    (void *) cmd, (void *) buffer,
 829                    512, sd_init_done,  SD_TIMEOUT,
 830                    MAX_RETRIES);
 831       
 832       while(SCpnt->request.dev != 0xfffe);
 833       
 834       the_result = SCpnt->result;
 835       
 836       /* Look for non-removable devices that return NOT_READY.  Issue command
 837          to spin up drive for these cases. */
 838       if(the_result && !rscsi_disks[i].device->removable && 
 839          SCpnt->sense_buffer[2] == NOT_READY) {
 840         int time1;
 841         if(!spintime){
 842           printk( "sd%c: Spinning up disk...", 'a' + i );
 843           cmd[0] = START_STOP;
 844           cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
 845           cmd[1] |= 1;  /* Return immediately */
 846           memset ((void *) &cmd[2], 0, 8);
 847           cmd[4] = 1; /* Start spin cycle */
 848           SCpnt->request.dev = 0xffff;  /* Mark as really busy again */
 849           SCpnt->sense_buffer[0] = 0;
 850           SCpnt->sense_buffer[2] = 0;
 851           
 852           scsi_do_cmd (SCpnt,
 853                        (void *) cmd, (void *) buffer,
 854                        512, sd_init_done,  SD_TIMEOUT,
 855                        MAX_RETRIES);
 856           
 857           while(SCpnt->request.dev != 0xfffe);
 858 
 859           spintime = jiffies;
 860         };
 861 
 862         time1 = jiffies;
 863         while(jiffies < time1 + HZ); /* Wait 1 second for next try */
 864         printk( "." );
 865       };
 866     } while(the_result && spintime && spintime+5000 > jiffies);
 867     if (spintime) {
 868        if (the_result)
 869            printk( "not responding...\n" );
 870        else
 871            printk( "ready\n" );
 872     }
 873   };  /* current == task[0] */
 874 
 875 
 876   retries = 3;
 877   do {
 878     cmd[0] = READ_CAPACITY;
 879     cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
 880     memset ((void *) &cmd[2], 0, 8);
 881     memset ((void *) buffer, 0, 8);
 882     SCpnt->request.dev = 0xffff;  /* Mark as really busy again */
 883     SCpnt->sense_buffer[0] = 0;
 884     SCpnt->sense_buffer[2] = 0;
 885     
 886     scsi_do_cmd (SCpnt,
 887                  (void *) cmd, (void *) buffer,
 888                  8, sd_init_done,  SD_TIMEOUT,
 889                  MAX_RETRIES);
 890     
 891     if (current == task[0])
 892       while(SCpnt->request.dev != 0xfffe);
 893     else
 894       if (SCpnt->request.dev != 0xfffe){
 895         struct semaphore sem = MUTEX_LOCKED;
 896         SCpnt->request.sem = &sem;
 897         down(&sem);
 898         /* Hmm.. Have to ask about this one.. */
 899         while (SCpnt->request.dev != 0xfffe) schedule();
 900       };
 901     
 902     the_result = SCpnt->result;
 903     retries--;
 904 
 905   } while(the_result && retries);
 906 
 907   SCpnt->request.dev = -1;  /* Mark as not busy */
 908 
 909   wake_up(&SCpnt->device->device_wait); 
 910 
 911   /* Wake up a process waiting for device*/
 912 
 913   /*
 914    *    The SCSI standard says "READ CAPACITY is necessary for self configuring software"
 915    *    While not mandatory, support of READ CAPACITY is strongly encouraged.
 916    *    We used to die if we couldn't successfully do a READ CAPACITY.
 917    *    But, now we go on about our way.  The side effects of this are
 918    *
 919    *    1.  We can't know block size with certainty.  I have said "512 bytes is it"
 920    *            as this is most common.
 921    *
 922    *    2.  Recovery from when some one attempts to read past the end of the raw device will
 923    *        be slower.
 924    */
 925 
 926   if (the_result)
 927     {
 928       printk ("sd%c : READ CAPACITY failed.\n"
 929               "sd%c : status = %x, message = %02x, host = %d, driver = %02x \n",
 930               'a' + i, 'a' + i,
 931               status_byte(the_result),
 932               msg_byte(the_result),
 933               host_byte(the_result),
 934               driver_byte(the_result)
 935               );
 936       if (driver_byte(the_result)  & DRIVER_SENSE)
 937         printk("sd%c : extended sense code = %1x \n", 'a' + i, SCpnt->sense_buffer[2] & 0xf);
 938       else
 939         printk("sd%c : sense not available. \n", 'a' + i);
 940 
 941       printk("sd%c : block size assumed to be 512 bytes, disk size 1GB.  \n", 'a' + i);
 942       rscsi_disks[i].capacity = 0x1fffff;
 943       rscsi_disks[i].sector_size = 512;
 944 
 945       /* Set dirty bit for removable devices if not ready - sometimes drives
 946          will not report this properly. */
 947       if(rscsi_disks[i].device->removable && 
 948          SCpnt->sense_buffer[2] == NOT_READY)
 949         rscsi_disks[i].device->changed = 1;
 950 
 951     }
 952   else
 953     {
 954       rscsi_disks[i].capacity = (buffer[0] << 24) |
 955         (buffer[1] << 16) |
 956           (buffer[2] << 8) |
 957             buffer[3];
 958 
 959       rscsi_disks[i].sector_size = (buffer[4] << 24) |
 960         (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
 961 
 962       if (rscsi_disks[i].sector_size != 512 &&
 963           rscsi_disks[i].sector_size != 1024 &&
 964           rscsi_disks[i].sector_size != 256)
 965         {
 966           printk ("sd%c : unsupported sector size %d.\n",
 967                   'a' + i, rscsi_disks[i].sector_size);
 968           if(rscsi_disks[i].device->removable){
 969             rscsi_disks[i].capacity = 0;
 970           } else {
 971             printk ("scsi : deleting disk entry.\n");
 972             rscsi_disks[j].device = NULL;
 973             sd_template.nr_dev--;
 974             return i;
 975           };
 976         }
 977       if(rscsi_disks[i].sector_size == 1024)
 978         rscsi_disks[i].capacity <<= 1;  /* Change this into 512 byte sectors */
 979       if(rscsi_disks[i].sector_size == 256)
 980         rscsi_disks[i].capacity >>= 1;  /* Change this into 512 byte sectors */
 981     }
 982 
 983   rscsi_disks[i].ten = 1;
 984   rscsi_disks[i].remap = 1;
 985   scsi_free(buffer, 512);
 986   return i;
 987 }
 988 
 989 /*
 990         The sd_init() function looks at all SCSI drives present, determines
 991         their size, and reads partition table entries for them.
 992 */
 993 
 994 
 995 static void sd_init()
     /*  */
 996 {
 997         int i;
 998         static int sd_registered = 0;
 999 
1000         if (sd_template.dev_noticed == 0) return;
1001 
1002         if(!sd_registered) {
1003           if (register_blkdev(MAJOR_NR,"sd",&sd_fops)) {
1004             printk("Unable to get major %d for SCSI disk\n",MAJOR_NR);
1005             return;
1006           }
1007           sd_registered++;
1008         }
1009 
1010         /* We do not support attaching loadable devices yet. */
1011         if(scsi_loadable_module_flag) return;
1012 
1013         sd_template.dev_max = sd_template.dev_noticed;
1014 
1015         rscsi_disks = (Scsi_Disk *) 
1016           scsi_init_malloc(sd_template.dev_max * sizeof(Scsi_Disk));
1017         memset(rscsi_disks, 0, sd_template.dev_max * sizeof(Scsi_Disk));
1018 
1019         sd_sizes = (int *) scsi_init_malloc((sd_template.dev_max << 4) * 
1020                                             sizeof(int));
1021         memset(sd_sizes, 0, (sd_template.dev_max << 4) * sizeof(int));
1022 
1023         sd_blocksizes = (int *) scsi_init_malloc((sd_template.dev_max << 4) * 
1024                                                  sizeof(int));
1025         for(i=0;i<(sd_template.dev_max << 4);i++) sd_blocksizes[i] = 1024;
1026         blksize_size[MAJOR_NR] = sd_blocksizes;
1027 
1028         sd = (struct hd_struct *) scsi_init_malloc((sd_template.dev_max << 4) *
1029                                                    sizeof(struct hd_struct));
1030 
1031 
1032         sd_gendisk.max_nr = sd_template.dev_max;
1033         sd_gendisk.part = sd;
1034         sd_gendisk.sizes = sd_sizes;
1035         sd_gendisk.real_devices = (void *) rscsi_disks;
1036 
1037 }
1038 
1039 static void sd_finish()
     /*  */
1040 {
1041         int i;
1042 
1043         for (i = 0; i < sd_template.dev_max; ++i)
1044           if (rscsi_disks[i].device) i = sd_init_onedisk(i);
1045 
1046         blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
1047 
1048         /* If our host adapter is capable of scatter-gather, then we increase
1049            the read-ahead to 16 blocks (32 sectors).  If not, we use
1050            a two block (4 sector) read ahead. */
1051         if(rscsi_disks[0].device->host->sg_tablesize)
1052           read_ahead[MAJOR_NR] = 120;
1053         /* 64 sector read-ahead */
1054         else
1055           read_ahead[MAJOR_NR] = 4;  /* 4 sector read-ahead */
1056         
1057         sd_gendisk.next = gendisk_head;
1058         gendisk_head = &sd_gendisk;
1059         return;
1060 }
1061 
1062 static int sd_detect(Scsi_Device * SDp){
     /*  */
1063   /* We do not support attaching loadable devices yet. */
1064   if(scsi_loadable_module_flag) return 0;
1065   if(SDp->type != TYPE_DISK && SDp->type != TYPE_MOD) return 0;
1066 
1067   printk("Detected scsi disk sd%c at scsi%d, id %d, lun %d\n", 
1068          'a'+ (sd_template.dev_noticed++),
1069          SDp->host->host_no , SDp->id, SDp->lun); 
1070 
1071          return 1;
1072 
1073 }
1074 
1075 static void sd_attach(Scsi_Device * SDp){
     /*  */
1076    Scsi_Disk * dpnt;
1077    int i;
1078 
1079    /* We do not support attaching loadable devices yet. */
1080    if(scsi_loadable_module_flag) return;
1081    if(SDp->type != TYPE_DISK && SDp->type != TYPE_MOD) return;
1082 
1083    if(sd_template.nr_dev >= sd_template.dev_max) 
1084      panic ("scsi_devices corrupt (sd)");
1085 
1086    for(dpnt = rscsi_disks, i=0; i<sd_template.dev_max; i++, dpnt++) 
1087      if(!dpnt->device) break;
1088 
1089    if(i >= sd_template.dev_max) panic ("scsi_devices corrupt (sd)");
1090 
1091    SDp->scsi_request_fn = do_sd_request;
1092    rscsi_disks[i].device = SDp;
1093    sd_template.nr_dev++;
1094 };
1095 
1096 #define DEVICE_BUSY rscsi_disks[target].device->busy
1097 #define USAGE rscsi_disks[target].device->access_count
1098 #define CAPACITY rscsi_disks[target].capacity
1099 #define MAYBE_REINIT  sd_init_onedisk(target)
1100 #define GENDISK_STRUCT sd_gendisk
1101 
1102 /* This routine is called to flush all partitions and partition tables
1103    for a changed scsi disk, and then re-read the new partition table.
1104    If we are revalidating a disk because of a media change, then we
1105    enter with usage == 0.  If we are using an ioctl, we automatically have
1106    usage == 1 (we need an open channel to use an ioctl :-), so this
1107    is our limit.
1108  */
1109 int revalidate_scsidisk(int dev, int maxusage){
     /*  */
1110           int target, major;
1111           struct gendisk * gdev;
1112           int max_p;
1113           int start;
1114           int i;
1115 
1116           target =  DEVICE_NR(MINOR(dev));
1117           gdev = &GENDISK_STRUCT;
1118 
1119           cli();
1120           if (DEVICE_BUSY || USAGE > maxusage) {
1121             sti();
1122             printk("Device busy for revalidation (usage=%d)\n", USAGE);
1123             return -EBUSY;
1124           };
1125           DEVICE_BUSY = 1;
1126           sti();
1127 
1128           max_p = gdev->max_p;
1129           start = target << gdev->minor_shift;
1130           major = MAJOR_NR << 8;
1131 
1132           for (i=max_p - 1; i >=0 ; i--) {
1133             sync_dev(major | start | i);
1134             invalidate_inodes(major | start | i);
1135             invalidate_buffers(major | start | i);
1136             gdev->part[start+i].start_sect = 0;
1137             gdev->part[start+i].nr_sects = 0;
1138           };
1139 
1140 #ifdef MAYBE_REINIT
1141           MAYBE_REINIT;
1142 #endif
1143 
1144           gdev->part[start].nr_sects = CAPACITY;
1145           resetup_one_dev(gdev, target);
1146 
1147           DEVICE_BUSY = 0;
1148           return 0;
1149 }
1150 
1151 static int fop_revalidate_scsidisk(dev_t dev){
     /*  */
1152   return revalidate_scsidisk(dev, 0);
1153 }
1154
/* */
root/drivers/scsi/sd.c

DEFINITIONS
