ide-cd.c

ep9315平台下硬盘驱动的源码

{
	struct packet_command pc;
	struct request *rq = HWGROUP(drive)->rq;
	int nsect, sector, nframes, frame, nskip;

	/* Number of sectors to transfer. */
	nsect = rq->nr_sectors;

	/* Starting sector. */
	sector = rq->sector;

	/* If the requested sector doesn't start on a cdrom block boundary,
	   we must adjust the start of the transfer so that it does,
	   and remember to skip the first few sectors.
	   If the CURRENT_NR_SECTORS field is larger than the size
	   of the buffer, it will mean that we're to skip a number
	   of sectors equal to the amount by which CURRENT_NR_SECTORS
	   is larger than the buffer size. */
	nskip = (sector % SECTORS_PER_FRAME);
	if (nskip > 0) {
		/* Sanity check... */
		if (rq->current_nr_sectors != (rq->bh->b_size >> SECTOR_BITS) &&
			(rq->sector % CD_FRAMESIZE != 0)) {
			printk ("%s: cdrom_start_read_continuation: buffer botch (%lu)\n",
				drive->name, rq->current_nr_sectors);
			cdrom_end_request(drive, 0);
			return ide_stopped;
		}
		sector -= nskip;
		nsect += nskip;
		rq->current_nr_sectors += nskip;
	}

	/* Convert from sectors to cdrom blocks, rounding up the transfer
	   length if needed. */
	nframes = (nsect + SECTORS_PER_FRAME-1) / SECTORS_PER_FRAME;
	frame = sector / SECTORS_PER_FRAME;

	/* Largest number of frames was can transfer at once is 64k-1. For
	   some drives we need to limit this even more. */
	nframes = MIN (nframes, (CDROM_CONFIG_FLAGS (drive)->limit_nframes) ?
		(65534 / CD_FRAMESIZE) : 65535);

	/* Set up the command */
	memset (&pc.c, 0, sizeof (pc.c));
	pc.c[0] = GPCMD_READ_10;
	pc.c[7] = (nframes >> 8);
	pc.c[8] = (nframes & 0xff);
	put_unaligned(cpu_to_be32(frame), (unsigned int *) &pc.c[2]);
	pc.timeout = WAIT_CMD;

	/* Send the command to the drive and return. */
	return cdrom_transfer_packet_command(drive, &pc, &cdrom_read_intr);
}


#define IDECD_SEEK_THRESHOLD	(1000)			/* 1000 blocks */
#define IDECD_SEEK_TIMER	(5 * WAIT_MIN_SLEEP)	/* 100 ms */
#define IDECD_SEEK_TIMEOUT     WAIT_CMD			/* 10 sec */

static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
{
	struct cdrom_info *info = drive->driver_data;
	int stat;
	static int retry = 10;
	ide_startstop_t startstop;

	if (cdrom_decode_status (&startstop, drive, 0, &stat))
		return startstop;
	CDROM_CONFIG_FLAGS(drive)->seeking = 1;

	if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
		if (--retry == 0) {
			/*
			 * this condition is far too common, to bother
			 * users about it
			 */
#if 0
			printk("%s: disabled DSC seek overlap\n", drive->name);
#endif
			drive->dsc_overlap = 0;
		}
	}
	return ide_stopped;
}

static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
{
	struct packet_command pc;
	struct request *rq = HWGROUP(drive)->rq;
	int sector, frame, nskip;

	sector = rq->sector;
	nskip = (sector % SECTORS_PER_FRAME);
	if (nskip > 0)
		sector -= nskip;
	frame = sector / SECTORS_PER_FRAME;

	memset (&pc.c, 0, sizeof (pc.c));
	pc.c[0] = GPCMD_SEEK;
	put_unaligned(cpu_to_be32(frame), (unsigned int *) &pc.c[2]);

	pc.timeout = WAIT_CMD;
	return cdrom_transfer_packet_command(drive, &pc, &cdrom_seek_intr);
}

static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
{
	struct cdrom_info *info = drive->driver_data;

	info->dma = 0;
	info->cmd = 0;
	info->start_seek = jiffies;
	return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
}

static inline int cdrom_merge_requests(struct request *rq, struct request *nxt)
{
	int ret = 1;

	/*
	 * partitions not really working, but better check anyway...
	 */
	if (rq->cmd == nxt->cmd && rq->rq_dev == nxt->rq_dev) {
		rq->nr_sectors += nxt->nr_sectors;
		rq->hard_nr_sectors += nxt->nr_sectors;
		rq->bhtail->b_reqnext = nxt->bh;
		rq->bhtail = nxt->bhtail;
		list_del(&nxt->queue);
		blkdev_release_request(nxt);
		ret = 0;
	}

	return ret;
}

/*
 * the current request will always be the first one on the list
 */
static void cdrom_attempt_remerge(ide_drive_t *drive, struct request *rq)
{
	struct list_head *entry;
	struct request *nxt;
	unsigned long flags;

	spin_lock_irqsave(&io_request_lock, flags);

	while (1) {
		entry = rq->queue.next;
		if (entry == &drive->queue.queue_head)
			break;

		nxt = blkdev_entry_to_request(entry);
		if (rq->sector + rq->nr_sectors != nxt->sector)
			break;
		else if (rq->nr_sectors + nxt->nr_sectors > SECTORS_MAX)
			break;

		if (cdrom_merge_requests(rq, nxt))
			break;
	}

	spin_unlock_irqrestore(&io_request_lock, flags);
}

/* Fix up a possibly partially-processed request so that we can
   start it over entirely, or even put it back on the request queue. */
static void restore_request (struct request *rq)
{
	if (rq->buffer != rq->bh->b_data) {
		int n = (rq->buffer - rq->bh->b_data) / SECTOR_SIZE;
		rq->buffer = rq->bh->b_data;
		rq->nr_sectors += n;
		rq->sector -= n;
	}
	rq->current_nr_sectors = rq->bh->b_size >> SECTOR_BITS;
	rq->hard_nr_sectors = rq->nr_sectors;
	rq->hard_sector = rq->sector;
}

/*
 * Start a read request from the CD-ROM.
 */
static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
{
	struct cdrom_info *info = drive->driver_data;
	struct request *rq = HWGROUP(drive)->rq;
	int minor = MINOR(rq->rq_dev);

	/* If the request is relative to a partition, fix it up to refer to the
	   absolute address.  */
	if (minor & PARTN_MASK) {
		rq->sector = block;
		minor &= ~PARTN_MASK;
		rq->rq_dev = MKDEV(MAJOR(rq->rq_dev), minor);
	}

	/* We may be retrying this request after an error.  Fix up
	   any weirdness which might be present in the request packet. */
	restore_request(rq);

	/* Satisfy whatever we can of this request from our cached sector. */
	if (cdrom_read_from_buffer(drive))
		return ide_stopped;

	cdrom_attempt_remerge(drive, rq);

	/* Clear the local sector buffer. */
	info->nsectors_buffered = 0;

	/* use dma, if possible. */
	if (drive->using_dma && (rq->sector % SECTORS_PER_FRAME == 0) &&
				(rq->nr_sectors % SECTORS_PER_FRAME == 0))
		info->dma = 1;
	else
		info->dma = 0;

	info->cmd = READ;
	/* Start sending the read request to the drive. */
	return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
}

/****************************************************************************
 * Execute all other packet commands.
 */

/* Forward declarations. */
static int cdrom_lockdoor(ide_drive_t *drive, int lockflag,
			  struct request_sense *sense);

/* Interrupt routine for packet command completion. */
static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
{
	int ireason, len, stat, thislen;
	struct request *rq = HWGROUP(drive)->rq;
	struct packet_command *pc = (struct packet_command *)rq->buffer;
	ide_startstop_t startstop;
	u8 lowcyl = 0, highcyl = 0;

	/* Check for errors. */
	if (cdrom_decode_status(&startstop, drive, 0, &stat))
		return startstop;

	/* Read the interrupt reason and the transfer length. */
	ireason = HWIF(drive)->INB(IDE_IREASON_REG);
	lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
	highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);

	len = lowcyl + (256 * highcyl);

	/* If DRQ is clear, the command has completed.
	   Complain if we still have data left to transfer. */
	if ((stat & DRQ_STAT) == 0) {
		/* Some of the trailing request sense fields are optional, and
		   some drives don't send them.  Sigh. */
		if (pc->c[0] == GPCMD_REQUEST_SENSE &&
		    pc->buflen > 0 &&
		    pc->buflen <= 5) {
			while (pc->buflen > 0) {
				*pc->buffer++ = 0;
				--pc->buflen;
			}
		}

		if (pc->buflen == 0)
			cdrom_end_request(drive, 1);
		else {
			/* Comment this out, because this always happens 
			   right after a reset occurs, and it is annoying to 
			   always print expected stuff.  */
			/*
			printk ("%s: cdrom_pc_intr: data underrun %d\n",
				drive->name, pc->buflen);
			*/
			pc->stat = 1;
			cdrom_end_request(drive, 1);
		}
		return ide_stopped;
	}

	/* Figure out how much data to transfer. */
	thislen = pc->buflen;
	if (thislen > len) thislen = len;

	/* The drive wants to be written to. */
	if ((ireason & 3) == 0) {
		/* Transfer the data. */
		HWIF(drive)->atapi_output_bytes(drive, pc->buffer, thislen);

		/* If we haven't moved enough data to satisfy the drive,
		   add some padding. */
		while (len > thislen) {
			int dum = 0;
			HWIF(drive)->atapi_output_bytes(drive, &dum, sizeof(dum));
			len -= sizeof(dum);
		}

		/* Keep count of how much data we've moved. */
		pc->buffer += thislen;
		pc->buflen -= thislen;
	}

	/* Same drill for reading. */
	else if ((ireason & 3) == 2) {

		/* Transfer the data. */
		HWIF(drive)->atapi_input_bytes(drive, pc->buffer, thislen);

		/* If we haven't moved enough data to satisfy the drive,
		   add some padding. */
		while (len > thislen) {
			int dum = 0;
			HWIF(drive)->atapi_input_bytes(drive, &dum, sizeof(dum));
			len -= sizeof(dum);
		}

		/* Keep count of how much data we've moved. */
		pc->buffer += thislen;
		pc->buflen -= thislen;
	} else {
		printk ("%s: cdrom_pc_intr: The drive "
			"appears confused (ireason = 0x%2x)\n",
			drive->name, ireason);
		pc->stat = 1;
	}

	/* Now we wait for another interrupt. */
	ide_set_handler(drive, &cdrom_pc_intr, WAIT_CMD, cdrom_timer_expiry);
	return ide_started;
}


static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
{
	struct request *rq = HWGROUP(drive)->rq;
	struct packet_command *pc = (struct packet_command *)rq->buffer;

	if (!pc->timeout)
		pc->timeout = WAIT_CMD;

	/* Send the command to the drive and return. */
	return cdrom_transfer_packet_command(drive, pc, &cdrom_pc_intr);
}


static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
{
	int len;
	struct request *rq = HWGROUP(drive)->rq;
	struct packet_command *pc = (struct packet_command *)rq->buffer;
	struct cdrom_info *info = drive->driver_data;

	info->dma = 0;
	info->cmd = 0;
	pc->stat = 0;
	len = pc->buflen;

	/* Start sending the command to the drive. */
	return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
}


/* Sleep for TIME jiffies.
   Not to be called from an interrupt handler. */
static
void cdrom_sleep (int time)
{
	int sleep = time;

	do {
		set_current_state(TASK_INTERRUPTIBLE);
		sleep = schedule_timeout(sleep);
	} while (sleep);
}

static
int cdrom_queue_packet_command(ide_drive_t *drive, struct packet_command *pc)
{
	struct request_sense sense;
	struct request req;
	int retries = 10;

	if (pc->sense == NULL)
		pc->sense = &sense;

	/* Start of retry loop. */
	do {
		ide_init_drive_cmd (&req);
		req.cmd = PACKET_COMMAND;
		req.buffer = (char *)pc;
		ide_do_drive_cmd(drive, &req, ide_wait);
		/* FIXME: we should probably abort/retry or something 
		 * in case of failure */
		if (pc->stat != 0) {
			/* The request failed.  Retry if it was due to a unit
			   attention status
			   (usually means media was changed). */
			struct request_sense *reqbuf = pc->sense;

			if (reqbuf->sense_key == UNIT_ATTENTION)
				cdrom_saw_media_change(drive);
			else if (reqbuf->sense_key == NOT_READY &&
				 reqbuf->asc == 4 && reqbuf->ascq != 4) {
				/* The drive is in the process of loading
				   a disk.  Retry, but wait a little to give
				   the drive time to complete the load. */
				cdrom_sleep(2 * HZ);
			} else {
				/* Otherwise, don't retry. */
				retries = 0;
			}
			--retries;
		}