Merge branch 'for-2.6.31' of git://git.kernel.org/pub/scm/linux/kernel/git/bart/ide-2.6 (27951daa) · Commits · 戴 / test

block/blk-core.c

+7 −3

Original line number	Diff line number	Diff line
		@@ -1732,10 +1732,14 @@ static int __end_that_request_first(struct request *req, int error,
		trace_block_rq_complete(req->q, req);

		/*
		* for a REQ_TYPE_BLOCK_PC request, we want to carry any eventual
		* sense key with us all the way through
		* For fs requests, rq is just carrier of independent bio's
		* and each partial completion should be handled separately.
		* Reset per-request error on each partial completion.
		*
		* TODO: tj: This is too subtle. It would be better to let
		* low level drivers do what they see fit.
		*/
		if (!blk_pc_request(req))
		if (blk_fs_request(req))
		req->errors = 0;

		if (error && (blk_fs_request(req) && !(req->cmd_flags & REQ_QUIET))) {

drivers/ide/alim15x3.c

+3 −7

Original line number	Diff line number	Diff line
		@@ -402,27 +402,23 @@ static u8 ali_cable_detect(ide_hwif_t *hwif)
		return cbl;
		}

		#if !defined(CONFIG_SPARC64) && !defined(CONFIG_PPC)
		#ifndef CONFIG_SPARC64
		/**
		* init_hwif_ali15x3 - Initialize the ALI IDE x86 stuff
		* @hwif: interface to configure
		*
		* Obtain the IRQ tables for an ALi based IDE solution on the PC
		* class platforms. This part of the code isn't applicable to the
		* Sparc and PowerPC systems.
		* Sparc systems.
		*/

		static void __devinit init_hwif_ali15x3 (ide_hwif_t *hwif)
		{
		struct pci_dev *dev = to_pci_dev(hwif->dev);
		u8 ideic, inmir;
		s8 irq_routing_table[] = { -1, 9, 3, 10, 4, 5, 7, 6,
		1, 11, 0, 12, 0, 14, 0, 15 };
		int irq = -1;

		if (dev->device == PCI_DEVICE_ID_AL_M5229)
		hwif->irq = hwif->channel ? 15 : 14;

		if (isa_dev) {
		/*
		* read IDE interface control
		@@ -455,7 +451,7 @@ static void __devinit init_hwif_ali15x3 (ide_hwif_t *hwif)
		}
		#else
		#define init_hwif_ali15x3 NULL
		#endif /* !defined(CONFIG_SPARC64) && !defined(CONFIG_PPC) */
		#endif /* CONFIG_SPARC64 */

		/**
		* init_dma_ali15x3 - set up DMA on ALi15x3

drivers/ide/ide-atapi.c

+105 −63

Original line number	Diff line number	Diff line
		@@ -79,34 +79,6 @@ void ide_init_pc(struct ide_atapi_pc *pc)
		}
		EXPORT_SYMBOL_GPL(ide_init_pc);

		/*
		* Generate a new packet command request in front of the request queue, before
		* the current request, so that it will be processed immediately, on the next
		* pass through the driver.
		*/
		static void ide_queue_pc_head(ide_drive_t drive, struct gendisk disk,
		struct ide_atapi_pc pc, struct request rq)
		{
		blk_rq_init(NULL, rq);
		rq->cmd_type = REQ_TYPE_SPECIAL;
		rq->cmd_flags \|= REQ_PREEMPT;
		rq->buffer = (char *)pc;
		rq->rq_disk = disk;

		if (pc->req_xfer) {
		rq->data = pc->buf;
		rq->data_len = pc->req_xfer;
		}

		memcpy(rq->cmd, pc->c, 12);
		if (drive->media == ide_tape)
		rq->cmd[13] = REQ_IDETAPE_PC1;

		drive->hwif->rq = NULL;

		elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0);
		}

		/*
		* Add a special packet command request to the tail of the request queue,
		* and wait for it to be serviced.
		@@ -119,19 +91,21 @@ int ide_queue_pc_tail(ide_drive_t drive, struct gendisk disk,

		rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
		rq->cmd_type = REQ_TYPE_SPECIAL;
		rq->buffer = (char *)pc;
		rq->special = (char *)pc;

		if (pc->req_xfer) {
		rq->data = pc->buf;
		rq->data_len = pc->req_xfer;
		error = blk_rq_map_kern(drive->queue, rq, pc->buf, pc->req_xfer,
		GFP_NOIO);
		if (error)
		goto put_req;
		}

		memcpy(rq->cmd, pc->c, 12);
		if (drive->media == ide_tape)
		rq->cmd[13] = REQ_IDETAPE_PC1;
		error = blk_execute_rq(drive->queue, disk, rq, 0);
		put_req:
		blk_put_request(rq);

		return error;
		}
		EXPORT_SYMBOL_GPL(ide_queue_pc_tail);
		@@ -191,20 +165,103 @@ void ide_create_request_sense_cmd(ide_drive_t drive, struct ide_atapi_pc pc)
		}
		EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);

		void ide_prep_sense(ide_drive_t drive, struct request rq)
		{
		struct request_sense *sense = &drive->sense_data;
		struct request *sense_rq = &drive->sense_rq;
		unsigned int cmd_len, sense_len;
		int err;

		debug_log("%s: enter\n", __func__);

		switch (drive->media) {
		case ide_floppy:
		cmd_len = 255;
		sense_len = 18;
		break;
		case ide_tape:
		cmd_len = 20;
		sense_len = 20;
		break;
		default:
		cmd_len = 18;
		sense_len = 18;
		}

		BUG_ON(sense_len > sizeof(*sense));

		if (blk_sense_request(rq) \|\| drive->sense_rq_armed)
		return;

		memset(sense, 0, sizeof(*sense));

		blk_rq_init(rq->q, sense_rq);

		err = blk_rq_map_kern(drive->queue, sense_rq, sense, sense_len,
		GFP_NOIO);
		if (unlikely(err)) {
		if (printk_ratelimit())
		printk(KERN_WARNING "%s: failed to map sense buffer\n",
		drive->name);
		return;
		}

		sense_rq->rq_disk = rq->rq_disk;
		sense_rq->cmd[0] = GPCMD_REQUEST_SENSE;
		sense_rq->cmd[4] = cmd_len;
		sense_rq->cmd_type = REQ_TYPE_SENSE;
		sense_rq->cmd_flags \|= REQ_PREEMPT;

		if (drive->media == ide_tape)
		sense_rq->cmd[13] = REQ_IDETAPE_PC1;

		drive->sense_rq_armed = true;
		}
		EXPORT_SYMBOL_GPL(ide_prep_sense);

		int ide_queue_sense_rq(ide_drive_t drive, void special)
		{
		/* deferred failure from ide_prep_sense() */
		if (!drive->sense_rq_armed) {
		printk(KERN_WARNING "%s: failed queue sense request\n",
		drive->name);
		return -ENOMEM;
		}

		drive->sense_rq.special = special;
		drive->sense_rq_armed = false;

		drive->hwif->rq = NULL;

		elv_add_request(drive->queue, &drive->sense_rq,
		ELEVATOR_INSERT_FRONT, 0);
		return 0;
		}
		EXPORT_SYMBOL_GPL(ide_queue_sense_rq);

		/*
		* Called when an error was detected during the last packet command.
		* We queue a request sense packet command in the head of the request list.
		* We queue a request sense packet command at the head of the request
		* queue.
		*/
		void ide_retry_pc(ide_drive_t drive, struct gendisk disk)
		void ide_retry_pc(ide_drive_t *drive)
		{
		struct request *rq = &drive->request_sense_rq;
		struct request *sense_rq = &drive->sense_rq;
		struct ide_atapi_pc *pc = &drive->request_sense_pc;

		(void)ide_read_error(drive);
		ide_create_request_sense_cmd(drive, pc);

		/* init pc from sense_rq */
		ide_init_pc(pc);
		memcpy(pc->c, sense_rq->cmd, 12);
		pc->buf = bio_data(sense_rq->bio); /* pointer to mapped address */
		pc->req_xfer = sense_rq->data_len;

		if (drive->media == ide_tape)
		set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags);
		ide_queue_pc_head(drive, disk, pc, rq);

		if (ide_queue_sense_rq(drive, pc))
		ide_complete_rq(drive, -EIO, blk_rq_bytes(drive->hwif->rq));
		}
		EXPORT_SYMBOL_GPL(ide_retry_pc);

		@@ -276,7 +333,6 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
		struct ide_cmd *cmd = &hwif->cmd;
		struct request *rq = hwif->rq;
		const struct ide_tp_ops *tp_ops = hwif->tp_ops;
		xfer_func_t *xferfunc;
		unsigned int timeout, done;
		u16 bcount;
		u8 stat, ireason, dsc = 0;
		@@ -303,11 +359,8 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
		drive->name, rq_data_dir(pc->rq)
		? "write" : "read");
		pc->flags \|= PC_FLAG_DMA_ERROR;
		} else {
		} else
		pc->xferred = pc->req_xfer;
		if (drive->pc_update_buffers)
		drive->pc_update_buffers(drive, pc);
		}
		debug_log("%s: DMA finished\n", drive->name);
		}

		@@ -343,7 +396,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
		debug_log("[cmd %x]: check condition\n", rq->cmd[0]);

		/* Retry operation */
		ide_retry_pc(drive, rq->rq_disk);
		ide_retry_pc(drive);

		/* queued, but not started */
		return ide_stopped;
		@@ -353,6 +406,12 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
		if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)
		dsc = 1;

		/*
		* ->pc_callback() might change rq->data_len for
		* residual count, cache total length.
		*/
		done = blk_rq_bytes(rq);

		/* Command finished - Call the callback function */
		uptodate = drive->pc_callback(drive, dsc);

		@@ -361,7 +420,6 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)

		if (blk_special_request(rq)) {
		rq->errors = 0;
		done = blk_rq_bytes(rq);
		error = 0;
		} else {

		@@ -370,11 +428,6 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
		rq->errors = -EIO;
		}

		if (drive->media == ide_tape)
		done = ide_rq_bytes(rq); /* FIXME */
		else
		done = blk_rq_bytes(rq);

		error = uptodate ? 0 : -EIO;
		}

		@@ -407,21 +460,11 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
		return ide_do_reset(drive);
		}

		xferfunc = write ? tp_ops->output_data : tp_ops->input_data;

		if (drive->media == ide_floppy && pc->buf == NULL) {
		done = min_t(unsigned int, bcount, cmd->nleft);
		ide_pio_bytes(drive, cmd, write, done);
		} else if (drive->media == ide_tape && pc->bh) {
		done = drive->pc_io_buffers(drive, pc, bcount, write);
		} else {
		done = min_t(unsigned int, bcount, pc->req_xfer - pc->xferred);
		xferfunc(drive, NULL, pc->cur_pos, done);
		}

		/* Update the current position */
		/* Update transferred byte count */
		pc->xferred += done;
		pc->cur_pos += done;

		bcount -= done;

		@@ -599,7 +642,6 @@ ide_startstop_t ide_issue_pc(ide_drive_t drive, struct ide_cmd cmd)

		/* We haven't transferred any data yet */
		pc->xferred = 0;
		pc->cur_pos = pc->buf;

		valid_tf = IDE_VALID_DEVICE;
		bcount = ((drive->media == ide_tape) ?

drivers/ide/ide-cd.c

+27 −61

Original line number	Diff line number	Diff line
		@@ -206,54 +206,25 @@ static void cdrom_analyze_sense_data(ide_drive_t *drive,
		ide_cd_log_error(drive->name, failed_command, sense);
		}

		static void cdrom_queue_request_sense(ide_drive_t drive, void sense,
		struct request *failed_command)
		{
		struct cdrom_info *info = drive->driver_data;
		struct request *rq = &drive->request_sense_rq;

		ide_debug_log(IDE_DBG_SENSE, "enter");

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

		/* stuff the sense request in front of our current request */
		blk_rq_init(NULL, rq);
		rq->cmd_type = REQ_TYPE_ATA_PC;
		rq->rq_disk = info->disk;

		rq->data = sense;
		rq->cmd[0] = GPCMD_REQUEST_SENSE;
		rq->cmd[4] = 18;
		rq->data_len = 18;

		rq->cmd_type = REQ_TYPE_SENSE;
		rq->cmd_flags \|= REQ_PREEMPT;

		/* NOTE! Save the failed command in "rq->buffer" */
		rq->buffer = (void *) failed_command;

		if (failed_command)
		ide_debug_log(IDE_DBG_SENSE, "failed_cmd: 0x%x",
		failed_command->cmd[0]);

		drive->hwif->rq = NULL;

		elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0);
		}

		static void ide_cd_complete_failed_rq(ide_drive_t drive, struct request rq)
		{
		/*
		* For REQ_TYPE_SENSE, "rq->buffer" points to the original
		* failed request
		* For REQ_TYPE_SENSE, "rq->special" points to the original
		* failed request. Also, the sense data should be read
		* directly from rq which might be different from the original
		* sense buffer if it got copied during mapping.
		*/
		struct request failed = (struct request )rq->buffer;
		struct cdrom_info *info = drive->driver_data;
		void *sense = &info->sense_data;
		struct request failed = (struct request )rq->special;
		void *sense = bio_data(rq->bio);

		if (failed) {
		if (failed->sense) {
		/*
		* Sense is always read into drive->sense_data.
		* Copy back if the failed request has its
		* sense pointer set.
		*/
		memcpy(failed->sense, sense, 18);
		sense = failed->sense;
		failed->sense_len = rq->sense_len;
		}
		@@ -428,7 +399,7 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)

		/* if we got a CHECK_CONDITION status, queue a request sense command */
		if (stat & ATA_ERR)
		cdrom_queue_request_sense(drive, NULL, NULL);
		return ide_queue_sense_rq(drive, NULL) ? 2 : 1;
		return 1;

		end_request:
		@@ -442,8 +413,7 @@ end_request:

		hwif->rq = NULL;

		cdrom_queue_request_sense(drive, rq->sense, rq);
		return 1;
		return ide_queue_sense_rq(drive, rq) ? 2 : 1;
		} else
		return 2;
		}
		@@ -503,14 +473,8 @@ static void ide_cd_request_sense_fixup(ide_drive_t drive, struct ide_cmd cmd)
		* and some drives don't send them. Sigh.
		*/
		if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
		cmd->nleft > 0 && cmd->nleft <= 5) {
		unsigned int ofs = cmd->nbytes - cmd->nleft;

		while (cmd->nleft > 0) {
		((u8 )rq->data + ofs++) = 0;
		cmd->nleft--;
		}
		}
		cmd->nleft > 0 && cmd->nleft <= 5)
		cmd->nleft = 0;
		}

		int ide_cd_queue_pc(ide_drive_t drive, const unsigned char cmd,
		@@ -543,8 +507,12 @@ int ide_cd_queue_pc(ide_drive_t drive, const unsigned char cmd,
		rq->cmd_flags \|= cmd_flags;
		rq->timeout = timeout;
		if (buffer) {
		rq->data = buffer;
		rq->data_len = *bufflen;
		error = blk_rq_map_kern(drive->queue, rq, buffer,
		*bufflen, GFP_NOIO);
		if (error) {
		blk_put_request(rq);
		return error;
		}
		}

		error = blk_execute_rq(drive->queue, info->disk, rq, 0);
		@@ -838,15 +806,10 @@ static void cdrom_do_block_pc(ide_drive_t drive, struct request rq)
		drive->dma = 0;

		/* sg request */
		if (rq->bio \|\| ((rq->cmd_type == REQ_TYPE_ATA_PC) && rq->data_len)) {
		if (rq->bio) {
		struct request_queue *q = drive->queue;
		char *buf = bio_data(rq->bio);
		unsigned int alignment;
		char *buf;

		if (rq->bio)
		buf = bio_data(rq->bio);
		else
		buf = rq->data;

		drive->dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);

		@@ -896,6 +859,9 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t drive, struct request rq,
		goto out_end;
		}

		/* prepare sense request for this command */
		ide_prep_sense(drive, rq);

		memset(&cmd, 0, sizeof(cmd));

		if (rq_data_dir(rq))

drivers/ide/ide-cd.h

+0 −4

Original line number	Diff line number	Diff line
		@@ -87,10 +87,6 @@ struct cdrom_info {

		struct atapi_toc *toc;

		/* The result of the last successful request sense command
		on this device. */
		struct request_sense sense_data;

		u8 max_speed; /* Max speed of the drive. */
		u8 current_speed; /* Current speed of the drive. */

Admin message