URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [scsi/] [sr.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/*
 *  sr.c Copyright (C) 1992 David Giller
 *           Copyright (C) 1993, 1994, 1995 Eric Youngdale
 *
 *  adapted from:
 *      sd.c Copyright (C) 1992 Drew Eckhardt
 *      Linux scsi disk driver by
 *              Drew Eckhardt <drew@colorado.edu>
 *
 *      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 Thomas Quinot thomas@melchior.cuivre.fdn.fr to
 *       provide auto-eject.
 *
 */
 
#include <linux/module.h>
 
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/cdrom.h>
#include <linux/interrupt.h>
#include <asm/system.h>
 
#define MAJOR_NR SCSI_CDROM_MAJOR
#include <linux/blk.h>
#include "scsi.h"
#include "hosts.h"
#include "sr.h"
#include <scsi/scsi_ioctl.h>   /* For the door lock/unlock commands */
#include "constants.h"
 
#define MAX_RETRIES 3
#define SR_TIMEOUT (30 * HZ)
 
static int sr_init(void);
static void sr_finish(void);
static int sr_attach(Scsi_Device *);
static int sr_detect(Scsi_Device *);
static void sr_detach(Scsi_Device *);
 
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 = NULL;
static int * sr_sizes;
 
static int * sr_blocksizes;
 
static int sr_open(struct inode *, struct file *);
void get_sectorsize(int);
void sr_photocd(struct inode *);
 
extern int sr_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
 
void requeue_sr_request (Scsi_Cmnd * SCpnt);
static int check_cdrom_media_change(kdev_t);
 
static void sr_release(struct inode * inode, struct file * file)
{
        sync_dev(inode->i_rdev);
        if(! --scsi_CDs[MINOR(inode->i_rdev)].device->access_count)
        {
            sr_ioctl(inode, NULL, SCSI_IOCTL_DOORUNLOCK, 0);
            if (scsi_CDs[MINOR(inode->i_rdev)].auto_eject)
                sr_ioctl(inode, NULL, CDROMEJECT, 0);
        }
        if (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 */
        NULL,                   /* readdir - bad */
        NULL,                   /* select */
        sr_ioctl,               /* ioctl */
        NULL,                   /* mmap */
        sr_open,        /* special open code */
        sr_release,             /* release */
        NULL,                   /* fsync */
        NULL,                   /* fasync */
        check_cdrom_media_change,  /* Disk change */
        NULL                    /* revalidate */
};
 
/*
 * This function checks to see if the media has been changed in the
 * CDROM drive.  It is possible that we have already sensed a change,
 * or the drive may have sensed one and not yet reported it.  We must
 * be ready for either case. This function always reports the current
 * value of the changed bit.  If flag is 0, then the changed bit is reset.
 * This function could be done as an ioctl, but we would need to have
 * an inode for that to work, and we do not always have one.
 */
 
int check_cdrom_media_change(kdev_t full_dev){
        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 */
        };
 
        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;
        };
        return retval;
}
 
/*
 * rw_intr is the interrupt routine for the device driver.  It will be notified on the
 * end of a SCSI read / write, and will take on of several actions based on success or failure.
 */
 
static void rw_intr (Scsi_Cmnd * SCpnt)
{
        int result = SCpnt->result;
        int this_count = SCpnt->this_count;
        int good_sectors = (result == 0 ? this_count : 0);
        int block_sectors = 0;
 
#ifdef DEBUG
        printk("sr.c done: %x %x\n",result, SCpnt->request.bh->b_data);
#endif
    /*
      Handle MEDIUM ERRORs or VOLUME OVERFLOWs that indicate partial success.
      Since this is a relatively rare error condition, no care is taken to
      avoid unnecessary additional work such as memcpy's that could be avoided.
    */
 
        if (driver_byte(result) != 0 &&              /* An error occurred */
            SCpnt->sense_buffer[0] == 0xF0 &&        /* Sense data is valid */
            (SCpnt->sense_buffer[2] == MEDIUM_ERROR ||
             SCpnt->sense_buffer[2] == VOLUME_OVERFLOW ||
             SCpnt->sense_buffer[2] == ILLEGAL_REQUEST))
          {
            long error_sector = (SCpnt->sense_buffer[3] << 24) |
                                (SCpnt->sense_buffer[4] << 16) |
                                (SCpnt->sense_buffer[5] << 8) |
                                SCpnt->sense_buffer[6];
            int device_nr = DEVICE_NR(SCpnt->request.rq_dev);
            if (SCpnt->request.bh != NULL)
              block_sectors = SCpnt->request.bh->b_size >> 9;
            if (block_sectors < 4) block_sectors = 4;
            if (scsi_CDs[device_nr].sector_size == 2048)
              error_sector <<= 2;
            error_sector &= ~ (block_sectors - 1);
            good_sectors = error_sector - SCpnt->request.sector;
            if (good_sectors < 0 || good_sectors >= this_count)
              good_sectors = 0;
            /*
              The SCSI specification allows for the value returned by READ
              CAPACITY to be up to 75 2K sectors past the last readable
              block.  Therefore, if we hit a medium error within the last
              75 2K sectors, we decrease the saved size value.
            */
            if ((error_sector >> 1) < sr_sizes[device_nr] &&
                scsi_CDs[device_nr].capacity - error_sector < 4*75)
              sr_sizes[device_nr] = error_sector >> 1;
          }
 
        if (good_sectors > 0)
    { /* Some sectors were read successfully. */
        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,
                       good_sectors << 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) && good_sectors == 2 &&
                   SCpnt->request.nr_sectors > good_sectors &&
                   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);
                    good_sectors += 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);
                };
                    };
                    scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
                    if(SCpnt->request.sector % 4) good_sectors -= 2;
            /* See   if there is a padding record at the end that needs to be removed */
                    if(good_sectors > SCpnt->request.nr_sectors)
                good_sectors -= 2;
        };
 
#ifdef DEBUG
                printk("(%x %x %x) ",SCpnt->request.bh, SCpnt->request.nr_sectors,
                       good_sectors);
#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, good_sectors);  /* All done */
        if (result == 0)
          {
            requeue_sr_request(SCpnt);
            return;
          }
    }
 
    if (good_sectors == 0) {
        /* We only come through here if no sectors were read successfully. */
 
    /* 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++) {
            if (sgpnt[i].alt_address) {
                scsi_free(sgpnt[i].address, sgpnt[i].length);
            }
        }
        scsi_free(SCpnt->buffer, SCpnt->sglist_len);  /* Free list of scatter-gather pointers */
        } else {
        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.      */
 
                                scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->changed = 1;
                                SCpnt = end_scsi_request(SCpnt, 0, this_count);
                                requeue_sr_request(SCpnt);
                                return;
                        }
                }
 
                if (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
                        printk("CD-ROM error: ");
                        print_sense("sr", SCpnt);
                        printk("command was: ");
                        print_command(SCpnt->cmnd);
                        if (scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].ten) {
                                scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].ten = 0;
                                requeue_sr_request(SCpnt);
                                result = 0;
                                return;
                        } else {
                                SCpnt = end_scsi_request(SCpnt, 0, this_count);
                                requeue_sr_request(SCpnt); /* Do next request */
                                return;
                        }
 
                }
 
                if (SCpnt->sense_buffer[2] == NOT_READY) {
                        printk("CD-ROM 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;
                }
 
                if (SCpnt->sense_buffer[2] == MEDIUM_ERROR) {
                    printk("scsi%d: MEDIUM ERROR on "
                           "channel %d, id %d, lun %d, CDB: ",
                           SCpnt->host->host_no, (int) SCpnt->channel,
                           (int) SCpnt->target, (int) SCpnt->lun);
                    print_command(SCpnt->cmnd);
                    print_sense("sr", SCpnt);
                    SCpnt = end_scsi_request(SCpnt, 0, block_sectors);
                    requeue_sr_request(SCpnt);
                    return;
                }
 
                if (SCpnt->sense_buffer[2] == VOLUME_OVERFLOW) {
                    printk("scsi%d: VOLUME OVERFLOW on "
                           "channel %d, id %d, lun %d, CDB: ",
                           SCpnt->host->host_no, (int) SCpnt->channel,
                           (int) SCpnt->target, (int) SCpnt->lun);
                    print_command(SCpnt->cmnd);
                    print_sense("sr", SCpnt);
                    SCpnt = end_scsi_request(SCpnt, 0, block_sectors);
                    requeue_sr_request(SCpnt);
                    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.rq_dev)].device->host->host_no,
               scsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->id,
               scsi_CDs[DEVICE_NR(SCpnt->request.rq_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);
    }
}
 
/*
 * Here I tried to implement support for multisession-CD's
 *
 * Much of this has do be done with vendor-specific SCSI-commands, because
 * multisession is newer than the SCSI-II standard.
 * So I have to complete it step by step. Useful information is welcome.
 *
 * Actually works:
 *   - NEC:     Detection and support of multisession CD's. Special handling
 *              for XA-disks is not necessary.
 *
 *   - TOSHIBA: setting density is done here now, mounting PhotoCD's should
 *              work now without running the program "set_density"
 *              Multisession CD's are supported too.
 *
 *   Gerd Knorr <kraxel@cs.tu-berlin.de>
 */
/*
 * 19950704 operator@melchior.cuivre.fdn.fr (Thomas Quinot)
 *
 *   - SONY:    Same as Nec.
 *
 *   - PIONEER: works with SONY code (may be others too ?)
 */
 
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) {
#ifdef DEBUG
        printk(KERN_DEBUG "sr_photocd: CDROM and/or driver do 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;
    }
 
    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(KERN_DEBUG "sr_photocd: use NEC code\n");
#endif
        memset(buf,0,40);
        *((unsigned int*)buf)   = 0x0;   /* we send nothing...     */
        *((unsigned int*)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) {
            if (rc != 0x28000002) /* drop "not ready" */
                printk(KERN_WARNING"sr_photocd: ioctl error (NEC): 0x%x\n",rc);
            break;
        }
        if (rec[14] != 0 && rec[14] != 0xb0) {
            printk(KERN_INFO"sr_photocd: (NEC) 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(KERN_DEBUG "sr_photocd: multisession CD detected. start: %lu\n",sector);
        }
#endif
        break;
 
    case SCSI_MAN_TOSHIBA:
#ifdef DEBUG
        printk(KERN_DEBUG "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 int*)buf)   = (unsigned int) 0;
        *((unsigned int*)buf+1) = (unsigned int) 4;  /* receive 4 bytes */
        cmd[0]                  = (unsigned char) 0x00c7;
        cmd[1]                  = (unsigned char) 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(KERN_INFO "sr_photocd: (TOSHIBA) Hmm, seems the CDROM doesn't support multisession CD's\n");
                    no_multi = 1;
                }
            } else
                printk(KERN_INFO"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;
#ifdef DEBUG
            printk(KERN_DEBUG "sr_photocd: multisession CD detected: start: %lu\n",sector);
#endif
        }
 
        /* now we do a get_density... */
        memset(buf,0,40);
        *((unsigned int*)buf)   = (unsigned int) 0;
        *((unsigned int*)buf+1) = (unsigned int) 12;
        cmd[0]                  = (unsigned char) MODE_SENSE;
        cmd[2]                  = (unsigned char) 1;
        cmd[4]                  = (unsigned char) 12;
        rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
                               SCSI_IOCTL_SEND_COMMAND, buf);
        if (rc != 0) {
            printk(KERN_WARNING "sr_photocd: ioctl error (TOSHIBA #2): 0x%x\n",rc);
            break;
        }
#ifdef DEBUG
        printk(KERN_DEBUG "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)) {
#ifdef DEBUG
            printk(KERN_DEBUG "sr_photocd: doing set_density\n");
#endif
            memset(buf,0,40);
            *((unsigned int*)buf)   = (unsigned int) 12;  /* send 12 bytes */
            *((unsigned int*)buf+1) = (unsigned int) 0;
            cmd[0]                  = (unsigned char) MODE_SELECT;
            cmd[1]                  = (unsigned char) (1 << 4);
            cmd[4]                  = (unsigned char) 12;
            send = &cmd[6];             /* this is a 6-Byte command    */
            send[ 3]                = (unsigned char) 0x08; /* data for cmd */
            /* density 0x81 for XA, 0 else */
            send[ 4]                = (is_xa) ?
                                    (unsigned char) 0x81 : (unsigned char) 0;
            send[10]                = (unsigned char) 0x08;
            rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
                                   SCSI_IOCTL_SEND_COMMAND, buf);
            if (rc != 0) {
                printk(KERN_WARNING "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_SONY: /* Thomas QUINOT <thomas@melchior.cuivre.fdn.fr> */
    case SCSI_MAN_PIONEER:
    case SCSI_MAN_UNKNOWN:
#ifdef DEBUG
        printk(KERN_DEBUG "sr_photocd: use SONY/PIONEER code\n");
#endif
        get_sectorsize(MINOR(inode->i_rdev));   /* spinup (avoid timeout) */
        memset(buf,0,40);
        *((unsigned int*)buf)   = 0x0;   /* we send nothing...     */
        *((unsigned int*)buf+1) = 0x0c;  /* and receive 0x0c bytes */
        cmd[0] = READ_TOC;
        cmd[8] = 0x0c;
        cmd[9] = 0x40;
        rc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
                               SCSI_IOCTL_SEND_COMMAND, buf);
 
        if (rc != 0) {
            if (rc != 0x28000002) /* drop "not ready" */
                printk(KERN_WARNING "sr_photocd: ioctl error (SONY/PIONEER): 0x%x\n",rc);
            break;
        }
        if ((rec[0] << 8) + rec[1] < 0x0a) {
            printk(KERN_INFO "sr_photocd: (SONY/PIONEER) Hmm, seems the CDROM doesn't support multisession CD's\n");
            no_multi = 1;
            break;
        }
        sector = rec[11] + (rec[10] << 8) + (rec[9] << 16) + (rec[8] << 24);
        is_xa = !!sector;
#ifdef DEBUG
        if (sector)
            printk (KERN_DEBUG "sr_photocd: multisession CD detected. start: %lu\n",sector);
#endif
        break;
 
    case SCSI_MAN_NEC_OLDCDR:
    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;
 
    if(sr_template.usage_count) (*sr_template.usage_count)++;
 
    sr_ioctl(inode,filp,CDROMCLOSETRAY,0);
    check_disk_change(inode->i_rdev);
 
    if(!scsi_CDs[MINOR(inode->i_rdev)].device->access_count++)
        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)++;
 
    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.
     */
 
    if(scsi_CDs[MINOR(inode->i_rdev)].needs_sector_size)
        get_sectorsize(MINOR(inode->i_rdev));
 
    return 0;
}
 
 
/*
 * 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;
    Scsi_Device * SDev;
    unsigned long flags;
    int flag = 0;
 
    while (1==1){
        save_flags(flags);
        cli();
        if (CURRENT != NULL && CURRENT->rq_status == RQ_INACTIVE) {
            restore_flags(flags);
            return;
        };
 
        INIT_SCSI_REQUEST;
 
        SDev = scsi_CDs[DEVICE_NR(CURRENT->rq_dev)].device;
 
        /*
         * I am not sure where the best place to do this is.  We need
         * to hook in a place where we are likely to come if in user
         * space.
         */
        if( SDev->was_reset )
        {
            /*
             * We need to relock the door, but we might
             * be in an interrupt handler.  Only do this
             * from user space, since we do not want to
             * sleep from an interrupt.
             */
            if( SDev->removable && !intr_count )
            {
                scsi_ioctl(SDev, SCSI_IOCTL_DOORLOCK, 0);
            }
            SDev->was_reset = 0;
        }
 
        if (flag++ == 0)
            SCpnt = allocate_device(&CURRENT,
                                    scsi_CDs[DEVICE_NR(CURRENT->rq_dev)].device, 0);
        else SCpnt = NULL;
        restore_flags(flags);
 
        /* This is a performance enhancement.  We dig down into the request list and
         * try to 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 to 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(req->rq_dev)].device);
                if(SCpnt) break;
                req1 = req;
                req = req->next;
            };
            if (SCpnt && req->rq_status == RQ_INACTIVE) {
                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 */
}
 
void requeue_sr_request (Scsi_Cmnd * SCpnt)
{
        unsigned int dev, block, realcount;
        unsigned char cmd[10], *buffer, tries;
        int this_count, start, end_rec;
 
        tries = 2;
 
 repeat:
        if(!SCpnt || SCpnt->request.rq_status == RQ_INACTIVE) {
                do_sr_request();
                return;
        }
 
        dev =  MINOR(SCpnt->request.rq_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
         */
                /* 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);
    }
 
        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.
     */
 
        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) {
            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) {
            if (count < SCpnt->host->sg_tablesize) {
                count++;
                end_rec = (4 - (this_count % 4)) << 9;
                this_count += 4 - (this_count % 4);
            } else {
                count--;
                this_count -= (this_count % 4);
            };
        };
        SCpnt->use_sg = count;  /* Number of chains */
        /* scsi_malloc can only allocate in chunks of 512 bytes */
        count  = (SCpnt->use_sg * sizeof(struct scatterlist) + 511) & ~511;
 
        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 {
            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++;
            };
            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 - 1 >
                    ISA_DMA_THRESHOLD && SCpnt->host->unchecked_isa_dma) {
                    sgpnt[count].alt_address = sgpnt[count].address;
                    /* We try to 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,
                   this_count,
                   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);
#endif
        };  /* 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)
            this_count = SCpnt->request.nr_sectors;
        else
            this_count = (SCpnt->request.bh->b_size >> 9);
 
        start = block % 4;
        if (start)
            {
            this_count = ((this_count > 4 - start) ?
                          (4 - start) : (this_count));
            buffer = (unsigned char *) scsi_malloc(2048);
            }
        else if (this_count < 4)
            {
            buffer = (unsigned char *) scsi_malloc(2048);
            }
        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)
                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 */
        else
        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;
                cmd[4] = (unsigned char) (block >> 8) & 0xff;
                cmd[5] = (unsigned char) block & 0xff;
                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;
    }
 
#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");
    };
#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;
 
        SCpnt->this_count = this_count;
        scsi_do_cmd (SCpnt, (void *) cmd, buffer,
                 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, 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)
    {
        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;
}
 
 
static void sr_init_done (Scsi_Cmnd * SCpnt)
{
    struct request * req;
 
    req = &SCpnt->request;
    req->rq_status = RQ_SCSI_DONE; /* Busy, but indicate request done */
 
    if (req->sem != NULL) {
        up(req->sem);
    }
}
 
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.rq_status = RQ_SCSI_BUSY;  /* Mark as really busy */
        SCpnt->cmd_len = 0;
 
        memset(buffer, 0, 8);
 
        /* Do the command and wait.. */
        {
            struct semaphore sem = MUTEX_LOCKED;
            SCpnt->request.sem = &sem;
            scsi_do_cmd (SCpnt,
                         (void *) cmd, (void *) buffer,
                         512, sr_init_done,  SR_TIMEOUT,
                         MAX_RETRIES);
            down(&sem);
        }
 
        the_result = SCpnt->result;
        retries--;
 
    } while(the_result && retries);
 
    SCpnt->request.rq_status = RQ_INACTIVE;  /* 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 = 1 + ((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];
        switch (scsi_CDs[i].sector_size) {
                /*
                 * HP 4020i CD-Recorder reports 2340 byte sectors
                 * Philips CD-Writers report 2352 byte sectors
                 *
                 * Use 2k sectors for them..
                 */
                case 0: case 2340: case 2352:
                        scsi_CDs[i].sector_size = 2048;
                        /* fall through */
                case 2048:
                        scsi_CDs[i].capacity *= 4;
                        /* fall through */
                case 512:
                        break;
                default:
                        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;
        }
        scsi_CDs[i].needs_sector_size = 0;
        sr_sizes[i] = scsi_CDs[i].capacity >> (BLOCK_SIZE_BITS - 9);
    };
    scsi_free(buffer, 512);
}
 
static int sr_registered = 0;
 
static int sr_init()
{
    int i;
 
    if(sr_template.dev_noticed == 0) return 0;
 
    if(!sr_registered) {
        if (register_blkdev(MAJOR_NR,"sr",&sr_fops)) {
            printk("Unable to get major %d for SCSI-CD\n",MAJOR_NR);
            return 1;
        }
        sr_registered++;
    }
 
 
    if (scsi_CDs) return 0;
    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);
    for(i=0;i<sr_template.dev_max;i++) sr_blocksizes[i] = 2048;
    blksize_size[MAJOR_NR] = sr_blocksizes;
    return 0;
}
 
void sr_finish()
{
    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 0
        /* 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;
        scsi_CDs[i].auto_eject = 0; /* Default is not to eject upon unmount. */
        sr_sizes[i] = scsi_CDs[i].capacity >> (BLOCK_SIZE_BITS - 9);
    }
 
 
    /* 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. */
    if(scsi_CDs[0].device && scsi_CDs[0].device->host->sg_tablesize)
        read_ahead[MAJOR_NR] = 32;  /* 32 sector read-ahead.  Always removable. */
    else
        read_ahead[MAJOR_NR] = 4;  /* 4 sector read-ahead */
 
    return;
}
 
static void sr_detach(Scsi_Device * SDp)
{
    Scsi_CD * cpnt;
    int i;
 
    for(cpnt = scsi_CDs, i=0; i<sr_template.dev_max; i++, cpnt++)
        if(cpnt->device == SDp) {
            kdev_t devi = MKDEV(MAJOR_NR, i);
 
            /*
             * Since the cdrom is read-only, no need to sync the device.
             * We should be kind to our buffer cache, however.
             */
            invalidate_inodes(devi);
            invalidate_buffers(devi);
 
            /*
             * 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
 
int init_module(void) {
    sr_template.usage_count = &mod_use_count_;
    return scsi_register_module(MODULE_SCSI_DEV, &sr_template);
}
 
void cleanup_module( void)
{
    scsi_unregister_module(MODULE_SCSI_DEV, &sr_template);
    unregister_blkdev(SCSI_CDROM_MAJOR, "sr");
    sr_registered--;
    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.
 * Emacs will notice this stuff at the end of the file and automatically
 * adjust the settings for this buffer only.  This must remain at the end
 * of the file.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-indent-level: 4
 * c-brace-imaginary-offset: 0
 * 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:
 */
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [scsi/] [sr.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1626	jcastillo	`/*`
2			`* sr.c Copyright (C) 1992 David Giller`
3			`* Copyright (C) 1993, 1994, 1995 Eric Youngdale`
4			`*`
5			`* adapted from:`
6			`* sd.c Copyright (C) 1992 Drew Eckhardt`
7			`* Linux scsi disk driver by`
8			`* Drew Eckhardt <drew@colorado.edu>`
9			`*`
10			`* Modified by Eric Youngdale ericy@cais.com to`
11			`* add scatter-gather, multiple outstanding request, and other`
12			`* enhancements.`
13			`*`
14			`* Modified by Eric Youngdale eric@aib.com to support loadable`
15			`* low-level scsi drivers.`
16			`*`
17			`* Modified by Thomas Quinot thomas@melchior.cuivre.fdn.fr to`
18			`* provide auto-eject.`
19			`*`
20			`*/`
21
22			`#include <linux/module.h>`
23
24			`#include <linux/fs.h>`
25			`#include <linux/kernel.h>`
26			`#include <linux/sched.h>`
27			`#include <linux/mm.h>`
28			`#include <linux/string.h>`
29			`#include <linux/errno.h>`
30			`#include <linux/cdrom.h>`
31			`#include <linux/interrupt.h>`
32			`#include <asm/system.h>`
33
34			`#define MAJOR_NR SCSI_CDROM_MAJOR`
35			`#include <linux/blk.h>`
36			`#include "scsi.h"`
37			`#include "hosts.h"`
38			`#include "sr.h"`
39			`#include <scsi/scsi_ioctl.h> /* For the door lock/unlock commands */`
40			`#include "constants.h"`