drivers/scsi/sr.c

/* */
This source file includes following definitions.
sr_release
check_cdrom_media_change
rw_intr
sr_photocd
sr_open
do_sr_request
requeue_sr_request
sr_detect
sr_attach
sr_init_done
get_sectorsize
sr_init
sr_finish
sr_detach
init_module
cleanup_module
   1 /*
   2  *  sr.c Copyright (C) 1992 David Giller
   3  *           Copyright (C) 1993, 1994, 1995 Eric Youngdale
   4  *
   5  *  adapted from:
   6  *      sd.c Copyright (C) 1992 Drew Eckhardt 
   7  *      Linux scsi disk driver by
   8  *              Drew Eckhardt <drew@colorado.edu>
   9  *
  10  *      Modified by Eric Youngdale ericy@cais.com to
  11  *      add scatter-gather, multiple outstanding request, and other
  12  *      enhancements.
  13  *
  14  *          Modified by Eric Youngdale eric@aib.com to support loadable
  15  *          low-level scsi drivers.
  16  *
  17  *       Modified by Thomas Quinot thomas@melchior.frmug.fr.net to
  18  *       provide auto-eject.
  19  *
  20  */
  21 
  22 #ifdef MODULE
  23 #include <linux/autoconf.h>
  24 #include <linux/module.h>
  25 #include <linux/version.h>
  26 #endif /* MODULE */
  27 
  28 #include <linux/fs.h>
  29 #include <linux/kernel.h>
  30 #include <linux/sched.h>
  31 #include <linux/mm.h>
  32 #include <linux/string.h>
  33 #include <linux/errno.h>
  34 #include <linux/cdrom.h>
  35 #include <asm/system.h>
  36 
  37 #define MAJOR_NR SCSI_CDROM_MAJOR
  38 #include "../block/blk.h"
  39 #include "scsi.h"
  40 #include "hosts.h"
  41 #include "sr.h"
  42 #include "scsi_ioctl.h"   /* For the door lock/unlock commands */
  43 #include "constants.h"
  44 
  45 #define MAX_RETRIES 3
  46 #define SR_TIMEOUT (150 * HZ)
  47 
  48 static void sr_init(void);
  49 static void sr_finish(void);
  50 static int sr_attach(Scsi_Device *);
  51 static int sr_detect(Scsi_Device *);
  52 static void sr_detach(Scsi_Device *);
  53 
  54 struct Scsi_Device_Template sr_template = {NULL, "cdrom", "sr", NULL, TYPE_ROM, 
  55                                                SCSI_CDROM_MAJOR, 0, 0, 0, 1,
  56                                                sr_detect, sr_init,
  57                                                sr_finish, sr_attach, sr_detach};
  58 
  59 Scsi_CD * scsi_CDs = NULL;
  60 static int * sr_sizes;
  61 
  62 static int * sr_blocksizes;
  63 
  64 static int sr_open(struct inode *, struct file *);
  65 static void get_sectorsize(int);
  66 
  67 extern int sr_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
  68 
  69 void requeue_sr_request (Scsi_Cmnd * SCpnt);
  70 static int check_cdrom_media_change(dev_t);
  71 
  72 static void sr_release(struct inode * inode, struct file * file)
     /*  */
  73 {
  74         sync_dev(inode->i_rdev);
  75         if(! --scsi_CDs[MINOR(inode->i_rdev)].device->access_count)
  76         {
  77             sr_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
  78             if (scsi_CDs[MINOR(inode->i_rdev)].auto_eject)
  79                 sr_ioctl(inode, NULL, CDROMEJECT, 0);
  80         }
  81         if (scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)
  82             (*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)--;
  83         if(sr_template.usage_count) (*sr_template.usage_count)--;
  84 }
  85 
  86 static struct file_operations sr_fops = 
  87 {
  88         NULL,                   /* lseek - default */
  89         block_read,             /* read - general block-dev read */
  90         block_write,    /* write - general block-dev write */
  91         NULL,                   /* readdir - bad */
  92         NULL,                   /* select */
  93         sr_ioctl,               /* ioctl */
  94         NULL,                   /* mmap */
  95         sr_open,        /* special open code */
  96         sr_release,             /* release */
  97         NULL,                   /* fsync */
  98         NULL,                   /* fasync */
  99         check_cdrom_media_change,  /* Disk change */
 100         NULL                    /* revalidate */
 101 };
 102 
 103 /*
 104  * This function checks to see if the media has been changed in the
 105  * CDROM drive.  It is possible that we have already sensed a change,
 106  * or the drive may have sensed one and not yet reported it.  We must
 107  * be ready for either case. This function always reports the current
 108  * value of the changed bit.  If flag is 0, then the changed bit is reset.
 109  * This function could be done as an ioctl, but we would need to have
 110  * an inode for that to work, and we do not always have one.
 111  */
 112 
 113 int check_cdrom_media_change(dev_t full_dev){
     /*  */
 114         int retval, target;
 115         struct inode inode;
 116         int flag = 0;
 117     
 118         target =  MINOR(full_dev);
 119     
 120         if (target >= sr_template.nr_dev) {
 121                 printk("CD-ROM request error: invalid device.\n");
 122                 return 0;
 123         };
 124     
 125         inode.i_rdev = full_dev;  /* This is all we really need here */
 126         retval = sr_ioctl(&inode, NULL, SCSI_IOCTL_TEST_UNIT_READY, 0);
 127     
 128         if(retval){ /* Unable to test, unit probably not ready.  This usually
 129                  * means there is no disc in the drive.  Mark as changed,
 130                  * and we will figure it out later once the drive is
 131                  * available again.  */
 132         
 133         scsi_CDs[target].device->changed = 1;
 134         return 1; /* This will force a flush, if called from
 135                    * check_disk_change */
 136         };
 137     
 138         retval = scsi_CDs[target].device->changed;
 139         if(!flag) {
 140         scsi_CDs[target].device->changed = 0;
 141         /* If the disk changed, the capacity will now be different,
 142          * so we force a re-read of this information */
 143         if (retval) scsi_CDs[target].needs_sector_size = 1;
 144         };
 145         return retval;
 146 }
 147 
 148 /*
 149  * rw_intr is the interrupt routine for the device driver.  It will be notified on the 
 150  * end of a SCSI read / write, and will take on of several actions based on success or failure.
 151  */
 152 
 153 static void rw_intr (Scsi_Cmnd * SCpnt)
     /*  */
 154 {
 155         int result = SCpnt->result;
 156         int this_count = SCpnt->this_count;
 157     
 158 #ifdef DEBUG
 159         printk("sr.c done: %x %x\n",result, SCpnt->request.bh->b_data);
 160 #endif
 161         if (!result)
 162     { /* No error */
 163         if (SCpnt->use_sg == 0) {
 164                     if (SCpnt->buffer != SCpnt->request.buffer)
 165             {
 166                 int offset;
 167                 offset = (SCpnt->request.sector % 4) << 9;
 168                 memcpy((char *)SCpnt->request.buffer, 
 169                        (char *)SCpnt->buffer + offset, 
 170                        this_count << 9);
 171                 /* Even though we are not using scatter-gather, we look
 172                  * ahead and see if there is a linked request for the
 173                  * other half of this buffer.  If there is, then satisfy
 174                  * it. */
 175                 if((offset == 0) && this_count == 2 &&
 176                    SCpnt->request.nr_sectors > this_count && 
 177                    SCpnt->request.bh &&
 178                    SCpnt->request.bh->b_reqnext &&
 179                    SCpnt->request.bh->b_reqnext->b_size == 1024) {
 180                     memcpy((char *)SCpnt->request.bh->b_reqnext->b_data, 
 181                            (char *)SCpnt->buffer + 1024, 
 182                            1024);
 183                     this_count += 2;
 184                 };
 185                 
 186                 scsi_free(SCpnt->buffer, 2048);
 187             }
 188         } else {
 189                     struct scatterlist * sgpnt;
 190                     int i;
 191                     sgpnt = (struct scatterlist *) SCpnt->buffer;
 192                     for(i=0; i<SCpnt->use_sg; i++) {
 193                 if (sgpnt[i].alt_address) {
 194                     if (sgpnt[i].alt_address != sgpnt[i].address) {
 195                         memcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
 196                     };
 197                     scsi_free(sgpnt[i].address, sgpnt[i].length);
 198                 };
 199                     };
 200                     scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
 201                     if(SCpnt->request.sector % 4) this_count -= 2;
 202             /* See   if there is a padding record at the end that needs to be removed */
 203                     if(this_count > SCpnt->request.nr_sectors)
 204                 this_count -= 2;
 205         };
 206         
 207 #ifdef DEBUG
 208                 printk("(%x %x %x) ",SCpnt->request.bh, SCpnt->request.nr_sectors, 
 209                        this_count);
 210 #endif
 211                 if (SCpnt->request.nr_sectors > this_count)
 212         {        
 213                         SCpnt->request.errors = 0;
 214                         if (!SCpnt->request.bh)
 215                             panic("sr.c: linked page request (%lx %x)",
 216                       SCpnt->request.sector, this_count);
 217         }
 218         
 219         SCpnt = end_scsi_request(SCpnt, 1, this_count);  /* All done */
 220         requeue_sr_request(SCpnt);
 221         return;
 222     } /* Normal completion */
 223     
 224         /* We only come through here if we have an error of some kind */
 225     
 226     /* Free up any indirection buffers we allocated for DMA purposes. */
 227         if (SCpnt->use_sg) {
 228         struct scatterlist * sgpnt;
 229         int i;
 230         sgpnt = (struct scatterlist *) SCpnt->buffer;
 231         for(i=0; i<SCpnt->use_sg; i++) {
 232             if (sgpnt[i].alt_address) {
 233                 scsi_free(sgpnt[i].address, sgpnt[i].length);
 234             };
 235         };
 236         scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
 237         } else {
 238         if (SCpnt->buffer != SCpnt->request.buffer)
 239             scsi_free(SCpnt->buffer, SCpnt->bufflen);
 240         };
 241     
 242         if (driver_byte(result) != 0) {
 243                 if ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
 244                         if ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
 245                                 /* detected disc change.  set a bit and quietly refuse 
 246                                  * further access.      */
 247                 
 248                                 scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
 249                                 SCpnt = end_scsi_request(SCpnt, 0, this_count);
 250                 requeue_sr_request(SCpnt);
 251                                 return;
 252                         }
 253                 }
 254             
 255                 if (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
 256                         printk("CD-ROM error: ");
 257                         print_sense("sr", SCpnt);
 258                         printk("command was: ");
 259                         print_command(SCpnt->cmnd);
 260                         if (scsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten) {
 261                                 scsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten = 0;
 262                                 requeue_sr_request(SCpnt);
 263                                 result = 0;
 264                                 return;
 265                         } else {
 266                 SCpnt = end_scsi_request(SCpnt, 0, this_count);
 267                 requeue_sr_request(SCpnt); /* Do next request */
 268                 return;
 269                         }
 270             
 271                 }
 272         
 273                 if (SCpnt->sense_buffer[2] == NOT_READY) {
 274                         printk("CDROM not ready.  Make sure you have a disc in the drive.\n");
 275                         SCpnt = end_scsi_request(SCpnt, 0, this_count);
 276                         requeue_sr_request(SCpnt); /* Do next request */
 277                         return;
 278                 };
 279     }
 280         
 281         /* We only get this far if we have an error we have not recognized */
 282         if(result) {
 283         printk("SCSI CD error : host %d id %d lun %d return code = %03x\n", 
 284                scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->host->host_no, 
 285                scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->id,
 286                scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->lun,
 287                result);
 288             
 289         if (status_byte(result) == CHECK_CONDITION)
 290             print_sense("sr", SCpnt);
 291         
 292         SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
 293         requeue_sr_request(SCpnt);
 294     }
 295 }
 296 
 297 /*
 298  * Here I tried to implement better support for PhotoCD's.
 299  * 
 300  * Much of this has do be done with vendor-specific SCSI-commands.
 301  * So I have to complete it step by step. Useful information is welcome.
 302  *
 303  * Actually works:
 304  *   - NEC:     Detection and support of multisession CD's. Special handling
 305  *              for XA-disks is not necessary.
 306  *     
 307  *   - TOSHIBA: setting density is done here now, mounting PhotoCD's should
 308  *              work now without running the program "set_density"
 309  *              Multisession CD's are supported too.
 310  *
 311  *   kraxel@cs.tu-berlin.de (Gerd Knorr)
 312  */
 313 /*
 314  * 19950704 operator@melchior.frmug.fr.net (Thomas Quinot)
 315  *
 316  *   - SONY:    Same as Nec.
 317  */
 318 
 319 static void sr_photocd(struct inode *inode)
     /*  */
 320 {
 321     unsigned long   sector,min,sec,frame;
 322     unsigned char   buf[40];    /* the buffer for the ioctl */
 323     unsigned char   *cmd;       /* the scsi-command */
 324     unsigned char   *send;      /* the data we send to the drive ... */
 325     unsigned char   *rec;       /* ... and get back */
 326     int             rc,is_xa,no_multi;
 327     
 328     if (scsi_CDs[MINOR(inode->i_rdev)].xa_flags & 0x02) {
 329 #ifdef DEBUG
 330         printk("sr_photocd: CDROM and/or the driver does not support multisession CD's");
 331 #endif
 332         return;
 333     }
 334     
 335     if (!suser()) {
 336         /* I'm not the superuser, so SCSI_IOCTL_SEND_COMMAND isn't allowed for me.
 337          * That's why mpcd_sector will be initialized with zero, because I'm not
 338          * able to get the right value. Necessary only if access_count is 1, else
 339          * no disk change happened since the last call of this function and we can
 340          * keep the old value.
 341          */
 342         if (1 == scsi_CDs[MINOR(inode->i_rdev)].device->access_count) {
 343             scsi_CDs[MINOR(inode->i_rdev)].mpcd_sector = 0;
 344             scsi_CDs[MINOR(inode->i_rdev)].xa_flags &= ~0x01;
 345         }
 346         return;
 347     }
 348     
 349     sector   = 0;
 350     is_xa    = 0;
 351     no_multi = 0;
 352     cmd = rec = &buf[8];
 353     
 354     switch(scsi_CDs[MINOR(inode->i_rdev)].device->manufacturer) {
 355         
 356     case SCSI_MAN_NEC:
 357 #ifdef DEBUG
 358         printk("sr_photocd: use NEC code\n");
 359 #endif
 360         memset(buf,0,40);
 361         *((unsigned long*)buf)   = 0x0;   /* we send nothing...     */
 362         *((unsigned long*)buf+1) = 0x16;  /* and receive 0x16 bytes */
 363         cmd[0] = 0xde;
 364         cmd[1] = 0x03;
 365         cmd[2] = 0xb0;
 366         rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
 367                            SCSI_IOCTL_SEND_COMMAND, buf);
 368         if (rc != 0) {
 369             printk("sr_photocd: ioctl error (NEC): 0x%x\n",rc);
 370             break;
 371         }
 372         if (rec[14] != 0 && rec[14] != 0xb0) {
 373             printk("sr_photocd: Hmm, seems the CDROM doesn't support multisession CD's\n");
 374             no_multi = 1;
 375             break;
 376         }
 377         min   = (unsigned long) rec[15]/16*10 + (unsigned long) rec[15]%16;
 378         sec   = (unsigned long) rec[16]/16*10 + (unsigned long) rec[16]%16;
 379         frame = (unsigned long) rec[17]/16*10 + (unsigned long) rec[17]%16;
 380         sector = min*CD_SECS*CD_FRAMES + sec*CD_FRAMES + frame;
 381         is_xa  = (rec[14] == 0xb0);
 382 #ifdef DEBUG
 383         if (sector) {
 384             printk("sr_photocd: multisession CD detected. start: %lu\n",sector);
 385         }
 386 #endif
 387         break;
 388         
 389     case SCSI_MAN_TOSHIBA:
 390 #ifdef DEBUG
 391         printk("sr_photocd: use TOSHIBA code\n");
 392 #endif
 393         
 394         /* we request some disc information (is it a XA-CD ?,
 395          * where starts the last session ?) */
 396         memset(buf,0,40);
 397         *((unsigned long*)buf)   = 0;
 398         *((unsigned long*)buf+1) = 4;  /* we receive 4 bytes from the drive */
 399         cmd[0] = 0xc7;
 400         cmd[1] = 3;
 401         rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
 402                                SCSI_IOCTL_SEND_COMMAND, buf);
 403         if (rc != 0) {
 404             if (rc == 0x28000002) {
 405                 /* Got a "not ready" - error. No chance to find out if this is
 406                  * because there is no CD in the drive or because the drive
 407                  * don't knows multisession CD's. So I need to do an extra check... */
 408                 if (kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
 409                                       SCSI_IOCTL_TEST_UNIT_READY, NULL)) {
 410                     printk("sr_photocd: drive not ready\n");
 411                 } else {
 412                     printk("sr_photocd: Hmm, seems the CDROM doesn't support multisession CD's\n");
 413                     no_multi = 1;
 414                 }
 415             } else
 416                 printk("sr_photocd: ioctl error (TOSHIBA #1): 0x%x\n",rc);
 417             break; /* if the first ioctl fails, we don't call the second one */
 418         }
 419         is_xa  = (rec[0] == 0x20);
 420         min    = (unsigned long) rec[1]/16*10 + (unsigned long) rec[1]%16;
 421         sec    = (unsigned long) rec[2]/16*10 + (unsigned long) rec[2]%16;
 422         frame  = (unsigned long) rec[3]/16*10 + (unsigned long) rec[3]%16;
 423         sector = min*CD_SECS*CD_FRAMES + sec*CD_FRAMES + frame;
 424         if (sector) {
 425             sector -= CD_BLOCK_OFFSET;
 426 #ifdef DEBUG
 427             printk("sr_photocd: multisession CD detected: start: %lu\n",sector);
 428 #endif
 429         }
 430         
 431         /* now we do a get_density... */
 432         memset(buf,0,40);
 433         *((unsigned long*)buf)   = 0;
 434         *((unsigned long*)buf+1) = 12;
 435         cmd[0] = 0x1a;
 436         cmd[2] = 1;
 437         cmd[4] = 12;
 438         rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
 439                                SCSI_IOCTL_SEND_COMMAND, buf);
 440         if (rc != 0) {
 441             printk("sr_photocd: ioctl error (TOSHIBA #2): 0x%x\n",rc);
 442             break;
 443         }
 444 #ifdef DEBUG
 445         printk("sr_photocd: get_density: 0x%x\n",rec[4]);
 446 #endif
 447         
 448         /* ...and only if necessary a set_density */
 449         if ((rec[4] != 0x81 && is_xa) || (rec[4] != 0 && !is_xa)) {
 450 #ifdef DEBUG
 451             printk("sr_photocd: doing set_density\n");
 452 #endif
 453             memset(buf,0,40);
 454             *((unsigned long*)buf)   = 12;  /* sending 12 bytes... */
 455             *((unsigned long*)buf+1) = 0;
 456             cmd[0] = 0x15;
 457             cmd[1] = (1 << 4);
 458             cmd[4] = 12;
 459             send = &cmd[6];                 /* this is a 6-Byte command          */
 460             send[ 3] = 0x08;                /* the data for the command          */
 461             send[ 4] = (is_xa) ? 0x81 : 0;  /* density 0x81 for XA-CD's, 0 else  */
 462             send[10] = 0x08;
 463             rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
 464                                    SCSI_IOCTL_SEND_COMMAND, buf);
 465             if (rc != 0) {
 466                 printk("sr_photocd: ioctl error (TOSHIBA #3): 0x%x\n",rc);
 467             }
 468             /* The set_density command may have changed the sector size or capacity. */
 469             scsi_CDs[MINOR(inode->i_rdev)].needs_sector_size = 1;
 470         }
 471         break;
 472 
 473     case SCSI_MAN_SONY: /* Thomas QUINOT <thomas@melchior.frmug.fr.net> */
 474 #ifdef DEBUG
 475         printk("sr_photocd: use SONY code\n");
 476 #endif
 477         memset(buf,0,40);
 478         *((unsigned long*)buf)   = 0x0;   /* we send nothing...     */
 479         *((unsigned long*)buf+1) = 0x0c;  /* and receive 0x0c bytes */
 480         cmd[0] = 0x43; /* Read TOC */
 481         cmd[8] = 0x0c;
 482         cmd[9] = 0x40;
 483         rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
 484                                SCSI_IOCTL_SEND_COMMAND, buf);
 485         
 486         if ((rc != 0) || ((rec[0] << 8) + rec[1] != 0x0a)) {
 487             printk("sr_photocd: ioctl error (SONY): 0x%x\n",rc);
 488             break;
 489         }
 490         sector = rec[11] + (rec[10] << 8) + (rec[9] << 16) + (rec[8] << 24);
 491         is_xa = !!sector;
 492 #ifdef DEBUG
 493         if (sector)
 494             printk ("sr_photocd: multisession CD detected. start: %lu\n",sector);
 495 #endif
 496         break;
 497                 
 498     case SCSI_MAN_NEC_OLDCDR:
 499     case SCSI_MAN_UNKNOWN:
 500     default:
 501         sector = 0;
 502         no_multi = 1;
 503         break; }
 504     
 505     scsi_CDs[MINOR(inode->i_rdev)].mpcd_sector = sector;
 506     if (is_xa)
 507         scsi_CDs[MINOR(inode->i_rdev)].xa_flags |= 0x01;
 508     else
 509         scsi_CDs[MINOR(inode->i_rdev)].xa_flags &= ~0x01;
 510     if (no_multi)
 511         scsi_CDs[MINOR(inode->i_rdev)].xa_flags |= 0x02;
 512     return;
 513 }
 514 
 515 static int sr_open(struct inode * inode, struct file * filp)
     /*  */
 516 {
 517         if(MINOR(inode->i_rdev) >= sr_template.nr_dev || 
 518            !scsi_CDs[MINOR(inode->i_rdev)].device) return -ENXIO;   /* No such device */
 519     
 520         if (filp->f_mode & 2)  
 521             return -EROFS;
 522     
 523     check_disk_change(inode->i_rdev);
 524     
 525         if(!scsi_CDs[MINOR(inode->i_rdev)].device->access_count++)
 526         sr_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
 527         if (scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)
 528         (*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)++;
 529         if(sr_template.usage_count) (*sr_template.usage_count)++;
 530     
 531         sr_photocd(inode);
 532     
 533         /* If this device did not have media in the drive at boot time, then
 534          * we would have been unable to get the sector size.  Check to see if
 535          * this is the case, and try again.
 536      */
 537     
 538         if(scsi_CDs[MINOR(inode->i_rdev)].needs_sector_size)
 539         get_sectorsize(MINOR(inode->i_rdev));
 540     
 541         return 0;
 542 }
 543 
 544 
 545 /*
 546  * do_sr_request() is the request handler function for the sr driver.  Its function in life 
 547  * is to take block device requests, and translate them to SCSI commands.
 548  */
 549 
 550 static void do_sr_request (void)
     /*  */
 551 {
 552     Scsi_Cmnd * SCpnt = NULL;
 553     struct request * req = NULL;
 554     unsigned long flags;
 555     int flag = 0;
 556     
 557     while (1==1){
 558         save_flags(flags);
 559         cli();
 560         if (CURRENT != NULL && CURRENT->dev == -1) {
 561             restore_flags(flags);
 562             return;
 563         };
 564         
 565         INIT_SCSI_REQUEST;
 566         
 567         if (flag++ == 0)
 568             SCpnt = allocate_device(&CURRENT,
 569                                     scsi_CDs[DEVICE_NR(MINOR(CURRENT->dev))].device, 0); 
 570         else SCpnt = NULL;
 571         restore_flags(flags);
 572         
 573         /* This is a performance enhancement.  We dig down into the request list and
 574          * try and find a queueable request (i.e. device not busy, and host able to
 575          * accept another command.  If we find one, then we queue it. This can
 576          * make a big difference on systems with more than one disk drive.  We want
 577          * to have the interrupts off when monkeying with the request list, because
 578          * otherwise the kernel might try and slip in a request in between somewhere. */
 579         
 580         if (!SCpnt && sr_template.nr_dev > 1){
 581             struct request *req1;
 582             req1 = NULL;
 583             save_flags(flags);
 584             cli();
 585             req = CURRENT;
 586             while(req){
 587                 SCpnt = request_queueable(req,
 588                                           scsi_CDs[DEVICE_NR(MINOR(req->dev))].device);
 589                 if(SCpnt) break;
 590                 req1 = req;
 591                 req = req->next;
 592             };
 593             if (SCpnt && req->dev == -1) {
 594                 if (req == CURRENT) 
 595                     CURRENT = CURRENT->next;
 596                 else
 597                     req1->next = req->next;
 598             };
 599             restore_flags(flags);
 600         };
 601         
 602         if (!SCpnt)
 603             return; /* Could not find anything to do */
 604         
 605         wake_up(&wait_for_request);
 606 
 607         /* Queue command */
 608         requeue_sr_request(SCpnt);
 609     };  /* While */
 610 }    
 611 
 612 void requeue_sr_request (Scsi_Cmnd * SCpnt)
     /*  */
 613 {
 614         unsigned int dev, block, realcount;
 615         unsigned char cmd[10], *buffer, tries;
 616         int this_count, start, end_rec;
 617     
 618         tries = 2;
 619     
 620  repeat:
 621         if(!SCpnt || SCpnt->request.dev <= 0) {
 622         do_sr_request();
 623         return;
 624         }
 625     
 626         dev =  MINOR(SCpnt->request.dev);
 627         block = SCpnt->request.sector;  
 628         buffer = NULL;
 629         this_count = 0;
 630     
 631         if (dev >= sr_template.nr_dev)
 632     {
 633                 /* printk("CD-ROM request error: invalid device.\n");                   */
 634                 SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 635                 tries = 2;
 636                 goto repeat;
 637     }
 638     
 639         if (!scsi_CDs[dev].use)
 640     {
 641                 /* printk("CD-ROM request error: device marked not in use.\n");         */
 642                 SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 643                 tries = 2;
 644                 goto repeat;
 645     }
 646     
 647         if (scsi_CDs[dev].device->changed)
 648     {
 649         /* 
 650          * quietly refuse to do anything to a changed disc 
 651          * until the changed bit has been reset
 652          */
 653                 /* printk("CD-ROM has been changed.  Prohibiting further I/O.\n");      */
 654                 SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 655                 tries = 2;
 656                 goto repeat;
 657     }
 658         
 659         switch (SCpnt->request.cmd)
 660     {
 661     case WRITE:                 
 662         SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 663         goto repeat;
 664         break;
 665     case READ : 
 666         cmd[0] = READ_6;
 667         break;
 668     default : 
 669         panic ("Unknown sr command %d\n", SCpnt->request.cmd);
 670     }
 671         
 672         cmd[1] = (SCpnt->lun << 5) & 0xe0;
 673     
 674     /*
 675      * Now do the grungy work of figuring out which sectors we need, and
 676          * where in memory we are going to put them.
 677      * 
 678          * The variables we need are:
 679      * 
 680          * this_count= number of 512 byte sectors being read 
 681          * block     = starting cdrom sector to read.
 682          * realcount = # of cdrom sectors to read
 683      * 
 684          * The major difference between a scsi disk and a scsi cdrom
 685      * is that we will always use scatter-gather if we can, because we can
 686      * work around the fact that the buffer cache has a block size of 1024,
 687      * and we have 2048 byte sectors.  This code should work for buffers that
 688      * are any multiple of 512 bytes long.  */
 689     
 690         SCpnt->use_sg = 0;
 691     
 692         if (SCpnt->host->sg_tablesize > 0 &&
 693             (!need_isa_buffer ||
 694          dma_free_sectors >= 10)) {
 695         struct buffer_head * bh;
 696         struct scatterlist * sgpnt;
 697         int count, this_count_max;
 698         bh = SCpnt->request.bh;
 699         this_count = 0;
 700         count = 0;
 701         this_count_max = (scsi_CDs[dev].ten ? 0xffff : 0xff) << 4;
 702         /* Calculate how many links we can use.  First see if we need
 703          * a padding record at the start */
 704         this_count = SCpnt->request.sector % 4;
 705         if(this_count) count++;
 706         while(bh && count < SCpnt->host->sg_tablesize) {
 707             if ((this_count + (bh->b_size >> 9)) > this_count_max) break;
 708             this_count += (bh->b_size >> 9);
 709             count++;
 710             bh = bh->b_reqnext;
 711         };
 712         /* Fix up in case of an odd record at the end */
 713         end_rec = 0;
 714         if(this_count % 4) {
 715             if (count < SCpnt->host->sg_tablesize) {
 716                 count++;
 717                 end_rec = (4 - (this_count % 4)) << 9;
 718                 this_count += 4 - (this_count % 4);
 719             } else {
 720                 count--;
 721                 this_count -= (this_count % 4);
 722             };
 723         };
 724         SCpnt->use_sg = count;  /* Number of chains */
 725         count = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
 726         while( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
 727             count = count << 1;
 728         SCpnt->sglist_len = count;
 729         sgpnt = (struct scatterlist * ) scsi_malloc(count);
 730         if (!sgpnt) {
 731             printk("Warning - running *really* short on DMA buffers\n");
 732             SCpnt->use_sg = 0;  /* No memory left - bail out */
 733         } else {
 734             buffer = (unsigned char *) sgpnt;
 735             count = 0;
 736             bh = SCpnt->request.bh;
 737             if(SCpnt->request.sector % 4) {
 738                 sgpnt[count].length = (SCpnt->request.sector % 4) << 9;
 739                 sgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
 740                 if(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
 741                 sgpnt[count].alt_address = sgpnt[count].address; /* Flag to delete
 742                                                                     if needed */
 743                 count++;
 744             };
 745             for(bh = SCpnt->request.bh; count < SCpnt->use_sg; 
 746                 count++, bh = bh->b_reqnext) {
 747                 if (bh) { /* Need a placeholder at the end of the record? */
 748                     sgpnt[count].address = bh->b_data;
 749                     sgpnt[count].length = bh->b_size;
 750                     sgpnt[count].alt_address = NULL;
 751                 } else {
 752                     sgpnt[count].address = (char *) scsi_malloc(end_rec);
 753                     if(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
 754                     sgpnt[count].length = end_rec;
 755                     sgpnt[count].alt_address = sgpnt[count].address;
 756                     if (count+1 != SCpnt->use_sg) panic("Bad sr request list");
 757                     break;
 758                 };
 759                 if (((long) sgpnt[count].address) + sgpnt[count].length > ISA_DMA_THRESHOLD &&
 760                   SCpnt->host->unchecked_isa_dma) {
 761                     sgpnt[count].alt_address = sgpnt[count].address;
 762                     /* We try and avoid exhausting the DMA pool, since it is easier
 763                      * to control usage here.  In other places we might have a more
 764                      * pressing need, and we would be screwed if we ran out */
 765                     if(dma_free_sectors < (sgpnt[count].length >> 9) + 5) {
 766                         sgpnt[count].address = NULL;
 767                     } else {
 768                         sgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
 769                     };
 770                     /* If we start running low on DMA buffers, we abort the scatter-gather
 771                      * operation, and free all of the memory we have allocated.  We want to
 772                      * ensure that all scsi operations are able to do at least a non-scatter/gather
 773                      * operation */
 774                     if(sgpnt[count].address == NULL){ /* Out of dma memory */
 775                         printk("Warning: Running low on SCSI DMA buffers");
 776                         /* Try switching back to a non scatter-gather operation. */
 777                         while(--count >= 0){
 778                             if(sgpnt[count].alt_address) 
 779                                 scsi_free(sgpnt[count].address, sgpnt[count].length);
 780                         };
 781                         SCpnt->use_sg = 0;
 782                         scsi_free(buffer, SCpnt->sglist_len);
 783                         break;
 784                     }; /* if address == NULL */
 785                 };  /* if need DMA fixup */
 786             };  /* for loop to fill list */
 787 #ifdef DEBUG
 788             printk("SR: %d %d %d %d %d *** ",SCpnt->use_sg, SCpnt->request.sector,
 789                    this_count, 
 790                    SCpnt->request.current_nr_sectors,
 791                    SCpnt->request.nr_sectors);
 792             for(count=0; count<SCpnt->use_sg; count++)
 793                 printk("SGlist: %d %x %x %x\n", count,
 794                        sgpnt[count].address, 
 795                        sgpnt[count].alt_address, 
 796                        sgpnt[count].length);
 797 #endif
 798         };  /* Able to allocate scatter-gather list */
 799         };
 800         
 801         if (SCpnt->use_sg == 0){
 802         /* We cannot use scatter-gather.  Do this the old fashion way */
 803         if (!SCpnt->request.bh)         
 804             this_count = SCpnt->request.nr_sectors;
 805         else
 806             this_count = (SCpnt->request.bh->b_size >> 9);
 807         
 808         start = block % 4;
 809         if (start)
 810             {                             
 811             this_count = ((this_count > 4 - start) ? 
 812                           (4 - start) : (this_count));
 813             buffer = (unsigned char *) scsi_malloc(2048);
 814             } 
 815         else if (this_count < 4)
 816             {
 817             buffer = (unsigned char *) scsi_malloc(2048);
 818             }
 819         else
 820             {
 821             this_count -= this_count % 4;
 822             buffer = (unsigned char *) SCpnt->request.buffer;
 823             if (((long) buffer) + (this_count << 9) > ISA_DMA_THRESHOLD &&
 824                 SCpnt->host->unchecked_isa_dma)
 825                 buffer = (unsigned char *) scsi_malloc(this_count << 9);
 826             }
 827         };
 828     
 829         if (scsi_CDs[dev].sector_size == 2048)
 830         block = block >> 2; /* These are the sectors that the cdrom uses */
 831         else
 832         block = block & 0xfffffffc;
 833     
 834         realcount = (this_count + 3) / 4;
 835     
 836         if (scsi_CDs[dev].sector_size == 512) realcount = realcount << 2;
 837     
 838         if (((realcount > 0xff) || (block > 0x1fffff)) && scsi_CDs[dev].ten) 
 839     {
 840                 if (realcount > 0xffff)
 841         {
 842                         realcount = 0xffff;
 843                         this_count = realcount * (scsi_CDs[dev].sector_size >> 9);
 844         }
 845         
 846                 cmd[0] += READ_10 - READ_6 ;
 847                 cmd[2] = (unsigned char) (block >> 24) & 0xff;
 848                 cmd[3] = (unsigned char) (block >> 16) & 0xff;
 849                 cmd[4] = (unsigned char) (block >> 8) & 0xff;
 850                 cmd[5] = (unsigned char) block & 0xff;
 851                 cmd[6] = cmd[9] = 0;
 852                 cmd[7] = (unsigned char) (realcount >> 8) & 0xff;
 853                 cmd[8] = (unsigned char) realcount & 0xff;
 854     }
 855         else
 856     {
 857         if (realcount > 0xff)
 858         {
 859             realcount = 0xff;
 860             this_count = realcount * (scsi_CDs[dev].sector_size >> 9);
 861         }
 862         
 863         cmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
 864         cmd[2] = (unsigned char) ((block >> 8) & 0xff);
 865         cmd[3] = (unsigned char) block & 0xff;
 866         cmd[4] = (unsigned char) realcount;
 867         cmd[5] = 0;
 868     }   
 869     
 870 #ifdef DEBUG
 871     { 
 872         int i;
 873         printk("ReadCD: %d %d %d %d\n",block, realcount, buffer, this_count);
 874         printk("Use sg: %d\n", SCpnt->use_sg);
 875         printk("Dumping command: ");
 876         for(i=0; i<12; i++) printk("%2.2x ", cmd[i]);
 877         printk("\n");
 878     };
 879 #endif
 880     
 881     /* Some dumb host adapters can speed transfers by knowing the
 882      * minimum transfersize in advance.
 883      *
 884      * We shouldn't disconnect in the middle of a sector, but the cdrom
 885      * sector size can be larger than the size of a buffer and the
 886      * transfer may be split to the size of a buffer.  So it's safe to
 887      * assume that we can at least transfer the minimum of the buffer
 888      * size (1024) and the sector size between each connect / disconnect.
 889      */
 890     
 891     SCpnt->transfersize = (scsi_CDs[dev].sector_size > 1024) ?
 892         1024 : scsi_CDs[dev].sector_size;
 893     
 894         SCpnt->this_count = this_count;
 895         scsi_do_cmd (SCpnt, (void *) cmd, buffer, 
 896                  realcount * scsi_CDs[dev].sector_size, 
 897                  rw_intr, SR_TIMEOUT, MAX_RETRIES);
 898 }
 899 
 900 static int sr_detect(Scsi_Device * SDp){
     /*  */
 901     
 902     if(SDp->type != TYPE_ROM && SDp->type != TYPE_WORM) return 0;
 903     
 904     printk("Detected scsi CD-ROM sr%d at scsi%d, channel %d, id %d, lun %d\n", 
 905            sr_template.dev_noticed++,
 906            SDp->host->host_no, SDp->channel, SDp->id, SDp->lun); 
 907     
 908     return 1;
 909 }
 910 
 911 static int sr_attach(Scsi_Device * SDp){
     /*  */
 912     Scsi_CD * cpnt;
 913     int i;
 914     
 915     if(SDp->type != TYPE_ROM && SDp->type != TYPE_WORM) return 1;
 916     
 917     if (sr_template.nr_dev >= sr_template.dev_max)
 918     {
 919         SDp->attached--;
 920         return 1;
 921     }
 922     
 923     for(cpnt = scsi_CDs, i=0; i<sr_template.dev_max; i++, cpnt++) 
 924         if(!cpnt->device) break;
 925     
 926     if(i >= sr_template.dev_max) panic ("scsi_devices corrupt (sr)");
 927     
 928     SDp->scsi_request_fn = do_sr_request;
 929     scsi_CDs[i].device = SDp;
 930     sr_template.nr_dev++;
 931     if(sr_template.nr_dev > sr_template.dev_max)
 932         panic ("scsi_devices corrupt (sr)");
 933     return 0;
 934 }
 935 
 936 
 937 static void sr_init_done (Scsi_Cmnd * SCpnt)
     /*  */
 938 {
 939     struct request * req;
 940     
 941     req = &SCpnt->request;
 942     req->dev = 0xfffe; /* Busy, but indicate request done */
 943     
 944     if (req->sem != NULL) {
 945         up(req->sem);
 946     }
 947 }
 948 
 949 static void get_sectorsize(int i){
     /*  */
 950     unsigned char cmd[10];
 951     unsigned char *buffer;
 952     int the_result, retries;
 953     Scsi_Cmnd * SCpnt;
 954     
 955     buffer = (unsigned char *) scsi_malloc(512);
 956     SCpnt = allocate_device(NULL, scsi_CDs[i].device, 1);
 957     
 958     retries = 3;
 959     do {
 960         cmd[0] = READ_CAPACITY;
 961         cmd[1] = (scsi_CDs[i].device->lun << 5) & 0xe0;
 962         memset ((void *) &cmd[2], 0, 8);
 963         SCpnt->request.dev = 0xffff;  /* Mark as really busy */
 964         SCpnt->cmd_len = 0;
 965         
 966         memset(buffer, 0, 8);
 967         
 968         scsi_do_cmd (SCpnt,
 969                      (void *) cmd, (void *) buffer,
 970                      512, sr_init_done,  SR_TIMEOUT,
 971                      MAX_RETRIES);
 972         
 973         if (current->pid == 0)
 974             while(SCpnt->request.dev != 0xfffe)
 975                 barrier();
 976         else
 977             if (SCpnt->request.dev != 0xfffe){
 978                 struct semaphore sem = MUTEX_LOCKED;
 979                 SCpnt->request.sem = &sem;
 980                 down(&sem);
 981                 /* Hmm.. Have to ask about this */
 982                 while (SCpnt->request.dev != 0xfffe) schedule();
 983             };
 984         
 985         the_result = SCpnt->result;
 986         retries--;
 987         
 988     } while(the_result && retries);
 989     
 990     SCpnt->request.dev = -1;  /* Mark as not busy */
 991     
 992     wake_up(&SCpnt->device->device_wait); 
 993     
 994     if (the_result) {
 995         scsi_CDs[i].capacity = 0x1fffff;
 996         scsi_CDs[i].sector_size = 2048;  /* A guess, just in case */
 997         scsi_CDs[i].needs_sector_size = 1;
 998     } else {
 999         scsi_CDs[i].capacity = (buffer[0] << 24) |
1000             (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
1001         scsi_CDs[i].sector_size = (buffer[4] << 24) |
1002             (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
1003         if(scsi_CDs[i].sector_size == 0) scsi_CDs[i].sector_size = 2048;
1004         if(scsi_CDs[i].sector_size != 2048 && 
1005            scsi_CDs[i].sector_size != 512) {
1006             printk ("scd%d : unsupported sector size %d.\n",
1007                     i, scsi_CDs[i].sector_size);
1008             scsi_CDs[i].capacity = 0;
1009             scsi_CDs[i].needs_sector_size = 1;
1010         };
1011         if(scsi_CDs[i].sector_size == 2048)
1012             scsi_CDs[i].capacity *= 4;
1013         scsi_CDs[i].needs_sector_size = 0;
1014         sr_sizes[i] = scsi_CDs[i].capacity;
1015     };
1016     scsi_free(buffer, 512);
1017 }
1018 
1019 static void sr_init()
     /*  */
1020 {
1021         int i;
1022         static int sr_registered = 0;
1023     
1024         if(sr_template.dev_noticed == 0) return;
1025     
1026         if(!sr_registered) {
1027         if (register_blkdev(MAJOR_NR,"sr",&sr_fops)) {
1028             printk("Unable to get major %d for SCSI-CD\n",MAJOR_NR);
1029             return;
1030         }
1031         sr_registered++;
1032         }
1033     
1034         
1035         if (scsi_CDs) return;
1036         sr_template.dev_max = sr_template.dev_noticed + SR_EXTRA_DEVS;
1037         scsi_CDs = (Scsi_CD *) scsi_init_malloc(sr_template.dev_max * sizeof(Scsi_CD), GFP_ATOMIC);
1038         memset(scsi_CDs, 0, sr_template.dev_max * sizeof(Scsi_CD));
1039     
1040         sr_sizes = (int *) scsi_init_malloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC);
1041         memset(sr_sizes, 0, sr_template.dev_max * sizeof(int));
1042     
1043         sr_blocksizes = (int *) scsi_init_malloc(sr_template.dev_max * 
1044                                              sizeof(int), GFP_ATOMIC);
1045         for(i=0;i<sr_template.dev_max;i++) sr_blocksizes[i] = 2048;
1046         blksize_size[MAJOR_NR] = sr_blocksizes;
1047     
1048 }
1049 
1050 void sr_finish()
     /*  */
1051 {
1052     int i;
1053     
1054         blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
1055         blk_size[MAJOR_NR] = sr_sizes;  
1056     
1057         for (i = 0; i < sr_template.nr_dev; ++i)
1058     {
1059         /* If we have already seen this, then skip it.  Comes up
1060          * with loadable modules. */
1061         if (scsi_CDs[i].capacity) continue;
1062         scsi_CDs[i].capacity = 0x1fffff;
1063         scsi_CDs[i].sector_size = 2048;  /* A guess, just in case */
1064         scsi_CDs[i].needs_sector_size = 1;
1065 #if 0
1066         /* seems better to leave this for later */
1067         get_sectorsize(i);
1068         printk("Scd sectorsize = %d bytes.\n", scsi_CDs[i].sector_size);
1069 #endif
1070         scsi_CDs[i].use = 1;
1071         scsi_CDs[i].ten = 1;
1072         scsi_CDs[i].remap = 1;
1073         scsi_CDs[i].auto_eject = 0; /* Default is not to eject upon unmount. */
1074         sr_sizes[i] = scsi_CDs[i].capacity;
1075     }
1076     
1077     
1078         /* If our host adapter is capable of scatter-gather, then we increase
1079          * the read-ahead to 16 blocks (32 sectors).  If not, we use
1080          * a two block (4 sector) read ahead. */
1081         if(scsi_CDs[0].device && scsi_CDs[0].device->host->sg_tablesize)
1082         read_ahead[MAJOR_NR] = 32;  /* 32 sector read-ahead.  Always removable. */
1083         else
1084         read_ahead[MAJOR_NR] = 4;  /* 4 sector read-ahead */
1085     
1086         return;
1087 }       
1088 
1089 static void sr_detach(Scsi_Device * SDp)
     /*  */
1090 {
1091     Scsi_CD * cpnt;
1092     int i, major;
1093     
1094     major = MAJOR_NR << 8;
1095     
1096     for(cpnt = scsi_CDs, i=0; i<sr_template.dev_max; i++, cpnt++) 
1097         if(cpnt->device == SDp) {
1098             /*
1099              * Since the cdrom is read-only, no need to sync the device.
1100              * We should be kind to our buffer cache, however.
1101              */
1102             invalidate_inodes(major | i);
1103             invalidate_buffers(major | i);
1104             
1105             /*
1106              * Reset things back to a sane state so that one can re-load a new
1107              * driver (perhaps the same one).
1108              */
1109             cpnt->device = NULL;
1110             cpnt->capacity = 0;
1111             SDp->attached--;
1112             sr_template.nr_dev--;
1113             sr_template.dev_noticed--;
1114             sr_sizes[i] = 0;
1115             return;
1116         }
1117     return;
1118 }
1119 
1120 
1121 #ifdef MODULE
1122 #include <linux/module.h>
1123 #include <linux/version.h>
1124 
1125 char kernel_version[] = UTS_RELEASE;
1126 
1127 int init_module(void) {
     /*  */
1128     sr_template.usage_count = &mod_use_count_;
1129     return scsi_register_module(MODULE_SCSI_DEV, &sr_template);
1130 }
1131 
1132 void cleanup_module( void) 
     /*  */
1133 {
1134     int i;
1135     
1136     if (MOD_IN_USE) {
1137         printk(KERN_INFO __FILE__ ": module is in use, remove rejected\n");
1138         return;
1139     }
1140     scsi_unregister_module(MODULE_SCSI_DEV, &sr_template);
1141     unregister_blkdev(SCSI_GENERIC_MAJOR, "sr");
1142     if(scsi_CDs != NULL) {
1143         scsi_init_free((char *) scsi_CDs,
1144                        (sr_template.dev_noticed + SR_EXTRA_DEVS) 
1145                        * sizeof(Scsi_CD));
1146         
1147         scsi_init_free((char *) sr_sizes, sr_template.dev_max * sizeof(int));
1148         scsi_init_free((char *) sr_blocksizes, sr_template.dev_max * sizeof(int));
1149     }
1150     
1151     blksize_size[MAJOR_NR] = NULL;
1152     blk_dev[MAJOR_NR].request_fn = NULL;
1153     blk_size[MAJOR_NR] = NULL;  
1154     read_ahead[MAJOR_NR] = 0;
1155     
1156     sr_template.dev_max = 0;
1157 }
1158 #endif /* MODULE */
1159 
1160 /*
1161  * Overrides for Emacs so that we follow Linus's tabbing style.
1162  * Emacs will notice this stuff at the end of the file and automatically
1163  * adjust the settings for this buffer only.  This must remain at the end
1164  * of the file.
1165  * ---------------------------------------------------------------------------
1166  * Local variables:
1167  * c-indent-level: 4
1168  * c-brace-imaginary-offset: 0
1169  * c-brace-offset: -4
1170  * c-argdecl-indent: 4
1171  * c-label-offset: -4
1172  * c-continued-statement-offset: 4
1173  * c-continued-brace-offset: 0
1174  * indent-tabs-mode: nil
1175  * tab-width: 8
1176  * End:
1177  */
/* */
root/drivers/scsi/sr.c

DEFINITIONS
