patch-1.3.5 linux/drivers/scsi/sr.c

Next file: linux/drivers/scsi/sr_ioctl.c
Previous file: linux/drivers/scsi/sg.h
Back to the patch index
Back to the overall index

diff -u --recursive --new-file v1.3.4/linux/drivers/scsi/sr.c linux/drivers/scsi/sr.c
@@ -1,20 +1,18 @@
 /*
- *      sr.c Copyright (C) 1992 David Giller
+ *  sr.c Copyright (C) 1992 David Giller
  *	     Copyright (C) 1993, 1994, 1995 Eric Youngdale
  *
- *      adapted from:
+ *  adapted from:
  *	sd.c Copyright (C) 1992 Drew Eckhardt 
  *	Linux scsi disk driver by
- *		Drew Eckhardt 
+ *		Drew Eckhardt <drew@colorado.edu>
  *
- *	<drew@colorado.edu>
+ *      Modified by Eric Youngdale ericy@cais.com to
+ *      add scatter-gather, multiple outstanding request, and other
+ *      enhancements.
  *
- *       Modified by Eric Youngdale ericy@cais.com to
- *       add scatter-gather, multiple outstanding request, and other
- *       enhancements.
- *
- *	 Modified by Eric Youngdale eric@aib.com to support loadable
- *	 low-level scsi drivers.
+ *	    Modified by Eric Youngdale eric@aib.com to support loadable
+ *	    low-level scsi drivers.
  */
 
 #include <linux/fs.h>
@@ -43,12 +41,12 @@
 static int sr_detect(Scsi_Device *);
 static void sr_detach(Scsi_Device *);
 
-struct Scsi_Device_Template sr_template = {NULL, "cdrom", "sr", TYPE_ROM, 
-					     SCSI_CDROM_MAJOR, 0, 0, 0, 1,
-					     sr_detect, sr_init,
-					     sr_finish, sr_attach, sr_detach};
+struct Scsi_Device_Template sr_template = {NULL, "cdrom", "sr", NULL, TYPE_ROM, 
+					       SCSI_CDROM_MAJOR, 0, 0, 0, 1,
+					       sr_detect, sr_init,
+					       sr_finish, sr_attach, sr_detach};
 
-Scsi_CD * scsi_CDs;
+Scsi_CD * scsi_CDs = NULL;
 static int * sr_sizes;
 
 static int * sr_blocksizes;
@@ -65,21 +63,22 @@
 {
 	sync_dev(inode->i_rdev);
 	if(! --scsi_CDs[MINOR(inode->i_rdev)].device->access_count)
-	  sr_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
+	sr_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
 	if (scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)
-	  (*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)--;
+	(*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)--;
+	if(sr_template.usage_count) (*sr_template.usage_count)--;
 }
 
 static struct file_operations sr_fops = 
 {
 	NULL,			/* lseek - default */
 	block_read,		/* read - general block-dev read */
-	block_write,		/* write - general block-dev write */
+	block_write,	/* write - general block-dev write */
 	NULL,			/* readdir - bad */
 	NULL,			/* select */
 	sr_ioctl,		/* ioctl */
 	NULL,			/* mmap */
-	sr_open,       		/* special open code */
+	sr_open,       	/* special open code */
 	sr_release,		/* release */
 	NULL,			/* fsync */
 	NULL,			/* fasync */
@@ -101,33 +100,33 @@
 	int retval, target;
 	struct inode inode;
 	int flag = 0;
-
+    
 	target =  MINOR(full_dev);
-
+    
 	if (target >= sr_template.nr_dev) {
 		printk("CD-ROM request error: invalid device.\n");
 		return 0;
 	};
-
+    
 	inode.i_rdev = full_dev;  /* This is all we really need here */
 	retval = sr_ioctl(&inode, NULL, SCSI_IOCTL_TEST_UNIT_READY, 0);
-
+    
 	if(retval){ /* Unable to test, unit probably not ready.  This usually
-		     means there is no disc in the drive.  Mark as changed,
-		     and we will figure it out later once the drive is
-		     available again.  */
-
-	  scsi_CDs[target].device->changed = 1;
-	  return 1; /* This will force a flush, if called from
-		       check_disk_change */
+		 * means there is no disc in the drive.  Mark as changed,
+		 * and we will figure it out later once the drive is
+		 * available again.  */
+	
+	scsi_CDs[target].device->changed = 1;
+	return 1; /* This will force a flush, if called from
+		   * check_disk_change */
 	};
-
+    
 	retval = scsi_CDs[target].device->changed;
 	if(!flag) {
-	  scsi_CDs[target].device->changed = 0;
-	  /* If the disk changed, the capacity will now be different,
-	     so we force a re-read of this information */
-	  if (retval) scsi_CDs[target].needs_sector_size = 1;
+	scsi_CDs[target].device->changed = 0;
+	/* If the disk changed, the capacity will now be different,
+	 * so we force a re-read of this information */
+	if (retval) scsi_CDs[target].needs_sector_size = 1;
 	};
 	return retval;
 }
@@ -141,100 +140,100 @@
 {
 	int result = SCpnt->result;
 	int this_count = SCpnt->this_count;
-
+    
 #ifdef DEBUG
 	printk("sr.c done: %x %x\n",result, SCpnt->request.bh->b_data);
 #endif
 	if (!result)
-		{ /* No error */
-		  if (SCpnt->use_sg == 0) {
+    { /* No error */
+	if (SCpnt->use_sg == 0) {
 		    if (SCpnt->buffer != SCpnt->request.buffer)
-		      {
-			int offset;
-			offset = (SCpnt->request.sector % 4) << 9;
-			memcpy((char *)SCpnt->request.buffer, 
-			       (char *)SCpnt->buffer + offset, 
-			       this_count << 9);
-			/* Even though we are not using scatter-gather, we look
-			   ahead and see if there is a linked request for the
-			   other half of this buffer.  If there is, then satisfy
-			   it. */
-			if((offset == 0) && this_count == 2 &&
-			   SCpnt->request.nr_sectors > this_count && 
-			   SCpnt->request.bh &&
-			   SCpnt->request.bh->b_reqnext &&
-			   SCpnt->request.bh->b_reqnext->b_size == 1024) {
-			  memcpy((char *)SCpnt->request.bh->b_reqnext->b_data, 
-				 (char *)SCpnt->buffer + 1024, 
-				 1024);
-			  this_count += 2;
-			};
-			
-			scsi_free(SCpnt->buffer, 2048);
-		      }
-		  } else {
+	    {
+		int offset;
+		offset = (SCpnt->request.sector % 4) << 9;
+		memcpy((char *)SCpnt->request.buffer, 
+		       (char *)SCpnt->buffer + offset, 
+		       this_count << 9);
+		/* Even though we are not using scatter-gather, we look
+		 * ahead and see if there is a linked request for the
+		 * other half of this buffer.  If there is, then satisfy
+		 * it. */
+		if((offset == 0) && this_count == 2 &&
+		   SCpnt->request.nr_sectors > this_count && 
+		   SCpnt->request.bh &&
+		   SCpnt->request.bh->b_reqnext &&
+		   SCpnt->request.bh->b_reqnext->b_size == 1024) {
+		    memcpy((char *)SCpnt->request.bh->b_reqnext->b_data, 
+			   (char *)SCpnt->buffer + 1024, 
+			   1024);
+		    this_count += 2;
+		};
+		
+		scsi_free(SCpnt->buffer, 2048);
+	    }
+	} else {
 		    struct scatterlist * sgpnt;
 		    int i;
 		    sgpnt = (struct scatterlist *) SCpnt->buffer;
 		    for(i=0; i<SCpnt->use_sg; i++) {
-		      if (sgpnt[i].alt_address) {
-			if (sgpnt[i].alt_address != sgpnt[i].address) {
-			  memcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
-			};
-			scsi_free(sgpnt[i].address, sgpnt[i].length);
-		      };
+		if (sgpnt[i].alt_address) {
+		    if (sgpnt[i].alt_address != sgpnt[i].address) {
+			memcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
+		    };
+		    scsi_free(sgpnt[i].address, sgpnt[i].length);
+		};
 		    };
 		    scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
 		    if(SCpnt->request.sector % 4) this_count -= 2;
-/* See   if there is a padding record at the end that needs to be removed */
+	    /* See   if there is a padding record at the end that needs to be removed */
 		    if(this_count > SCpnt->request.nr_sectors)
-		      this_count -= 2;
-		  };
-
+		this_count -= 2;
+	};
+	
 #ifdef DEBUG
 		printk("(%x %x %x) ",SCpnt->request.bh, SCpnt->request.nr_sectors, 
 		       this_count);
 #endif
 		if (SCpnt->request.nr_sectors > this_count)
-			{	 
+	{	 
 			SCpnt->request.errors = 0;
 			if (!SCpnt->request.bh)
 			    panic("sr.c: linked page request (%lx %x)",
-				  SCpnt->request.sector, this_count);
-			}
-
-		  SCpnt = end_scsi_request(SCpnt, 1, this_count);  /* All done */
-		  requeue_sr_request(SCpnt);
-		  return;
-		} /* Normal completion */
-
+		      SCpnt->request.sector, this_count);
+	}
+	
+	SCpnt = end_scsi_request(SCpnt, 1, this_count);  /* All done */
+	requeue_sr_request(SCpnt);
+	return;
+    } /* Normal completion */
+    
 	/* We only come through here if we have an error of some kind */
-
-/* Free up any indirection buffers we allocated for DMA purposes. */
+    
+    /* Free up any indirection buffers we allocated for DMA purposes. */
 	if (SCpnt->use_sg) {
-	  struct scatterlist * sgpnt;
-	  int i;
-	  sgpnt = (struct scatterlist *) SCpnt->buffer;
-	  for(i=0; i<SCpnt->use_sg; i++) {
+	struct scatterlist * sgpnt;
+	int i;
+	sgpnt = (struct scatterlist *) SCpnt->buffer;
+	for(i=0; i<SCpnt->use_sg; i++) {
 	    if (sgpnt[i].alt_address) {
-	      scsi_free(sgpnt[i].address, sgpnt[i].length);
+		scsi_free(sgpnt[i].address, sgpnt[i].length);
 	    };
-	  };
-	  scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
+	};
+	scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
 	} else {
-	  if (SCpnt->buffer != SCpnt->request.buffer)
+	if (SCpnt->buffer != SCpnt->request.buffer)
 	    scsi_free(SCpnt->buffer, SCpnt->bufflen);
 	};
-
+    
 	if (driver_byte(result) != 0) {
 		if ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
 			if ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
-				/* detected disc change.  set a bit and quietly refuse	*/
-				/* further access.					*/
-		    
+				/* detected disc change.  set a bit and quietly refuse 
+				 * further access.	*/
+		
 				scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
 				SCpnt = end_scsi_request(SCpnt, 0, this_count);
-			        requeue_sr_request(SCpnt);
+		requeue_sr_request(SCpnt);
 				return;
 			}
 		}
@@ -250,35 +249,35 @@
 				result = 0;
 				return;
 			} else {
-			  SCpnt = end_scsi_request(SCpnt, 0, this_count);
-			  requeue_sr_request(SCpnt); /* Do next request */
-			  return;
+		SCpnt = end_scsi_request(SCpnt, 0, this_count);
+		requeue_sr_request(SCpnt); /* Do next request */
+		return;
 			}
-
+	    
 		}
-
+	
 		if (SCpnt->sense_buffer[2] == NOT_READY) {
 			printk("CDROM not ready.  Make sure you have a disc in the drive.\n");
 			SCpnt = end_scsi_request(SCpnt, 0, this_count);
 			requeue_sr_request(SCpnt); /* Do next request */
 			return;
 		};
-	      }
+    }
 	
 	/* We only get this far if we have an error we have not recognized */
 	if(result) {
-	  printk("SCSI CD error : host %d id %d lun %d return code = %03x\n", 
-		 scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->host->host_no, 
-		 scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->id,
-		 scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->lun,
-		 result);
+	printk("SCSI CD error : host %d id %d lun %d return code = %03x\n", 
+	       scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->host->host_no, 
+	       scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->id,
+	       scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->lun,
+	       result);
 	    
-	  if (status_byte(result) == CHECK_CONDITION)
-		  print_sense("sr", SCpnt);
-	  
-	  SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
-	  requeue_sr_request(SCpnt);
-  }
+	if (status_byte(result) == CHECK_CONDITION)
+	    print_sense("sr", SCpnt);
+	
+	SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
+	requeue_sr_request(SCpnt);
+    }
 }
 
 /*
@@ -300,200 +299,201 @@
 
 static void sr_photocd(struct inode *inode)
 {
-  unsigned long   sector,min,sec,frame;
-  unsigned char   buf[40];    /* the buffer for the ioctl */
-  unsigned char   *cmd;       /* the scsi-command */
-  unsigned char   *send;      /* the data we send to the drive ... */
-  unsigned char   *rec;       /* ... and get back */
-  int             rc,is_xa,no_multi;
-
-  if (scsi_CDs[MINOR(inode->i_rdev)].xa_flags & 0x02) {
+    unsigned long   sector,min,sec,frame;
+    unsigned char   buf[40];    /* the buffer for the ioctl */
+    unsigned char   *cmd;       /* the scsi-command */
+    unsigned char   *send;      /* the data we send to the drive ... */
+    unsigned char   *rec;       /* ... and get back */
+    int             rc,is_xa,no_multi;
+    
+    if (scsi_CDs[MINOR(inode->i_rdev)].xa_flags & 0x02) {
 #ifdef DEBUG
-    printk("sr_photocd: CDROM and/or the driver does not support multisession CD's");
+	printk("sr_photocd: CDROM and/or the driver does not support multisession CD's");
 #endif
-    return;
-  }
-  
-  if (!suser()) {
-    /* I'm not the superuser, so SCSI_IOCTL_SEND_COMMAND isn't allowed for me.
-     * That's why mpcd_sector will be initialized with zero, because I'm not
-     * able to get the right value. Necessary only if access_count is 1, else
-     * no disk change happened since the last call of this function and we can
-     * keep the old value.
-     */
-    if (1 == scsi_CDs[MINOR(inode->i_rdev)].device->access_count) {
-      scsi_CDs[MINOR(inode->i_rdev)].mpcd_sector = 0;
-      scsi_CDs[MINOR(inode->i_rdev)].xa_flags &= ~0x01;
+	return;
     }
-    return;
-  }
-
-  sector   = 0;
-  is_xa    = 0;
-  no_multi = 0;
-  cmd = rec = &buf[8];
-
-  switch(scsi_CDs[MINOR(inode->i_rdev)].device->manufacturer) {
-
-  case SCSI_MAN_NEC:
+    
+    if (!suser()) {
+	/* I'm not the superuser, so SCSI_IOCTL_SEND_COMMAND isn't allowed for me.
+	 * That's why mpcd_sector will be initialized with zero, because I'm not
+	 * able to get the right value. Necessary only if access_count is 1, else
+	 * no disk change happened since the last call of this function and we can
+	 * keep the old value.
+	 */
+	if (1 == scsi_CDs[MINOR(inode->i_rdev)].device->access_count) {
+	    scsi_CDs[MINOR(inode->i_rdev)].mpcd_sector = 0;
+	    scsi_CDs[MINOR(inode->i_rdev)].xa_flags &= ~0x01;
+	}
+	return;
+    }
+    
+    sector   = 0;
+    is_xa    = 0;
+    no_multi = 0;
+    cmd = rec = &buf[8];
+    
+    switch(scsi_CDs[MINOR(inode->i_rdev)].device->manufacturer) {
+	
+    case SCSI_MAN_NEC:
 #ifdef DEBUG
-    printk("sr_photocd: use NEC code\n");
+	printk("sr_photocd: use NEC code\n");
 #endif
-    memset(buf,0,40);
-    *((unsigned long*)buf)   = 0x0;   /* we send nothing...     */
-    *((unsigned long*)buf+1) = 0x16;  /* and receive 0x16 bytes */
-    cmd[0] = 0xde;
-    cmd[1] = 0x03;
-    cmd[2] = 0xb0;
-    rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
+	memset(buf,0,40);
+	*((unsigned long*)buf)   = 0x0;   /* we send nothing...     */
+	*((unsigned long*)buf+1) = 0x16;  /* and receive 0x16 bytes */
+	cmd[0] = 0xde;
+	cmd[1] = 0x03;
+	cmd[2] = 0xb0;
+	rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
 			   SCSI_IOCTL_SEND_COMMAND, buf);
-    if (rc != 0) {
-      printk("sr_photocd: ioctl error (NEC): 0x%x\n",rc);
-      break;
-    }
-    if (rec[14] != 0 && rec[14] != 0xb0) {
-      printk("sr_photocd: Hmm, seems the CDROM doesn't support multisession CD's\n");
-      no_multi = 1;
-      break;
-    }
-    min   = (unsigned long) rec[15]/16*10 + (unsigned long) rec[15]%16;
-    sec   = (unsigned long) rec[16]/16*10 + (unsigned long) rec[16]%16;
-    frame = (unsigned long) rec[17]/16*10 + (unsigned long) rec[17]%16;
-    sector = min*CD_SECS*CD_FRAMES + sec*CD_FRAMES + frame;
-    is_xa  = (rec[14] == 0xb0);
+	if (rc != 0) {
+	    printk("sr_photocd: ioctl error (NEC): 0x%x\n",rc);
+	    break;
+	}
+	if (rec[14] != 0 && rec[14] != 0xb0) {
+	    printk("sr_photocd: Hmm, seems the CDROM doesn't support multisession CD's\n");
+	    no_multi = 1;
+	    break;
+	}
+	min   = (unsigned long) rec[15]/16*10 + (unsigned long) rec[15]%16;
+	sec   = (unsigned long) rec[16]/16*10 + (unsigned long) rec[16]%16;
+	frame = (unsigned long) rec[17]/16*10 + (unsigned long) rec[17]%16;
+	sector = min*CD_SECS*CD_FRAMES + sec*CD_FRAMES + frame;
+	is_xa  = (rec[14] == 0xb0);
 #ifdef DEBUG
-    if (sector) {
-      printk("sr_photocd: multisession CD detected. start: %lu\n",sector);
-    }
+	if (sector) {
+	    printk("sr_photocd: multisession CD detected. start: %lu\n",sector);
+	}
 #endif
-    break;
-
-  case SCSI_MAN_TOSHIBA:
+	break;
+	
+    case SCSI_MAN_TOSHIBA:
 #ifdef DEBUG
-    printk("sr_photocd: use TOSHIBA code\n");
+	printk("sr_photocd: use TOSHIBA code\n");
 #endif
-    
-    /* we request some disc information (is it a XA-CD ?,
-       where starts the last session ?) */
-    memset(buf,0,40);
-    *((unsigned long*)buf)   = 0;
-    *((unsigned long*)buf+1) = 4;  /* we receive 4 bytes from the drive */
-    cmd[0] = 0xc7;
-    cmd[1] = 3;
-    rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
-			   SCSI_IOCTL_SEND_COMMAND, buf);
-    if (rc != 0) {
-      if (rc == 0x28000002) {
-	/* Got a "not ready" - error. No chance to find out if this is
-	   because there is no CD in the drive or because the drive
-	   don't knows multisession CD's. So I need to do an extra check... */
-	if (kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
-			      SCSI_IOCTL_TEST_UNIT_READY, NULL)) {
-	  printk("sr_photocd: drive not ready\n");
-	} else {
-	  printk("sr_photocd: Hmm, seems the CDROM doesn't support multisession CD's\n");
-	  no_multi = 1;
+	
+	/* we request some disc information (is it a XA-CD ?,
+	 * where starts the last session ?) */
+	memset(buf,0,40);
+	*((unsigned long*)buf)   = 0;
+	*((unsigned long*)buf+1) = 4;  /* we receive 4 bytes from the drive */
+	cmd[0] = 0xc7;
+	cmd[1] = 3;
+	rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
+			       SCSI_IOCTL_SEND_COMMAND, buf);
+	if (rc != 0) {
+	    if (rc == 0x28000002) {
+		/* Got a "not ready" - error. No chance to find out if this is
+		 * because there is no CD in the drive or because the drive
+		 * don't knows multisession CD's. So I need to do an extra check... */
+		if (kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
+				      SCSI_IOCTL_TEST_UNIT_READY, NULL)) {
+		    printk("sr_photocd: drive not ready\n");
+		} else {
+		    printk("sr_photocd: Hmm, seems the CDROM doesn't support multisession CD's\n");
+		    no_multi = 1;
+		}
+	    } else
+		printk("sr_photocd: ioctl error (TOSHIBA #1): 0x%x\n",rc);
+	    break; /* if the first ioctl fails, we don't call the second one */
 	}
-      } else
-	printk("sr_photocd: ioctl error (TOSHIBA #1): 0x%x\n",rc);
-      break; /* if the first ioctl fails, we don't call the second one */
-    }
-    is_xa  = (rec[0] == 0x20);
-    min    = (unsigned long) rec[1]/16*10 + (unsigned long) rec[1]%16;
-    sec    = (unsigned long) rec[2]/16*10 + (unsigned long) rec[2]%16;
-    frame  = (unsigned long) rec[3]/16*10 + (unsigned long) rec[3]%16;
-    sector = min*CD_SECS*CD_FRAMES + sec*CD_FRAMES + frame;
-    if (sector) {
-      sector -= CD_BLOCK_OFFSET;
+	is_xa  = (rec[0] == 0x20);
+	min    = (unsigned long) rec[1]/16*10 + (unsigned long) rec[1]%16;
+	sec    = (unsigned long) rec[2]/16*10 + (unsigned long) rec[2]%16;
+	frame  = (unsigned long) rec[3]/16*10 + (unsigned long) rec[3]%16;
+	sector = min*CD_SECS*CD_FRAMES + sec*CD_FRAMES + frame;
+	if (sector) {
+	    sector -= CD_BLOCK_OFFSET;
 #ifdef DEBUG
-      printk("sr_photocd: multisession CD detected: start: %lu\n",sector);
+	    printk("sr_photocd: multisession CD detected: start: %lu\n",sector);
 #endif
-    }
-
-    /* now we do a get_density... */
-    memset(buf,0,40);
-    *((unsigned long*)buf)   = 0;
-    *((unsigned long*)buf+1) = 12;
-    cmd[0] = 0x1a;
-    cmd[2] = 1;
-    cmd[4] = 12;
-    rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
-			   SCSI_IOCTL_SEND_COMMAND, buf);
-    if (rc != 0) {
-      printk("sr_photocd: ioctl error (TOSHIBA #2): 0x%x\n",rc);
-      break;
-    }
+	}
+	
+	/* now we do a get_density... */
+	memset(buf,0,40);
+	*((unsigned long*)buf)   = 0;
+	*((unsigned long*)buf+1) = 12;
+	cmd[0] = 0x1a;
+	cmd[2] = 1;
+	cmd[4] = 12;
+	rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
+			       SCSI_IOCTL_SEND_COMMAND, buf);
+	if (rc != 0) {
+	    printk("sr_photocd: ioctl error (TOSHIBA #2): 0x%x\n",rc);
+	    break;
+	}
 #ifdef DEBUG
-    printk("sr_photocd: get_density: 0x%x\n",rec[4]);
+	printk("sr_photocd: get_density: 0x%x\n",rec[4]);
 #endif
-    
-    /* ...and only if necessary a set_density */
-    if ((rec[4] != 0x81 && is_xa) || (rec[4] != 0 && !is_xa)) {
+	
+	/* ...and only if necessary a set_density */
+	if ((rec[4] != 0x81 && is_xa) || (rec[4] != 0 && !is_xa)) {
 #ifdef DEBUG
-      printk("sr_photocd: doing set_density\n");
+	    printk("sr_photocd: doing set_density\n");
 #endif
-      memset(buf,0,40);
-      *((unsigned long*)buf)   = 12;  /* sending 12 bytes... */
-      *((unsigned long*)buf+1) = 0;
-      cmd[0] = 0x15;
-      cmd[1] = (1 << 4);
-      cmd[4] = 12;
-      send = &cmd[6];                 /* this is a 6-Byte command          */
-      send[ 3] = 0x08;                /* the data for the command          */
-      send[ 4] = (is_xa) ? 0x81 : 0;  /* density 0x81 for XA-CD's, 0 else  */
-      send[10] = 0x08;
-      rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
-			     SCSI_IOCTL_SEND_COMMAND, buf);
-      if (rc != 0) {
-	printk("sr_photocd: ioctl error (TOSHIBA #3): 0x%x\n",rc);
-      }
-      /* The set_density command may have changed the sector size or capacity. */
-      scsi_CDs[MINOR(inode->i_rdev)].needs_sector_size = 1;
-    }
-    break;
-
-  case SCSI_MAN_NEC_OLDCDR:
-  case SCSI_MAN_UNKNOWN:
-  default:
-    sector = 0;
-    no_multi = 1;
-    break; }
-
-  scsi_CDs[MINOR(inode->i_rdev)].mpcd_sector = sector;
-  if (is_xa)
-    scsi_CDs[MINOR(inode->i_rdev)].xa_flags |= 0x01;
-  else
-    scsi_CDs[MINOR(inode->i_rdev)].xa_flags &= ~0x01;
-  if (no_multi)
-    scsi_CDs[MINOR(inode->i_rdev)].xa_flags |= 0x02;
-  return;
+	    memset(buf,0,40);
+	    *((unsigned long*)buf)   = 12;  /* sending 12 bytes... */
+	    *((unsigned long*)buf+1) = 0;
+	    cmd[0] = 0x15;
+	    cmd[1] = (1 << 4);
+	    cmd[4] = 12;
+	    send = &cmd[6];                 /* this is a 6-Byte command          */
+	    send[ 3] = 0x08;                /* the data for the command          */
+	    send[ 4] = (is_xa) ? 0x81 : 0;  /* density 0x81 for XA-CD's, 0 else  */
+	    send[10] = 0x08;
+	    rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
+				   SCSI_IOCTL_SEND_COMMAND, buf);
+	    if (rc != 0) {
+		printk("sr_photocd: ioctl error (TOSHIBA #3): 0x%x\n",rc);
+	    }
+	    /* The set_density command may have changed the sector size or capacity. */
+	    scsi_CDs[MINOR(inode->i_rdev)].needs_sector_size = 1;
+	}
+	break;
+	
+    case SCSI_MAN_NEC_OLDCDR:
+    case SCSI_MAN_UNKNOWN:
+    default:
+	sector = 0;
+	no_multi = 1;
+	break; }
+    
+    scsi_CDs[MINOR(inode->i_rdev)].mpcd_sector = sector;
+    if (is_xa)
+	scsi_CDs[MINOR(inode->i_rdev)].xa_flags |= 0x01;
+    else
+	scsi_CDs[MINOR(inode->i_rdev)].xa_flags &= ~0x01;
+    if (no_multi)
+	scsi_CDs[MINOR(inode->i_rdev)].xa_flags |= 0x02;
+    return;
 }
 
 static int sr_open(struct inode * inode, struct file * filp)
 {
 	if(MINOR(inode->i_rdev) >= sr_template.nr_dev || 
 	   !scsi_CDs[MINOR(inode->i_rdev)].device) return -ENXIO;   /* No such device */
-
+    
 	if (filp->f_mode & 2)  
 	    return -EROFS;
-
-        check_disk_change(inode->i_rdev);
-
+    
+    check_disk_change(inode->i_rdev);
+    
 	if(!scsi_CDs[MINOR(inode->i_rdev)].device->access_count++)
-	  sr_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
+	sr_ioctl(inode, NULL, SCSI_IOCTL_DOORLOCK, 0);
 	if (scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)
-	  (*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)++;
-
+	(*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)++;
+	if(sr_template.usage_count) (*sr_template.usage_count)++;
+    
 	sr_photocd(inode);
-
+    
 	/* If this device did not have media in the drive at boot time, then
-	   we would have been unable to get the sector size.  Check to see if
-	   this is the case, and try again.
-	   */
-
+	 * we would have been unable to get the sector size.  Check to see if
+	 * this is the case, and try again.
+     */
+    
 	if(scsi_CDs[MINOR(inode->i_rdev)].needs_sector_size)
-	  get_sectorsize(MINOR(inode->i_rdev));
-
+	get_sectorsize(MINOR(inode->i_rdev));
+    
 	return 0;
 }
 
@@ -502,67 +502,67 @@
  * do_sr_request() is the request handler function for the sr driver.  Its function in life 
  * is to take block device requests, and translate them to SCSI commands.
  */
-	
+
 static void do_sr_request (void)
 {
-  Scsi_Cmnd * SCpnt = NULL;
-  struct request * req = NULL;
-  unsigned long flags;
-  int flag = 0;
-
-  while (1==1){
-    save_flags(flags);
-    cli();
-    if (CURRENT != NULL && CURRENT->dev == -1) {
-      restore_flags(flags);
-      return;
-    };
-    
-    INIT_SCSI_REQUEST;
-
-    if (flag++ == 0)
-      SCpnt = allocate_device(&CURRENT,
-			      scsi_CDs[DEVICE_NR(MINOR(CURRENT->dev))].device, 0); 
-    else SCpnt = NULL;
-    restore_flags(flags);
-
-/* This is a performance enhancement.  We dig down into the request list and
-   try and find a queueable request (i.e. device not busy, and host able to
-   accept another command.  If we find one, then we queue it. This can
-   make a big difference on systems with more than one disk drive.  We want
-   to have the interrupts off when monkeying with the request list, because
-   otherwise the kernel might try and slip in a request in between somewhere. */
-
-    if (!SCpnt && sr_template.nr_dev > 1){
-      struct request *req1;
-      req1 = NULL;
-      save_flags(flags);
-      cli();
-      req = CURRENT;
-      while(req){
-	SCpnt = request_queueable(req,
-				  scsi_CDs[DEVICE_NR(MINOR(req->dev))].device);
-	if(SCpnt) break;
-	req1 = req;
-	req = req->next;
-      };
-      if (SCpnt && req->dev == -1) {
-	if (req == CURRENT) 
-	  CURRENT = CURRENT->next;
-	else
-	  req1->next = req->next;
-      };
-      restore_flags(flags);
-    };
-    
-    if (!SCpnt)
-      return; /* Could not find anything to do */
+    Scsi_Cmnd * SCpnt = NULL;
+    struct request * req = NULL;
+    unsigned long flags;
+    int flag = 0;
     
-  wake_up(&wait_for_request);
+    while (1==1){
+	save_flags(flags);
+	cli();
+	if (CURRENT != NULL && CURRENT->dev == -1) {
+	    restore_flags(flags);
+	    return;
+	};
+	
+	INIT_SCSI_REQUEST;
+	
+	if (flag++ == 0)
+	    SCpnt = allocate_device(&CURRENT,
+				    scsi_CDs[DEVICE_NR(MINOR(CURRENT->dev))].device, 0); 
+	else SCpnt = NULL;
+	restore_flags(flags);
+	
+	/* This is a performance enhancement.  We dig down into the request list and
+	 * try and find a queueable request (i.e. device not busy, and host able to
+	 * accept another command.  If we find one, then we queue it. This can
+	 * make a big difference on systems with more than one disk drive.  We want
+	 * to have the interrupts off when monkeying with the request list, because
+	 * otherwise the kernel might try and slip in a request in between somewhere. */
+	
+	if (!SCpnt && sr_template.nr_dev > 1){
+	    struct request *req1;
+	    req1 = NULL;
+	    save_flags(flags);
+	    cli();
+	    req = CURRENT;
+	    while(req){
+		SCpnt = request_queueable(req,
+					  scsi_CDs[DEVICE_NR(MINOR(req->dev))].device);
+		if(SCpnt) break;
+		req1 = req;
+		req = req->next;
+	    };
+	    if (SCpnt && req->dev == -1) {
+		if (req == CURRENT) 
+		    CURRENT = CURRENT->next;
+		else
+		    req1->next = req->next;
+	    };
+	    restore_flags(flags);
+	};
+	
+	if (!SCpnt)
+	    return; /* Could not find anything to do */
+	
+	wake_up(&wait_for_request);
 
-/* Queue command */
-  requeue_sr_request(SCpnt);
-  };  /* While */
+	/* Queue command */
+	requeue_sr_request(SCpnt);
+    };  /* While */
 }    
 
 void requeue_sr_request (Scsi_Cmnd * SCpnt)
@@ -570,174 +570,175 @@
 	unsigned int dev, block, realcount;
 	unsigned char cmd[10], *buffer, tries;
 	int this_count, start, end_rec;
-
+    
 	tries = 2;
-
-      repeat:
+    
+ repeat:
 	if(!SCpnt || SCpnt->request.dev <= 0) {
-	  do_sr_request();
-	  return;
+	do_sr_request();
+	return;
 	}
-
+    
 	dev =  MINOR(SCpnt->request.dev);
 	block = SCpnt->request.sector;	
 	buffer = NULL;
 	this_count = 0;
-
+    
 	if (dev >= sr_template.nr_dev)
-		{
+    {
 		/* printk("CD-ROM request error: invalid device.\n");			*/
 		SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 		tries = 2;
 		goto repeat;
-		}
-
+    }
+    
 	if (!scsi_CDs[dev].use)
-		{
+    {
 		/* printk("CD-ROM request error: device marked not in use.\n");		*/
 		SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 		tries = 2;
 		goto repeat;
-		}
-
+    }
+    
 	if (scsi_CDs[dev].device->changed)
-	        {
-/* 
- * quietly refuse to do anything to a changed disc until the changed bit has been reset
- */
+    {
+	/* 
+	 * quietly refuse to do anything to a changed disc 
+	 * until the changed bit has been reset
+	 */
 		/* printk("CD-ROM has been changed.  Prohibiting further I/O.\n");	*/
 		SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
 		tries = 2;
 		goto repeat;
-		}
+    }
 	
 	switch (SCpnt->request.cmd)
-		{
-		case WRITE: 		
-			SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
-			goto repeat;
-			break;
-		case READ : 
-		        cmd[0] = READ_6;
-			break;
-		default : 
-			panic ("Unknown sr command %d\n", SCpnt->request.cmd);
-		}
+    {
+    case WRITE: 		
+	SCpnt = end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);
+	goto repeat;
+	break;
+    case READ : 
+	cmd[0] = READ_6;
+	break;
+    default : 
+	panic ("Unknown sr command %d\n", SCpnt->request.cmd);
+    }
 	
 	cmd[1] = (SCpnt->lun << 5) & 0xe0;
-
-/*
-           Now do the grungy work of figuring out which sectors we need, and
-	   where in memory we are going to put them.
-
-	   The variables we need are:
-
-	   this_count= number of 512 byte sectors being read 
-	   block     = starting cdrom sector to read.
-	   realcount = # of cdrom sectors to read
-
-	   The major difference between a scsi disk and a scsi cdrom
-is that we will always use scatter-gather if we can, because we can
-work around the fact that the buffer cache has a block size of 1024,
-and we have 2048 byte sectors.  This code should work for buffers that
-are any multiple of 512 bytes long.  */
-
+    
+    /*
+     * Now do the grungy work of figuring out which sectors we need, and
+	 * where in memory we are going to put them.
+     * 
+	 * The variables we need are:
+     * 
+	 * this_count= number of 512 byte sectors being read 
+	 * block     = starting cdrom sector to read.
+	 * realcount = # of cdrom sectors to read
+     * 
+	 * The major difference between a scsi disk and a scsi cdrom
+     * is that we will always use scatter-gather if we can, because we can
+     * work around the fact that the buffer cache has a block size of 1024,
+     * and we have 2048 byte sectors.  This code should work for buffers that
+     * are any multiple of 512 bytes long.  */
+    
 	SCpnt->use_sg = 0;
-
+    
 	if (SCpnt->host->sg_tablesize > 0 &&
 	    (!need_isa_buffer ||
-	    dma_free_sectors >= 10)) {
-	  struct buffer_head * bh;
-	  struct scatterlist * sgpnt;
-	  int count, this_count_max;
-	  bh = SCpnt->request.bh;
-	  this_count = 0;
-	  count = 0;
-	  this_count_max = (scsi_CDs[dev].ten ? 0xffff : 0xff) << 4;
-	  /* Calculate how many links we can use.  First see if we need
-	   a padding record at the start */
-	  this_count = SCpnt->request.sector % 4;
-	  if(this_count) count++;
-	  while(bh && count < SCpnt->host->sg_tablesize) {
+	 dma_free_sectors >= 10)) {
+	struct buffer_head * bh;
+	struct scatterlist * sgpnt;
+	int count, this_count_max;
+	bh = SCpnt->request.bh;
+	this_count = 0;
+	count = 0;
+	this_count_max = (scsi_CDs[dev].ten ? 0xffff : 0xff) << 4;
+	/* Calculate how many links we can use.  First see if we need
+	 * a padding record at the start */
+	this_count = SCpnt->request.sector % 4;
+	if(this_count) count++;
+	while(bh && count < SCpnt->host->sg_tablesize) {
 	    if ((this_count + (bh->b_size >> 9)) > this_count_max) break;
 	    this_count += (bh->b_size >> 9);
 	    count++;
 	    bh = bh->b_reqnext;
-	  };
-	  /* Fix up in case of an odd record at the end */
-	  end_rec = 0;
-	  if(this_count % 4) {
+	};
+	/* Fix up in case of an odd record at the end */
+	end_rec = 0;
+	if(this_count % 4) {
 	    if (count < SCpnt->host->sg_tablesize) {
-	      count++;
-	      end_rec = (4 - (this_count % 4)) << 9;
-	      this_count += 4 - (this_count % 4);
+		count++;
+		end_rec = (4 - (this_count % 4)) << 9;
+		this_count += 4 - (this_count % 4);
 	    } else {
-	      count--;
-	      this_count -= (this_count % 4);
+		count--;
+		this_count -= (this_count % 4);
 	    };
-	  };
-	  SCpnt->use_sg = count;  /* Number of chains */
-	  count = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
-	  while( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
+	};
+	SCpnt->use_sg = count;  /* Number of chains */
+	count = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
+	while( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
 	    count = count << 1;
-	  SCpnt->sglist_len = count;
-	  sgpnt = (struct scatterlist * ) scsi_malloc(count);
-	  if (!sgpnt) {
+	SCpnt->sglist_len = count;
+	sgpnt = (struct scatterlist * ) scsi_malloc(count);
+	if (!sgpnt) {
 	    printk("Warning - running *really* short on DMA buffers\n");
 	    SCpnt->use_sg = 0;  /* No memory left - bail out */
-	  } else {
+	} else {
 	    buffer = (unsigned char *) sgpnt;
 	    count = 0;
 	    bh = SCpnt->request.bh;
 	    if(SCpnt->request.sector % 4) {
-	      sgpnt[count].length = (SCpnt->request.sector % 4) << 9;
-	      sgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
-	      if(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
-	      sgpnt[count].alt_address = sgpnt[count].address; /* Flag to delete
-								  if needed */
-	      count++;
+		sgpnt[count].length = (SCpnt->request.sector % 4) << 9;
+		sgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
+		if(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
+		sgpnt[count].alt_address = sgpnt[count].address; /* Flag to delete
+								    if needed */
+		count++;
 	    };
 	    for(bh = SCpnt->request.bh; count < SCpnt->use_sg; 
 		count++, bh = bh->b_reqnext) {
-	      if (bh) { /* Need a placeholder at the end of the record? */
-		sgpnt[count].address = bh->b_data;
-		sgpnt[count].length = bh->b_size;
-		sgpnt[count].alt_address = NULL;
-	      } else {
-		sgpnt[count].address = (char *) scsi_malloc(end_rec);
-		if(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
-		sgpnt[count].length = end_rec;
-		sgpnt[count].alt_address = sgpnt[count].address;
-		if (count+1 != SCpnt->use_sg) panic("Bad sr request list");
-		break;
-	      };
-	      if (((long) sgpnt[count].address) + sgpnt[count].length > 
-		  ISA_DMA_THRESHOLD & (SCpnt->host->unchecked_isa_dma)) {
-		sgpnt[count].alt_address = sgpnt[count].address;
-		/* We try and avoid exhausting the DMA pool, since it is easier
-		   to control usage here.  In other places we might have a more
-		   pressing need, and we would be screwed if we ran out */
-		if(dma_free_sectors < (sgpnt[count].length >> 9) + 5) {
-		  sgpnt[count].address = NULL;
+		if (bh) { /* Need a placeholder at the end of the record? */
+		    sgpnt[count].address = bh->b_data;
+		    sgpnt[count].length = bh->b_size;
+		    sgpnt[count].alt_address = NULL;
 		} else {
-		  sgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
+		    sgpnt[count].address = (char *) scsi_malloc(end_rec);
+		    if(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
+		    sgpnt[count].length = end_rec;
+		    sgpnt[count].alt_address = sgpnt[count].address;
+		    if (count+1 != SCpnt->use_sg) panic("Bad sr request list");
+		    break;
 		};
-/* If we start running low on DMA buffers, we abort the scatter-gather
-   operation, and free all of the memory we have allocated.  We want to
-   ensure that all scsi operations are able to do at least a non-scatter/gather
-   operation */
-		if(sgpnt[count].address == NULL){ /* Out of dma memory */
-		  printk("Warning: Running low on SCSI DMA buffers");
-		  /* Try switching back to a non scatter-gather operation. */
-		  while(--count >= 0){
-		    if(sgpnt[count].alt_address) 
-		      scsi_free(sgpnt[count].address, sgpnt[count].length);
-		  };
-		  SCpnt->use_sg = 0;
-		  scsi_free(buffer, SCpnt->sglist_len);
-		  break;
-		}; /* if address == NULL */
-	      };  /* if need DMA fixup */
+		if (((long) sgpnt[count].address) + sgpnt[count].length > ISA_DMA_THRESHOLD &&
+		  SCpnt->host->unchecked_isa_dma) {
+		    sgpnt[count].alt_address = sgpnt[count].address;
+		    /* We try and avoid exhausting the DMA pool, since it is easier
+		     * to control usage here.  In other places we might have a more
+		     * pressing need, and we would be screwed if we ran out */
+		    if(dma_free_sectors < (sgpnt[count].length >> 9) + 5) {
+			sgpnt[count].address = NULL;
+		    } else {
+			sgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
+		    };
+		    /* If we start running low on DMA buffers, we abort the scatter-gather
+		     * operation, and free all of the memory we have allocated.  We want to
+		     * ensure that all scsi operations are able to do at least a non-scatter/gather
+		     * operation */
+		    if(sgpnt[count].address == NULL){ /* Out of dma memory */
+			printk("Warning: Running low on SCSI DMA buffers");
+			/* Try switching back to a non scatter-gather operation. */
+			while(--count >= 0){
+			    if(sgpnt[count].alt_address) 
+				scsi_free(sgpnt[count].address, sgpnt[count].length);
+			};
+			SCpnt->use_sg = 0;
+			scsi_free(buffer, SCpnt->sglist_len);
+			break;
+		    }; /* if address == NULL */
+		};  /* if need DMA fixup */
 	    };  /* for loop to fill list */
 #ifdef DEBUG
 	    printk("SR: %d %d %d %d %d *** ",SCpnt->use_sg, SCpnt->request.sector,
@@ -745,59 +746,59 @@
 		   SCpnt->request.current_nr_sectors,
 		   SCpnt->request.nr_sectors);
 	    for(count=0; count<SCpnt->use_sg; count++)
-	      printk("SGlist: %d %x %x %x\n", count,
-		     sgpnt[count].address, 
-		     sgpnt[count].alt_address, 
-		     sgpnt[count].length);
+		printk("SGlist: %d %x %x %x\n", count,
+		       sgpnt[count].address, 
+		       sgpnt[count].alt_address, 
+		       sgpnt[count].length);
 #endif
-	  };  /* Able to allocate scatter-gather list */
+	};  /* Able to allocate scatter-gather list */
 	};
 	
 	if (SCpnt->use_sg == 0){
-	  /* We cannot use scatter-gather.  Do this the old fashion way */
-	  if (!SCpnt->request.bh)  	
+	/* We cannot use scatter-gather.  Do this the old fashion way */
+	if (!SCpnt->request.bh)  	
 	    this_count = SCpnt->request.nr_sectors;
-	  else
+	else
 	    this_count = (SCpnt->request.bh->b_size >> 9);
-	  
-	  start = block % 4;
-	  if (start)
+	
+	start = block % 4;
+	if (start)
 	    {				  
-	      this_count = ((this_count > 4 - start) ? 
-			    (4 - start) : (this_count));
-	      buffer = (unsigned char *) scsi_malloc(2048);
+	    this_count = ((this_count > 4 - start) ? 
+			  (4 - start) : (this_count));
+	    buffer = (unsigned char *) scsi_malloc(2048);
 	    } 
-	  else if (this_count < 4)
+	else if (this_count < 4)
 	    {
-	      buffer = (unsigned char *) scsi_malloc(2048);
+	    buffer = (unsigned char *) scsi_malloc(2048);
 	    }
-	  else
+	else
 	    {
-	      this_count -= this_count % 4;
-	      buffer = (unsigned char *) SCpnt->request.buffer;
-	      if (((long) buffer) + (this_count << 9) > ISA_DMA_THRESHOLD & 
-		  (SCpnt->host->unchecked_isa_dma))
+	    this_count -= this_count % 4;
+	    buffer = (unsigned char *) SCpnt->request.buffer;
+	    if (((long) buffer) + (this_count << 9) > ISA_DMA_THRESHOLD &&
+		SCpnt->host->unchecked_isa_dma)
 		buffer = (unsigned char *) scsi_malloc(this_count << 9);
 	    }
 	};
-
+    
 	if (scsi_CDs[dev].sector_size == 2048)
-	  block = block >> 2; /* These are the sectors that the cdrom uses */
+	block = block >> 2; /* These are the sectors that the cdrom uses */
 	else
-	  block = block & 0xfffffffc;
-
+	block = block & 0xfffffffc;
+    
 	realcount = (this_count + 3) / 4;
-
+    
 	if (scsi_CDs[dev].sector_size == 512) realcount = realcount << 2;
-
+    
 	if (((realcount > 0xff) || (block > 0x1fffff)) && scsi_CDs[dev].ten) 
-		{
+    {
 		if (realcount > 0xffff)
-		        {
+	{
 			realcount = 0xffff;
 			this_count = realcount * (scsi_CDs[dev].sector_size >> 9);
-			}
-
+	}
+	
 		cmd[0] += READ_10 - READ_6 ;
 		cmd[2] = (unsigned char) (block >> 24) & 0xff;
 		cmd[3] = (unsigned char) (block >> 16) & 0xff;
@@ -806,269 +807,310 @@
 		cmd[6] = cmd[9] = 0;
 		cmd[7] = (unsigned char) (realcount >> 8) & 0xff;
 		cmd[8] = (unsigned char) realcount & 0xff;
-		}
+    }
 	else
-		{
-		  if (realcount > 0xff)
-		    {
-		      realcount = 0xff;
-		      this_count = realcount * (scsi_CDs[dev].sector_size >> 9);
-		    }
-		  
-		  cmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
-		  cmd[2] = (unsigned char) ((block >> 8) & 0xff);
-		  cmd[3] = (unsigned char) block & 0xff;
-		  cmd[4] = (unsigned char) realcount;
-		  cmd[5] = 0;
-		}   
-
+    {
+	if (realcount > 0xff)
+	{
+	    realcount = 0xff;
+	    this_count = realcount * (scsi_CDs[dev].sector_size >> 9);
+	}
+	
+	cmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
+	cmd[2] = (unsigned char) ((block >> 8) & 0xff);
+	cmd[3] = (unsigned char) block & 0xff;
+	cmd[4] = (unsigned char) realcount;
+	cmd[5] = 0;
+    }   
+    
 #ifdef DEBUG
-	{ 
-	  int i;
-	  printk("ReadCD: %d %d %d %d\n",block, realcount, buffer, this_count);
-	  printk("Use sg: %d\n", SCpnt->use_sg);
-	  printk("Dumping command: ");
-	  for(i=0; i<12; i++) printk("%2.2x ", cmd[i]);
-	  printk("\n");
-	};
+    { 
+	int i;
+	printk("ReadCD: %d %d %d %d\n",block, realcount, buffer, this_count);
+	printk("Use sg: %d\n", SCpnt->use_sg);
+	printk("Dumping command: ");
+	for(i=0; i<12; i++) printk("%2.2x ", cmd[i]);
+	printk("\n");
+    };
 #endif
-
-/* Some dumb host adapters can speed transfers by knowing the
- * minimum transfersize in advance.
- *
- * We shouldn't disconnect in the middle of a sector, but the cdrom
- * sector size can be larger than the size of a buffer and the
- * transfer may be split to the size of a buffer.  So it's safe to
- * assume that we can at least transfer the minimum of the buffer
- * size (1024) and the sector size between each connect / disconnect.
- */
-
-        SCpnt->transfersize = (scsi_CDs[dev].sector_size > 1024) ?
-                        1024 : scsi_CDs[dev].sector_size;
-
+    
+    /* Some dumb host adapters can speed transfers by knowing the
+     * minimum transfersize in advance.
+     *
+     * We shouldn't disconnect in the middle of a sector, but the cdrom
+     * sector size can be larger than the size of a buffer and the
+     * transfer may be split to the size of a buffer.  So it's safe to
+     * assume that we can at least transfer the minimum of the buffer
+     * size (1024) and the sector size between each connect / disconnect.
+     */
+    
+    SCpnt->transfersize = (scsi_CDs[dev].sector_size > 1024) ?
+	1024 : scsi_CDs[dev].sector_size;
+    
 	SCpnt->this_count = this_count;
 	scsi_do_cmd (SCpnt, (void *) cmd, buffer, 
-		     realcount * scsi_CDs[dev].sector_size, 
-		     rw_intr, SR_TIMEOUT, MAX_RETRIES);
+		 realcount * scsi_CDs[dev].sector_size, 
+		 rw_intr, SR_TIMEOUT, MAX_RETRIES);
 }
 
 static int sr_detect(Scsi_Device * SDp){
-  
-  if(SDp->type != TYPE_ROM && SDp->type != TYPE_WORM) return 0;
-
-  printk("Detected scsi CD-ROM sr%d at scsi%d, id %d, lun %d\n", 
-	 sr_template.dev_noticed++,
-	 SDp->host->host_no , SDp->id, SDp->lun); 
-
-	 return 1;
+    
+    if(SDp->type != TYPE_ROM && SDp->type != TYPE_WORM) return 0;
+    
+    printk("Detected scsi CD-ROM sr%d at scsi%d, channel %d, id %d, lun %d\n", 
+	   sr_template.dev_noticed++,
+	   SDp->host->host_no, SDp->channel, SDp->id, SDp->lun); 
+    
+    return 1;
 }
 
 static int sr_attach(Scsi_Device * SDp){
-  Scsi_CD * cpnt;
-  int i;
-  
-  if(SDp->type != TYPE_ROM && SDp->type != TYPE_WORM) return 1;
-  
-  if (sr_template.nr_dev >= sr_template.dev_max)
+    Scsi_CD * cpnt;
+    int i;
+    
+    if(SDp->type != TYPE_ROM && SDp->type != TYPE_WORM) return 1;
+    
+    if (sr_template.nr_dev >= sr_template.dev_max)
     {
 	SDp->attached--;
 	return 1;
     }
-  
-  for(cpnt = scsi_CDs, i=0; i<sr_template.dev_max; i++, cpnt++) 
-    if(!cpnt->device) break;
-  
-  if(i >= sr_template.dev_max) panic ("scsi_devices corrupt (sr)");
-  
-  SDp->scsi_request_fn = do_sr_request;
-  scsi_CDs[i].device = SDp;
-  sr_template.nr_dev++;
-  if(sr_template.nr_dev > sr_template.dev_max)
-    panic ("scsi_devices corrupt (sr)");
-  return 0;
+    
+    for(cpnt = scsi_CDs, i=0; i<sr_template.dev_max; i++, cpnt++) 
+	if(!cpnt->device) break;
+    
+    if(i >= sr_template.dev_max) panic ("scsi_devices corrupt (sr)");
+    
+    SDp->scsi_request_fn = do_sr_request;
+    scsi_CDs[i].device = SDp;
+    sr_template.nr_dev++;
+    if(sr_template.nr_dev > sr_template.dev_max)
+	panic ("scsi_devices corrupt (sr)");
+    return 0;
 }
-     
+
 
 static void sr_init_done (Scsi_Cmnd * SCpnt)
 {
-  struct request * req;
-  
-  req = &SCpnt->request;
-  req->dev = 0xfffe; /* Busy, but indicate request done */
-  
-  if (req->sem != NULL) {
-    up(req->sem);
-  }
+    struct request * req;
+    
+    req = &SCpnt->request;
+    req->dev = 0xfffe; /* Busy, but indicate request done */
+    
+    if (req->sem != NULL) {
+	up(req->sem);
+    }
 }
 
 static void get_sectorsize(int i){
-  unsigned char cmd[10];
-  unsigned char *buffer;
-  int the_result, retries;
-  Scsi_Cmnd * SCpnt;
-  
-  buffer = (unsigned char *) scsi_malloc(512);
-  SCpnt = allocate_device(NULL, scsi_CDs[i].device, 1);
-
-  retries = 3;
-  do {
-    cmd[0] = READ_CAPACITY;
-    cmd[1] = (scsi_CDs[i].device->lun << 5) & 0xe0;
-    memset ((void *) &cmd[2], 0, 8);
-    SCpnt->request.dev = 0xffff;  /* Mark as really busy */
-    SCpnt->cmd_len = 0;
-    
-    memset(buffer, 0, 8);
-
-    scsi_do_cmd (SCpnt,
-		 (void *) cmd, (void *) buffer,
-		 512, sr_init_done,  SR_TIMEOUT,
-		 MAX_RETRIES);
+    unsigned char cmd[10];
+    unsigned char *buffer;
+    int the_result, retries;
+    Scsi_Cmnd * SCpnt;
     
-    if (current == task[0])
-      while(SCpnt->request.dev != 0xfffe) barrier();
-    else
-      if (SCpnt->request.dev != 0xfffe){
-      	struct semaphore sem = MUTEX_LOCKED;
-	SCpnt->request.sem = &sem;
-	down(&sem);
-	/* Hmm.. Have to ask about this */
-	while (SCpnt->request.dev != 0xfffe) schedule();
-      };
-    
-    the_result = SCpnt->result;
-    retries--;
-    
-  } while(the_result && retries);
-  
-  SCpnt->request.dev = -1;  /* Mark as not busy */
-  
-  wake_up(&SCpnt->device->device_wait); 
-
-  if (the_result) {
-    scsi_CDs[i].capacity = 0x1fffff;
-    scsi_CDs[i].sector_size = 2048;  /* A guess, just in case */
-    scsi_CDs[i].needs_sector_size = 1;
-  } else {
-    scsi_CDs[i].capacity = (buffer[0] << 24) |
-      (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
-    scsi_CDs[i].sector_size = (buffer[4] << 24) |
-      (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
-    if(scsi_CDs[i].sector_size == 0) scsi_CDs[i].sector_size = 2048;
-    if(scsi_CDs[i].sector_size != 2048 && 
-       scsi_CDs[i].sector_size != 512) {
-      printk ("scd%d : unsupported sector size %d.\n",
-	      i, scsi_CDs[i].sector_size);
-      scsi_CDs[i].capacity = 0;
-      scsi_CDs[i].needs_sector_size = 1;
+    buffer = (unsigned char *) scsi_malloc(512);
+    SCpnt = allocate_device(NULL, scsi_CDs[i].device, 1);
+    
+    retries = 3;
+    do {
+	cmd[0] = READ_CAPACITY;
+	cmd[1] = (scsi_CDs[i].device->lun << 5) & 0xe0;
+	memset ((void *) &cmd[2], 0, 8);
+	SCpnt->request.dev = 0xffff;  /* Mark as really busy */
+	SCpnt->cmd_len = 0;
+	
+	memset(buffer, 0, 8);
+	
+	scsi_do_cmd (SCpnt,
+		     (void *) cmd, (void *) buffer,
+		     512, sr_init_done,  SR_TIMEOUT,
+		     MAX_RETRIES);
+	
+	if (current->pid == 0)
+	    while(SCpnt->request.dev != 0xfffe)
+		barrier();
+	else
+	    if (SCpnt->request.dev != 0xfffe){
+		struct semaphore sem = MUTEX_LOCKED;
+		SCpnt->request.sem = &sem;
+		down(&sem);
+		/* Hmm.. Have to ask about this */
+		while (SCpnt->request.dev != 0xfffe) schedule();
+	    };
+	
+	the_result = SCpnt->result;
+	retries--;
+	
+    } while(the_result && retries);
+    
+    SCpnt->request.dev = -1;  /* Mark as not busy */
+    
+    wake_up(&SCpnt->device->device_wait); 
+    
+    if (the_result) {
+	scsi_CDs[i].capacity = 0x1fffff;
+	scsi_CDs[i].sector_size = 2048;  /* A guess, just in case */
+	scsi_CDs[i].needs_sector_size = 1;
+    } else {
+	scsi_CDs[i].capacity = (buffer[0] << 24) |
+	    (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
+	scsi_CDs[i].sector_size = (buffer[4] << 24) |
+	    (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
+	if(scsi_CDs[i].sector_size == 0) scsi_CDs[i].sector_size = 2048;
+	if(scsi_CDs[i].sector_size != 2048 && 
+	   scsi_CDs[i].sector_size != 512) {
+	    printk ("scd%d : unsupported sector size %d.\n",
+		    i, scsi_CDs[i].sector_size);
+	    scsi_CDs[i].capacity = 0;
+	    scsi_CDs[i].needs_sector_size = 1;
+	};
+	if(scsi_CDs[i].sector_size == 2048)
+	    scsi_CDs[i].capacity *= 4;
+	scsi_CDs[i].needs_sector_size = 0;
+	sr_sizes[i] = scsi_CDs[i].capacity;
     };
-    if(scsi_CDs[i].sector_size == 2048)
-      scsi_CDs[i].capacity *= 4;
-    scsi_CDs[i].needs_sector_size = 0;
-    sr_sizes[i] = scsi_CDs[i].capacity;
-  };
-  scsi_free(buffer, 512);
+    scsi_free(buffer, 512);
 }
 
 static void sr_init()
 {
 	int i;
 	static int sr_registered = 0;
-
+    
 	if(sr_template.dev_noticed == 0) return;
-
+    
 	if(!sr_registered) {
-	  if (register_blkdev(MAJOR_NR,"sr",&sr_fops)) {
+	if (register_blkdev(MAJOR_NR,"sr",&sr_fops)) {
 	    printk("Unable to get major %d for SCSI-CD\n",MAJOR_NR);
 	    return;
-	  }
-	  sr_registered++;
 	}
-
+	sr_registered++;
+	}
+    
 	
 	if (scsi_CDs) return;
 	sr_template.dev_max = sr_template.dev_noticed + SR_EXTRA_DEVS;
 	scsi_CDs = (Scsi_CD *) scsi_init_malloc(sr_template.dev_max * sizeof(Scsi_CD), GFP_ATOMIC);
 	memset(scsi_CDs, 0, sr_template.dev_max * sizeof(Scsi_CD));
-
+    
 	sr_sizes = (int *) scsi_init_malloc(sr_template.dev_max * sizeof(int), GFP_ATOMIC);
 	memset(sr_sizes, 0, sr_template.dev_max * sizeof(int));
-
+    
 	sr_blocksizes = (int *) scsi_init_malloc(sr_template.dev_max * 
-						 sizeof(int), GFP_ATOMIC);
+					     sizeof(int), GFP_ATOMIC);
 	for(i=0;i<sr_template.dev_max;i++) sr_blocksizes[i] = 2048;
 	blksize_size[MAJOR_NR] = sr_blocksizes;
-
+    
 }
 
 void sr_finish()
 {
-  int i;
-
+    int i;
+    
 	blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
 	blk_size[MAJOR_NR] = sr_sizes;	
-
+    
 	for (i = 0; i < sr_template.nr_dev; ++i)
-		{
-		  /* If we have already seen this, then skip it.  Comes up
-		     with loadable modules. */
-		  if (scsi_CDs[i].capacity) continue;
-		  scsi_CDs[i].capacity = 0x1fffff;
-		  scsi_CDs[i].sector_size = 2048;  /* A guess, just in case */
-		  scsi_CDs[i].needs_sector_size = 1;
+    {
+	/* If we have already seen this, then skip it.  Comes up
+	 * with loadable modules. */
+	if (scsi_CDs[i].capacity) continue;
+	scsi_CDs[i].capacity = 0x1fffff;
+	scsi_CDs[i].sector_size = 2048;  /* A guess, just in case */
+	scsi_CDs[i].needs_sector_size = 1;
 #if 0
-		  /* seems better to leave this for later */
-		  get_sectorsize(i);
-		  printk("Scd sectorsize = %d bytes.\n", scsi_CDs[i].sector_size);
+	/* seems better to leave this for later */
+	get_sectorsize(i);
+	printk("Scd sectorsize = %d bytes.\n", scsi_CDs[i].sector_size);
 #endif
-		  scsi_CDs[i].use = 1;
-		  scsi_CDs[i].ten = 1;
-		  scsi_CDs[i].remap = 1;
-		  sr_sizes[i] = scsi_CDs[i].capacity;
-		}
-
-
+	scsi_CDs[i].use = 1;
+	scsi_CDs[i].ten = 1;
+	scsi_CDs[i].remap = 1;
+	sr_sizes[i] = scsi_CDs[i].capacity;
+    }
+    
+    
 	/* If our host adapter is capable of scatter-gather, then we increase
-	   the read-ahead to 16 blocks (32 sectors).  If not, we use
-	   a two block (4 sector) read ahead. */
+	 * the read-ahead to 16 blocks (32 sectors).  If not, we use
+	 * a two block (4 sector) read ahead. */
 	if(scsi_CDs[0].device && scsi_CDs[0].device->host->sg_tablesize)
-	  read_ahead[MAJOR_NR] = 32;  /* 32 sector read-ahead.  Always removable. */
+	read_ahead[MAJOR_NR] = 32;  /* 32 sector read-ahead.  Always removable. */
 	else
-	  read_ahead[MAJOR_NR] = 4;  /* 4 sector read-ahead */
-
+	read_ahead[MAJOR_NR] = 4;  /* 4 sector read-ahead */
+    
 	return;
 }	
 
 static void sr_detach(Scsi_Device * SDp)
 {
-  Scsi_CD * cpnt;
-  int i, major;
-  
-  major = MAJOR_NR << 8;
-
-  for(cpnt = scsi_CDs, i=0; i<sr_template.dev_max; i++, cpnt++) 
-    if(cpnt->device == SDp) {
-      /*
-       * Since the cdrom is read-only, no need to sync the device.
-       * We should be kind to our buffer cache, however.
-       */
-      invalidate_inodes(major | i);
-      invalidate_buffers(major | i);
-
-      /*
-       * Reset things back to a sane state so that one can re-load a new
-       * driver (perhaps the same one).
-       */
-      cpnt->device = NULL;
-      cpnt->capacity = 0;
-      SDp->attached--;
-      sr_template.nr_dev--;
-      sr_template.dev_noticed--;
-      sr_sizes[i] = 0;
-      return;
+    Scsi_CD * cpnt;
+    int i, major;
+    
+    major = MAJOR_NR << 8;
+    
+    for(cpnt = scsi_CDs, i=0; i<sr_template.dev_max; i++, cpnt++) 
+	if(cpnt->device == SDp) {
+	    /*
+	     * Since the cdrom is read-only, no need to sync the device.
+	     * We should be kind to our buffer cache, however.
+	     */
+	    invalidate_inodes(major | i);
+	    invalidate_buffers(major | i);
+	    
+	    /*
+	     * Reset things back to a sane state so that one can re-load a new
+	     * driver (perhaps the same one).
+	     */
+	    cpnt->device = NULL;
+	    cpnt->capacity = 0;
+	    SDp->attached--;
+	    sr_template.nr_dev--;
+	    sr_template.dev_noticed--;
+	    sr_sizes[i] = 0;
+	    return;
+	}
+    return;
+}
+
+
+#ifdef MODULE
+#include <linux/module.h>
+#include <linux/version.h>
+
+char kernel_version[] = UTS_RELEASE;
+
+int init_module(void) {
+    sr_template.usage_count = &mod_use_count_;
+    return scsi_register_module(MODULE_SCSI_DEV, &sr_template);
+}
+
+void cleanup_module( void) 
+{
+    int i;
+    
+    if (MOD_IN_USE) {
+	printk(KERN_INFO __FILE__ ": module is in use, remove rejected\n");
+	return;
     }
-  return;
+    scsi_unregister_module(MODULE_SCSI_DEV, &sr_template);
+    unregister_blkdev(SCSI_GENERIC_MAJOR, "sr");
+    if(scsi_CDs != NULL) {
+	scsi_init_free((char *) scsi_CDs,
+		       (sr_template.dev_noticed + SR_EXTRA_DEVS) 
+		       * sizeof(Scsi_CD));
+	
+	scsi_init_free((char *) sr_sizes, sr_template.dev_max * sizeof(int));
+	scsi_init_free((char *) sr_blocksizes, sr_template.dev_max * sizeof(int));
+    }
+    
+    blksize_size[MAJOR_NR] = NULL;
+    blk_dev[MAJOR_NR].request_fn = NULL;
+    blk_size[MAJOR_NR] = NULL;	
+    read_ahead[MAJOR_NR] = 0;
+    
+    sr_template.dev_max = 0;
 }
+#endif /* MODULE */
 
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
@@ -1077,12 +1119,14 @@
  * of the file.
  * ---------------------------------------------------------------------------
  * Local variables:
- * c-indent-level: 8
+ * c-indent-level: 4
  * c-brace-imaginary-offset: 0
- * c-brace-offset: -8
- * c-argdecl-indent: 8
- * c-label-offset: -8
- * c-continued-statement-offset: 8
+ * c-brace-offset: -4
+ * c-argdecl-indent: 4
+ * c-label-offset: -4
+ * c-continued-statement-offset: 4
  * c-continued-brace-offset: 0
+ * indent-tabs-mode: nil
+ * tab-width: 8
  * End:
  */

FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen, slshen@lbl.gov with Sam's (original) version
of this