sr.c

LINUX1.0内核源代码,学习LINUX编程的一定要看。

/*
 *      sr.c by David Giller
 *
 *      adapted from:
 *	sd.c Copyright (C) 1992 Drew Eckhardt 
 *	Linux scsi disk driver by
 *		Drew Eckhardt 
 *
 *	<[e-mail]>
 *
 *       Modified by Eric Youngdale [e-mail] to
 *       add scatter-gather, multiple outstanding request, and other
 *       enhancements.
 */

#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <asm/system.h>

#define MAJOR_NR SCSI_CDROM_MAJOR
#include "../block/blk.h"
#include "scsi.h"
#include "hosts.h"
#include "sr.h"
#include "scsi_ioctl.h"   /* For the door lock/unlock commands */
#include "constants.h"

#define MAX_RETRIES 1
#define SR_TIMEOUT 500

int NR_SR=0;
int MAX_SR=0;
Scsi_CD * scsi_CDs;
static int * sr_sizes;

static int * sr_blocksizes;

static int sr_open(struct inode *, struct file *);
static void get_sectorsize(int);

extern int sr_ioctl(struct inode *, struct file *, unsigned int, unsigned long);

void requeue_sr_request (Scsi_Cmnd * SCpnt);

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);
}

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,       		/* no special open code */
	sr_release,		/* release */
	NULL			/* fsync */
};

/*
 * 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(int full_dev, int flag){
	int retval, target;
	struct inode inode;

	target =  MINOR(full_dev);

	if (target >= NR_SR) {
		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;

#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) {
		    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 {
		    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) this_count -= 2;
/* 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;
		  };

#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);
			}

		  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. */
	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.dev)].device->changed = 1;
				end_scsi_request(SCpnt, 0, this_count);
			        requeue_sr_request(SCpnt);
				return;
			}
		}
	    
		if (SCpnt->sense_buffer[2] == ILLEGAL_REQUEST) {
			printk("CD-ROM error: Drive reports ILLEGAL REQUEST.\n");
			if (scsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten) {
				scsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten = 0;
				requeue_sr_request(SCpnt);
				result = 0;
				return;
			} else {
			  printk("CD-ROM error: Drive reports %d.\n", SCpnt->sense_buffer[2]);				
			  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");
			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);
	    
	  if (status_byte(result) == CHECK_CONDITION)
		  print_sense("sr", SCpnt);
	  
	  end_scsi_request(SCpnt, 0, SCpnt->request.current_nr_sectors);
	  requeue_sr_request(SCpnt);
  }
}

static int sr_open(struct inode * inode, struct file * filp)
{
	if(MINOR(inode->i_rdev) >= NR_SR || 
	   !scsi_CDs[MINOR(inode->i_rdev)].device) return -ENODEV;   /* No such device */

        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 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;
  int flag = 0;

  while (1==1){
    cli();
    if (CURRENT != NULL && CURRENT->dev == -1) {
      sti();
      return;
    };

    INIT_SCSI_REQUEST;

    if (flag++ == 0)
      SCpnt = allocate_device(&CURRENT,
			      scsi_CDs[DEVICE_NR(MINOR(CURRENT->dev))].device->index, 0); 
    else SCpnt = NULL;
    sti();

/* 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 inbetween somewhere. */

    if (!SCpnt && NR_SR > 1){
      struct request *req1;
      req1 = NULL;
      cli();
      req = CURRENT;
      while(req){
	SCpnt = request_queueable(req,
				  scsi_CDs[DEVICE_NR(MINOR(req->dev))].device->index);
	if(SCpnt) break;
	req1 = req;
	req = req->next;
      };
      if (SCpnt && req->dev == -1) {
	if (req == CURRENT) 
	  CURRENT = CURRENT->next;
	else
	  req1->next = req->next;
      };
      sti();
    };
    
    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->request.dev <= 0) {
	  do_sr_request();
	  return;
	}

	dev =  MINOR(SCpnt->request.dev);
	block = SCpnt->request.sector;	
	buffer = NULL;
	this_count = 0;

	if (dev >= NR_SR)
		{
		/* printk("CD-ROM request error: invalid device.\n");			*/
		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");		*/
		end_scsi_request(SCpnt, 0, SCpnt->request.nr_sectors);