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
- Lines: 1747
- Date:
Thu Jun 29 12:37:45 1995
- Orig file:
v1.3.4/linux/drivers/scsi/sr.c
- Orig date:
Sat Jun 10 19:13:13 1995
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