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   unsigned char cmd[10];
 802   unsigned char *buffer;
 803   char spintime;
 804   int the_result, retries;
 805   Scsi_Cmnd * SCpnt;
 806 
 807   /* We need to retry the READ_CAPACITY because a UNIT_ATTENTION is considered
 808      a fatal error, and many devices report such an error just after a scsi
 809      bus reset. */
 810 
 811   SCpnt = allocate_device(NULL, rscsi_disks[i].device, 1);
 812   buffer = (unsigned char *) scsi_malloc(512);
 813 
 814   spintime = 0;
 815 
 816   /* Spin up drives, as required.  Only do this at boot time */
 817   if (current == task[0]){
 818     do{
 819       cmd[0] = TEST_UNIT_READY;
 820       cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
 821       memset ((void *) &cmd[2], 0, 8);
 822       SCpnt->request.dev = 0xffff;  /* Mark as really busy again */
 823       SCpnt->sense_buffer[0] = 0;
 824       SCpnt->sense_buffer[2] = 0;
 825       
 826       scsi_do_cmd (SCpnt,
 827                    (void *) cmd, (void *) buffer,
 828                    512, sd_init_done,  SD_TIMEOUT,
 829                    MAX_RETRIES);
 830       
 831       while(SCpnt->request.dev != 0xfffe);
 832       
 833       the_result = SCpnt->result;
 834       
 835       /* Look for non-removable devices that return NOT_READY.  Issue command
 836          to spin up drive for these cases. */
 837       if(the_result && !rscsi_disks[i].device->removable && 
 838          SCpnt->sense_buffer[2] == NOT_READY) {
 839         int time1;
 840         if(!spintime){
 841           printk( "sd%c: Spinning up disk...", 'a' + i );
 842           cmd[0] = START_STOP;
 843           cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
 844           cmd[1] |= 1;  /* Return immediately */
 845           memset ((void *) &cmd[2], 0, 8);
 846           cmd[4] = 1; /* Start spin cycle */
 847           SCpnt->request.dev = 0xffff;  /* Mark as really busy again */
 848           SCpnt->sense_buffer[0] = 0;
 849           SCpnt->sense_buffer[2] = 0;
 850           
 851           scsi_do_cmd (SCpnt,
 852                        (void *) cmd, (void *) buffer,
 853                        512, sd_init_done,  SD_TIMEOUT,
 854                        MAX_RETRIES);
 855           
 856           while(SCpnt->request.dev != 0xfffe);
 857 
 858           spintime = jiffies;
 859         };
 860 
 861         time1 = jiffies;
 862         while(jiffies < time1 + HZ); /* Wait 1 second for next try */
 863         printk( "." );
 864       };
 865     } while(the_result && spintime && spintime+5000 > jiffies);
 866     if (spintime) {
 867        if (the_result)
 868            printk( "not responding...\n" );
 869        else
 870            printk( "ready\n" );
 871     }
 872   };  /* current == task[0] */
 873 
 874 
 875   retries = 3;
 876   do {
 877     cmd[0] = READ_CAPACITY;
 878     cmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
 879     memset ((void *) &cmd[2], 0, 8);
 880     memset ((void *) buffer, 0, 8);
 881     SCpnt->request.dev = 0xffff;  /* Mark as really busy again */
 882     SCpnt->sense_buffer[0] = 0;
 883     SCpnt->sense_buffer[2] = 0;
 884     
 885     scsi_do_cmd (SCpnt,
 886                  (void *) cmd, (void *) buffer,
 887                  8, sd_init_done,  SD_TIMEOUT,
 888                  MAX_RETRIES);
 889     
 890     if (current == task[0])
 891       while(SCpnt->request.dev != 0xfffe);
 892     else
 893       if (SCpnt->request.dev != 0xfffe){
 894         struct semaphore sem = MUTEX_LOCKED;
 895         SCpnt->request.sem = &sem;
 896         down(&sem);
 897         /* Hmm.. Have to ask about this one.. */
 898         while (SCpnt->request.dev != 0xfffe) schedule();
 899       };
 900     
 901     the_result = SCpnt->result;
 902     retries--;
 903 
 904   } while(the_result && retries);
 905 
 906   SCpnt->request.dev = -1;  /* Mark as not busy */
 907 
 908   wake_up(&SCpnt->device->device_wait); 
 909 
 910   /* Wake up a process waiting for device*/
 911 
 912   /*
 913    *    The SCSI standard says "READ CAPACITY is necessary for self configuring software"
 914    *    While not mandatory, support of READ CAPACITY is strongly encouraged.
 915    *    We used to die if we couldn't successfully do a READ CAPACITY.
 916    *    But, now we go on about our way.  The side effects of this are
 917    *
 918    *    1.  We can't know block size with certainty.  I have said "512 bytes is it"
 919    *            as this is most common.
 920    *
 921    *    2.  Recovery from when some one attempts to read past the end of the raw device will
 922    *        be slower.
 923    */
 924 
 925   if (the_result)
 926     {
 927       printk ("sd%c : READ CAPACITY failed.\n"
 928               "sd%c : status = %x, message = %02x, host = %d, driver = %02x \n",
 929               'a' + i, 'a' + i,
 930               status_byte(the_result),
 931               msg_byte(the_result),
 932               host_byte(the_result),
 933               driver_byte(the_result)
 934               );
 935       if (driver_byte(the_result)  & DRIVER_SENSE)
 936         printk("sd%c : extended sense code = %1x \n", 'a' + i, SCpnt->sense_buffer[2] & 0xf);
 937       else
 938         printk("sd%c : sense not available. \n", 'a' + i);
 939 
 940       printk("sd%c : block size assumed to be 512 bytes, disk size 1GB.  \n", 'a' + i);
 941       rscsi_disks[i].capacity = 0x1fffff;
 942       rscsi_disks[i].sector_size = 512;
 943 
 944       /* Set dirty bit for removable devices if not ready - sometimes drives
 945          will not report this properly. */
 946       if(rscsi_disks[i].device->removable && 
 947          SCpnt->sense_buffer[2] == NOT_READY)
 948         rscsi_disks[i].device->changed = 1;
 949 
 950     }
 951   else
 952     {
 953       rscsi_disks[i].capacity = (buffer[0] << 24) |
 954         (buffer[1] << 16) |
 955           (buffer[2] << 8) |
 956             buffer[3];
 957 
 958       rscsi_disks[i].sector_size = (buffer[4] << 24) |
 959         (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
 960 
 961       if (rscsi_disks[i].sector_size != 512 &&
 962           rscsi_disks[i].sector_size != 1024 &&
 963           rscsi_disks[i].sector_size != 256)
 964         {
 965           printk ("sd%c : unsupported sector size %d.\n",
 966                   'a' + i, rscsi_disks[i].sector_size);
 967           if(rscsi_disks[i].device->removable){
 968             rscsi_disks[i].capacity = 0;
 969           } else {
 970             printk ("scsi : deleting disk entry.\n");
 971             rscsi_disks[i].device = NULL;
 972             sd_template.nr_dev--;
 973             return i;
 974           };
 975         }
 976       if(rscsi_disks[i].sector_size == 1024)
 977         rscsi_disks[i].capacity <<= 1;  /* Change this into 512 byte sectors */
 978       if(rscsi_disks[i].sector_size == 256)
 979         rscsi_disks[i].capacity >>= 1;  /* Change this into 512 byte sectors */
 980     }
 981 
 982   rscsi_disks[i].ten = 1;
 983   rscsi_disks[i].remap = 1;
 984   scsi_free(buffer, 512);
 985   return i;
 986 }
 987 
 988 /*
 989         The sd_init() function looks at all SCSI drives present, determines
 990         their size, and reads partition table entries for them.
 991 */
 992 
 993 
 994 static void sd_init()
     /*  */
 995 {
 996         int i;
 997         static int sd_registered = 0;
 998 
 999         if (sd_template.dev_noticed == 0) return;
1000 
1001         if(!sd_registered) {
1002           if (register_blkdev(MAJOR_NR,"sd",&sd_fops)) {
1003             printk("Unable to get major %d for SCSI disk\n",MAJOR_NR);
1004             return;
1005           }
1006           sd_registered++;
1007         }
1008 
1009         /* We do not support attaching loadable devices yet. */
1010         if(scsi_loadable_module_flag) return;
1011 
1012         sd_template.dev_max = sd_template.dev_noticed;
1013 
1014         rscsi_disks = (Scsi_Disk *) 
1015           scsi_init_malloc(sd_template.dev_max * sizeof(Scsi_Disk));
1016         memset(rscsi_disks, 0, sd_template.dev_max * sizeof(Scsi_Disk));
1017 
1018         sd_sizes = (int *) scsi_init_malloc((sd_template.dev_max << 4) * 
1019                                             sizeof(int));
1020         memset(sd_sizes, 0, (sd_template.dev_max << 4) * sizeof(int));
1021 
1022         sd_blocksizes = (int *) scsi_init_malloc((sd_template.dev_max << 4) * 
1023                                                  sizeof(int));
1024         for(i=0;i<(sd_template.dev_max << 4);i++) sd_blocksizes[i] = 1024;
1025         blksize_size[MAJOR_NR] = sd_blocksizes;
1026 
1027         sd = (struct hd_struct *) scsi_init_malloc((sd_template.dev_max << 4) *
1028                                                    sizeof(struct hd_struct));
1029 
1030 
1031         sd_gendisk.max_nr = sd_template.dev_max;
1032         sd_gendisk.part = sd;
1033         sd_gendisk.sizes = sd_sizes;
1034         sd_gendisk.real_devices = (void *) rscsi_disks;
1035 
1036 }
1037 
1038 static void sd_finish()
     /*  */
1039 {
1040         int i;
1041 
1042         for (i = 0; i < sd_template.dev_max; ++i)
1043           if (rscsi_disks[i].device) i = sd_init_onedisk(i);
1044 
1045         blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
1046 
1047         /* If our host adapter is capable of scatter-gather, then we increase
1048            the read-ahead to 16 blocks (32 sectors).  If not, we use
1049            a two block (4 sector) read ahead. */
1050         if(rscsi_disks[0].device->host->sg_tablesize)
1051           read_ahead[MAJOR_NR] = 120;
1052         /* 64 sector read-ahead */
1053         else
1054           read_ahead[MAJOR_NR] = 4;  /* 4 sector read-ahead */
1055         
1056         sd_gendisk.next = gendisk_head;
1057         gendisk_head = &sd_gendisk;
1058         return;
1059 }
1060 
1061 static int sd_detect(Scsi_Device * SDp){
     /*  */
1062   /* We do not support attaching loadable devices yet. */
1063   if(scsi_loadable_module_flag) return 0;
1064   if(SDp->type != TYPE_DISK && SDp->type != TYPE_MOD) return 0;
1065 
1066   printk("Detected scsi disk sd%c at scsi%d, id %d, lun %d\n", 
1067          'a'+ (sd_template.dev_noticed++),
1068          SDp->host->host_no , SDp->id, SDp->lun); 
1069 
1070          return 1;
1071 
1072 }
1073 
1074 static void sd_attach(Scsi_Device * SDp){
     /*  */
1075    Scsi_Disk * dpnt;
1076    int i;
1077 
1078    /* We do not support attaching loadable devices yet. */
1079    if(scsi_loadable_module_flag) return;
1080    if(SDp->type != TYPE_DISK && SDp->type != TYPE_MOD) return;
1081 
1082    if(sd_template.nr_dev >= sd_template.dev_max) 
1083      panic ("scsi_devices corrupt (sd)");
1084 
1085    for(dpnt = rscsi_disks, i=0; i<sd_template.dev_max; i++, dpnt++) 
1086      if(!dpnt->device) break;
1087 
1088    if(i >= sd_template.dev_max) panic ("scsi_devices corrupt (sd)");
1089 
1090    SDp->scsi_request_fn = do_sd_request;
1091    rscsi_disks[i].device = SDp;
1092    sd_template.nr_dev++;
1093 };
1094 
1095 #define DEVICE_BUSY rscsi_disks[target].device->busy
1096 #define USAGE rscsi_disks[target].device->access_count
1097 #define CAPACITY rscsi_disks[target].capacity
1098 #define MAYBE_REINIT  sd_init_onedisk(target)
1099 #define GENDISK_STRUCT sd_gendisk
1100 
1101 /* This routine is called to flush all partitions and partition tables
1102    for a changed scsi disk, and then re-read the new partition table.
1103    If we are revalidating a disk because of a media change, then we
1104    enter with usage == 0.  If we are using an ioctl, we automatically have
1105    usage == 1 (we need an open channel to use an ioctl :-), so this
1106    is our limit.
1107  */
1108 int revalidate_scsidisk(int dev, int maxusage){
     /*  */
1109           int target, major;
1110           struct gendisk * gdev;
1111           int max_p;
1112           int start;
1113           int i;
1114 
1115           target =  DEVICE_NR(MINOR(dev));
1116           gdev = &GENDISK_STRUCT;
1117 
1118           cli();
1119           if (DEVICE_BUSY || USAGE > maxusage) {
1120             sti();
1121             printk("Device busy for revalidation (usage=%d)\n", USAGE);
1122             return -EBUSY;
1123           };
1124           DEVICE_BUSY = 1;
1125           sti();
1126 
1127           max_p = gdev->max_p;
1128           start = target << gdev->minor_shift;
1129           major = MAJOR_NR << 8;
1130 
1131           for (i=max_p - 1; i >=0 ; i--) {
1132             sync_dev(major | start | i);
1133             invalidate_inodes(major | start | i);
1134             invalidate_buffers(major | start | i);
1135             gdev->part[start+i].start_sect = 0;
1136             gdev->part[start+i].nr_sects = 0;
1137           };
1138 
1139 #ifdef MAYBE_REINIT
1140           MAYBE_REINIT;
1141 #endif
1142 
1143           gdev->part[start].nr_sects = CAPACITY;
1144           resetup_one_dev(gdev, target);
1145 
1146           DEVICE_BUSY = 0;
1147           return 0;
1148 }
1149 
1150 static int fop_revalidate_scsidisk(dev_t dev){
     /*  */
1151   return revalidate_scsidisk(dev, 0);
1152 }
1153
/* */
root/drivers/scsi/sd.c

DEFINITIONS
