ide-cd.c

ep9315平台下硬盘驱动的源码

			s = buf;
		} else {
			int lo = 0, mid, hi = ARY_LEN(sense_data_texts);
			unsigned long key = (sense->sense_key << 16);
			key |= (sense->asc << 8);
			if (!(sense->ascq >= 0x80 && sense->ascq <= 0xdd))
				key |= sense->ascq;
			s = NULL;

			while (hi > lo) {
				mid = (lo + hi) / 2;
				if (sense_data_texts[mid].asc_ascq == key ||
				    sense_data_texts[mid].asc_ascq == (0xff0000|key)) {
					s = sense_data_texts[mid].text;
					break;
				}
				else if (sense_data_texts[mid].asc_ascq > key)
					hi = mid;
				else
					lo = mid+1;
			}
		}

		if (s == NULL) {
			if (sense->asc > 0x80)
				s = "(vendor-specific error)";
			else
				s = "(reserved error code)";
		}

		printk("  %s -- (asc=0x%02x, ascq=0x%02x)\n",
			s, sense->asc, sense->ascq);

		if (failed_command != NULL) {

			int lo=0, mid, hi= ARY_LEN (packet_command_texts);
			s = NULL;

			while (hi > lo) {
				mid = (lo + hi) / 2;
				if (packet_command_texts[mid].packet_command ==
				    failed_command->c[0]) {
					s = packet_command_texts[mid].text;
					break;
				}
				if (packet_command_texts[mid].packet_command >
				    failed_command->c[0])
					hi = mid;
				else
					lo = mid+1;
			}

			printk ("  The failed \"%s\" packet command was: \n  \"", s);
			for (i=0; i<sizeof (failed_command->c); i++)
				printk ("%02x ", failed_command->c[i]);
			printk ("\"\n");
		}

		/* The SKSV bit specifies validity of the sense_key_specific
		 * in the next two commands. It is bit 7 of the first byte.
		 * In the case of NOT_READY, if SKSV is set the drive can
		 * give us nice ETA readings.
		 */
		if (sense->sense_key == NOT_READY && (sense->sks[0] & 0x80)) {
			int progress = (sense->sks[1] << 8 | sense->sks[2]) * 100;
			printk("  Command is %02d%% complete\n", progress / 0xffff);

		}

		if (sense->sense_key == ILLEGAL_REQUEST &&
		    (sense->sks[0] & 0x80) != 0) {
			printk("  Error in %s byte %d",
				(sense->sks[0] & 0x40) != 0 ?
				"command packet" : "command data",
				(sense->sks[1] << 8) + sense->sks[2]);

			if ((sense->sks[0] & 0x40) != 0)
				printk (" bit %d", sense->sks[0] & 0x07);

			printk ("\n");
		}
	}

#else /* not VERBOSE_IDE_CD_ERRORS */

	/* Suppress printing unit attention and `in progress of becoming ready'
	   errors when we're not being verbose. */

	if (sense->sense_key == UNIT_ATTENTION ||
	    (sense->sense_key == NOT_READY && (sense->asc == 4 ||
						sense->asc == 0x3a)))
		return;

	printk("%s: error code: 0x%02x  sense_key: 0x%02x  asc: 0x%02x  ascq: 0x%02x\n",
		drive->name,
		sense->error_code, sense->sense_key,
		sense->asc, sense->ascq);
#endif /* not VERBOSE_IDE_CD_ERRORS */
}

static void cdrom_queue_request_sense(ide_drive_t *drive, 
				      struct completion *wait,
				      struct request_sense *sense,
				      struct packet_command *failed_command)
{
	struct cdrom_info *info		= drive->driver_data;
	struct packet_command *pc	= &info->request_sense_pc;
	struct request *rq;

	if (sense == NULL)
		sense = &info->sense_data;

	memset(pc, 0, sizeof(struct packet_command));
	pc->c[0] = GPCMD_REQUEST_SENSE;
	pc->c[4] = pc->buflen = 18;
	pc->buffer = (char *) sense;
	pc->sense = (struct request_sense *) failed_command;

	/* stuff the sense request in front of our current request */
	rq = &info->request_sense_request;
	ide_init_drive_cmd(rq);
	rq->cmd = REQUEST_SENSE_COMMAND;
	rq->buffer = (char *) pc;
	rq->waiting = wait;
	(void) ide_do_drive_cmd(drive, rq, ide_preempt);
}


/*
 * This is our end_request replacement function.
 */
static int ide_cdrom_end_request (ide_drive_t *drive, int uptodate)
{
	struct request *rq;
	unsigned long flags;
	int ret = 1;

	spin_lock_irqsave(&io_request_lock, flags);
	rq = HWGROUP(drive)->rq;

	/*
	 * decide whether to reenable DMA -- 3 is a random magic for now,
	 * if we DMA timeout more than 3 times, just stay in PIO
	 */
	if (drive->state == DMA_PIO_RETRY && drive->retry_pio <= 3) {
		drive->state = 0;
		HWGROUP(drive)->hwif->ide_dma_on(drive);
	}

	if (!end_that_request_first(rq, uptodate, drive->name)) {
		add_blkdev_randomness(MAJOR(rq->rq_dev));
		blkdev_dequeue_request(rq);
		HWGROUP(drive)->rq = NULL;
		end_that_request_last(rq);
		ret = 0;
	}
	spin_unlock_irqrestore(&io_request_lock, flags);
	return ret;
}

/*
 * Error reporting, in human readable form (luxurious, but a memory hog).
 */
byte ide_cdrom_dump_status (ide_drive_t *drive, const char *msg, byte stat)
{
	unsigned long flags;

	atapi_status_t status;
	atapi_error_t error;

	status.all = stat;
	local_irq_set(flags);
	printk("%s: %s: status=0x%02x", drive->name, msg, stat);
#if FANCY_STATUS_DUMPS
	printk(" { ");
	if (status.b.bsy)
		printk("Busy ");
	else {
		if (status.b.drdy)	printk("DriveReady ");
		if (status.b.df)	printk("DeviceFault ");
		if (status.b.dsc)	printk("SeekComplete ");
		if (status.b.drq)	printk("DataRequest ");
		if (status.b.corr)	printk("CorrectedError ");
		if (status.b.idx)	printk("Index ");
		if (status.b.check)	printk("Error ");
	}
	printk("}");
#endif	/* FANCY_STATUS_DUMPS */
	printk("\n");
	if ((status.all & (status.b.bsy|status.b.check)) == status.b.check) {
		error.all = HWIF(drive)->INB(IDE_ERROR_REG);
		printk("%s: %s: error=0x%02x", drive->name, msg, error.all);
#if FANCY_STATUS_DUMPS
		if (error.b.ili)	printk("IllegalLengthIndication ");
		if (error.b.eom)	printk("EndOfMedia ");
		if (error.b.abrt)	printk("Aborted Command ");
		if (error.b.mcr)	printk("MediaChangeRequested ");
		if (error.b.sense_key)	printk("LastFailedSense 0x%02x ",
						error.b.sense_key);
#endif	/* FANCY_STATUS_DUMPS */
		printk("\n");
	}
	local_irq_restore(flags);
	return error.all;
}

/*
 * ide_error() takes action based on the error returned by the drive.
 */
ide_startstop_t ide_cdrom_error (ide_drive_t *drive, const char *msg, byte stat)
{
	struct request *rq;
	byte err;

	err = ide_cdrom_dump_status(drive, msg, stat);
	if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
		return ide_stopped;
	/* retry only "normal" I/O: */
	if (rq->cmd == IDE_DRIVE_CMD || rq->cmd == IDE_DRIVE_TASK) {
		rq->errors = 1;
		ide_end_drive_cmd(drive, stat, err);
		return ide_stopped;
	}

	if (stat & BUSY_STAT || ((stat & WRERR_STAT) && !drive->nowerr)) {
		/* other bits are useless when BUSY */
		rq->errors |= ERROR_RESET;
	} else {
		/* add decoding error stuff */
	}
	if (HWIF(drive)->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT))
		/* force an abort */
		HWIF(drive)->OUTB(WIN_IDLEIMMEDIATE,IDE_COMMAND_REG);
	if (rq->errors >= ERROR_MAX) {
		DRIVER(drive)->end_request(drive, 0);
	} else {
		if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
			++rq->errors;
			return ide_do_reset(drive);
		}
		++rq->errors;
	}
	return ide_stopped;
}

ide_startstop_t ide_cdrom_abort (ide_drive_t *drive, const char *msg)
{
	struct request *rq;

	if (drive == NULL || (rq = HWGROUP(drive)->rq) == NULL)
		return ide_stopped;
	/* retry only "normal" I/O: */
	if (rq->cmd == IDE_DRIVE_CMD || rq->cmd == IDE_DRIVE_TASK) {
		rq->errors = 1;
		ide_end_drive_cmd(drive, BUSY_STAT, 0);
		return ide_stopped;
	}
	rq->errors |= ERROR_RESET;
	DRIVER(drive)->end_request(drive, 0);
	return ide_stopped;
}

static void cdrom_end_request (ide_drive_t *drive, int uptodate)
{
	struct request *rq = HWGROUP(drive)->rq;

	if (rq->cmd == REQUEST_SENSE_COMMAND && uptodate) {
		struct packet_command *pc = (struct packet_command *) rq->buffer;
		cdrom_analyze_sense_data(drive,
			(struct packet_command *) pc->sense,
			(struct request_sense *) (pc->buffer - pc->c[4]));
	}
	if (blk_fs_request(rq) && !rq->current_nr_sectors)
		uptodate = 1;

	ide_cdrom_end_request(drive, uptodate);
}


/* Returns 0 if the request should be continued.
   Returns 1 if the request was ended. */
static int cdrom_decode_status (ide_startstop_t *startstop, ide_drive_t *drive,
				int good_stat, int *stat_ret)
{
	struct request *rq = HWGROUP(drive)->rq;
	int stat, err, sense_key;
	struct packet_command *pc;
	
	/* Check for errors. */
	*stat_ret = stat = HWIF(drive)->INB(IDE_STATUS_REG);

	if (OK_STAT (stat, good_stat, BAD_R_STAT))
		return 0;

	/* Get the IDE error register. */
	err = HWIF(drive)->INB(IDE_ERROR_REG);
	sense_key = err >> 4;

	if (rq == NULL) {
		printk("%s: missing rq in cdrom_decode_status\n", drive->name);
		*startstop = ide_stopped;
		return 1;
	}

	if (rq->cmd == REQUEST_SENSE_COMMAND) {
		/* We got an error trying to get sense info
		   from the drive (probably while trying
		   to recover from a former error).  Just give up. */

		pc = (struct packet_command *) rq->buffer;
		pc->stat = 1;
		cdrom_end_request(drive, 1);
		*startstop = DRIVER(drive)->error(drive, "request sense failure", stat);
		return 1;

	} else if (rq->cmd == PACKET_COMMAND) {
		/* All other functions, except for READ. */
		struct completion *wait = NULL;
		pc = (struct packet_command *) rq->buffer;

		/* Check for tray open. */
		if (sense_key == NOT_READY) {
			cdrom_saw_media_change (drive);
		} else if (sense_key == UNIT_ATTENTION) {
			/* Check for media change. */
			cdrom_saw_media_change (drive);
			/*printk("%s: media changed\n",drive->name);*/
			return 0;
		} else if (!pc->quiet) {
			/* Otherwise, print an error. */
			ide_dump_status(drive, "packet command error", stat);
		}
		
		/* Set the error flag and complete the request.
		   Then, if we have a CHECK CONDITION status,
		   queue a request sense command.  We must be careful,
		   though: we don't want the thread in
		   cdrom_queue_packet_command to wake up until
		   the request sense has completed.  We do this
		   by transferring the semaphore from the packet
		   command request to the request sense request. */

		if ((stat & ERR_STAT) != 0) {
			wait = rq->waiting;
			rq->waiting = NULL;
		}

		pc->stat = 1;
		cdrom_end_request(drive, 1);

		if ((stat & ERR_STAT) != 0)
			cdrom_queue_request_sense(drive, wait, pc->sense, pc);
	} else if (blk_fs_request(rq)) {
		/* Handle errors from READ and WRITE requests. */
	  int do_end_request = 0;

		if (sense_key == NOT_READY) {
			/* Tray open. */
			cdrom_saw_media_change (drive);

			/* Fail the request. */
			printk ("%s: tray open\n", drive->name);
			//cdrom_end_request(drive, 0);
                        do_end_request = 1;
		} else if (sense_key == UNIT_ATTENTION) {
			/* Media change. */
			cdrom_saw_media_change (drive);

			/* Arrange to retry the request.
			   But be sure to give up if we've retried
			   too many times. */
			if (++rq->errors > ERROR_MAX)
			  //cdrom_end_request(drive, 0);
                          do_end_request = 1;
		} else if (sense_key == ILLEGAL_REQUEST ||
			   sense_key == DATA_PROTECT) {
			/* No point in retrying after an illegal
			   request or data protect error.*/
			ide_dump_status (drive, "command error", stat);
			//cdrom_end_request(drive, 0);
                        do_end_request = 1;
		} else if (sense_key == MEDIUM_ERROR) {
		  /* No point in re-trying a zillion times on a bad sector...
                   * If we got here the error is not correctable.
                   */ 
		  ide_dump_status (drive, "media error (bad sector)", stat);
                  do_end_request = 1;

		} else if ((err & ~ABRT_ERR) != 0) {
			/* Go to the default handler
			   for other errors. */
			*startstop = DRIVER(drive)->error(drive, "cdrom_decode_status", stat);
			return 1;
		} else if ((++rq->errors > ERROR_MAX)) {
			/* We've racked up too many retries.  Abort. */
			//cdrom_end_request(drive, 0);
		  do_end_request = 1;
		}

                if(do_end_request)
		  cdrom_end_request(drive, 0);

		/* If we got a CHECK_CONDITION status,
		   queue a request sense command. */
		if ((stat & ERR_STAT) != 0)
			cdrom_queue_request_sense(drive, NULL, NULL, NULL);
	}

	/* Retry, or handle the next request. */
	*startstop = ide_stopped;
	return 1;
}

static int cdrom_timer_expiry(ide_drive_t *drive)