Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 27951daa authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-2.6.31' of git://git.kernel.org/pub/scm/linux/kernel/git/bart/ide-2.6 

* 'for-2.6.31' of git://git.kernel.org/pub/scm/linux/kernel/git/bart/ide-2.6: (28 commits)
  ide-tape: fix debug call
  alim15x3: Remove historical hacks, re-enable init_hwif for PowerPC
  ide-dma: don't reset request fields on dma_timeout_retry()
  ide: drop rq->data handling from ide_map_sg()
  ide-atapi: kill unused fields and callbacks
  ide-tape: simplify read/write functions
  ide-tape: use byte size instead of sectors on rw issue functions
  ide-tape: unify r/w init paths
  ide-tape: kill idetape_bh
  ide-tape: use standard data transfer mechanism
  ide-tape: use single continuous buffer
  ide-atapi,tape,floppy: allow ->pc_callback() to change rq->data_len
  ide-tape,floppy: fix failed command completion after request sense
  ide-pm: don't abuse rq->data
  ide-cd,atapi: use bio for internal commands
  ide-atapi: convert ide-{floppy,tape} to using preallocated sense buffer
  ide-cd: convert to using generic sense request
  ide: add helpers for preparing sense requests
  ide-cd: don't abuse rq->buffer
  ide-atapi: don't abuse rq->buffer
  ...
parents 59c288ff e8e7526c

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 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat) 


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