ide: add ide_queue_pc_tail() helper (2ac07d92) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/ide/ide-atapi.c

+23 −0

Original line number	Original line	Diff line number	Diff line
	@@ -139,6 +139,29 @@ void ide_queue_pc_head(ide_drive_t drive, struct gendisk disk,
	}		}
	EXPORT_SYMBOL_GPL(ide_queue_pc_head);		EXPORT_SYMBOL_GPL(ide_queue_pc_head);

			/*
			* Add a special packet command request to the tail of the request queue,
			* and wait for it to be serviced.
			*/
			int ide_queue_pc_tail(ide_drive_t drive, struct gendisk disk,
			struct ide_atapi_pc *pc)
			{
			struct request *rq;
			int error;

			rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
			rq->cmd_type = REQ_TYPE_SPECIAL;
			rq->buffer = (char *)pc;
			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);
			blk_put_request(rq);

			return error;
			}
			EXPORT_SYMBOL_GPL(ide_queue_pc_tail);

	/* TODO: unify the code thus making some arguments go away */		/* TODO: unify the code thus making some arguments go away */
	ide_startstop_t ide_pc_intr(ide_drive_t drive, struct ide_atapi_pc pc,		ide_startstop_t ide_pc_intr(ide_drive_t drive, struct ide_atapi_pc pc,
	ide_handler_t handler, unsigned int timeout, ide_expiry_t expiry,		ide_handler_t handler, unsigned int timeout, ide_expiry_t expiry,

drivers/ide/ide-floppy.c

+17 −32

Original line number	Original line	Diff line number	Diff line
	@@ -553,26 +553,6 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
	return idefloppy_issue_pc(drive, pc);		return idefloppy_issue_pc(drive, pc);
	}		}

	/*
	* Add a special packet command request to the tail of the request queue,
	* and wait for it to be serviced.
	*/
	static int idefloppy_queue_pc_tail(ide_drive_t drive, struct ide_atapi_pc pc)
	{
	struct ide_floppy_obj *floppy = drive->driver_data;
	struct request *rq;
	int error;

	rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
	rq->buffer = (char *) pc;
	rq->cmd_type = REQ_TYPE_SPECIAL;
	memcpy(rq->cmd, pc->c, 12);
	error = blk_execute_rq(drive->queue, floppy->disk, rq, 0);
	blk_put_request(rq);

	return error;
	}

	/*		/*
	* Look at the flexible disk page parameters. We ignore the CHS capacity		* Look at the flexible disk page parameters. We ignore the CHS capacity
	* parameters and use the LBA parameters instead.		* parameters and use the LBA parameters instead.
	@@ -580,6 +560,7 @@ static int idefloppy_queue_pc_tail(ide_drive_t drive, struct ide_atapi_pc pc)
	static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)		static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
	{		{
	idefloppy_floppy_t *floppy = drive->driver_data;		idefloppy_floppy_t *floppy = drive->driver_data;
			struct gendisk *disk = floppy->disk;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;
	u8 *page;		u8 *page;
	int capacity, lba_capacity;		int capacity, lba_capacity;
	@@ -588,13 +569,13 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)

	idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE);		idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_FLEXIBLE_DISK_PAGE);

	if (idefloppy_queue_pc_tail(drive, &pc)) {		if (ide_queue_pc_tail(drive, disk, &pc)) {
	printk(KERN_ERR "ide-floppy: Can't get flexible disk page"		printk(KERN_ERR "ide-floppy: Can't get flexible disk page"
	" parameters\n");		" parameters\n");
	return 1;		return 1;
	}		}
	floppy->wp = !!(pc.buf[3] & 0x80);		floppy->wp = !!(pc.buf[3] & 0x80);
	set_disk_ro(floppy->disk, floppy->wp);		set_disk_ro(disk, floppy->wp);
	page = &pc.buf[8];		page = &pc.buf[8];

	transfer_rate = be16_to_cpup((__be16 *)&pc.buf[8 + 2]);		transfer_rate = be16_to_cpup((__be16 *)&pc.buf[8 + 2]);
	@@ -638,7 +619,7 @@ static int idefloppy_get_sfrp_bit(ide_drive_t *drive)
	idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE);		idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE);
	pc.flags \|= PC_FLAG_SUPPRESS_ERROR;		pc.flags \|= PC_FLAG_SUPPRESS_ERROR;

	if (idefloppy_queue_pc_tail(drive, &pc))		if (ide_queue_pc_tail(drive, floppy->disk, &pc))
	return 1;		return 1;

	floppy->srfp = pc.buf[8 + 2] & 0x40;		floppy->srfp = pc.buf[8 + 2] & 0x40;
	@@ -652,6 +633,7 @@ static int idefloppy_get_sfrp_bit(ide_drive_t *drive)
	static int ide_floppy_get_capacity(ide_drive_t *drive)		static int ide_floppy_get_capacity(ide_drive_t *drive)
	{		{
	idefloppy_floppy_t *floppy = drive->driver_data;		idefloppy_floppy_t *floppy = drive->driver_data;
			struct gendisk *disk = floppy->disk;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;
	u8 *cap_desc;		u8 *cap_desc;
	u8 header_len, desc_cnt;		u8 header_len, desc_cnt;
	@@ -664,7 +646,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
	set_capacity(floppy->disk, 0);		set_capacity(floppy->disk, 0);

	idefloppy_create_read_capacity_cmd(&pc);		idefloppy_create_read_capacity_cmd(&pc);
	if (idefloppy_queue_pc_tail(drive, &pc)) {		if (ide_queue_pc_tail(drive, disk, &pc)) {
	printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");		printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
	return 1;		return 1;
	}		}
	@@ -739,7 +721,8 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
	if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))		if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))
	(void) ide_floppy_get_flexible_disk_page(drive);		(void) ide_floppy_get_flexible_disk_page(drive);

	set_capacity(floppy->disk, floppy->blocks * floppy->bs_factor);		set_capacity(disk, floppy->blocks * floppy->bs_factor);

	return rc;		return rc;
	}		}

	@@ -764,6 +747,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)

	static int ide_floppy_get_format_capacities(ide_drive_t drive, int __user arg)		static int ide_floppy_get_format_capacities(ide_drive_t drive, int __user arg)
	{		{
			struct ide_floppy_obj *floppy = drive->driver_data;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;
	u8 header_len, desc_cnt;		u8 header_len, desc_cnt;
	int i, blocks, length, u_array_size, u_index;		int i, blocks, length, u_array_size, u_index;
	@@ -776,7 +760,7 @@ static int ide_floppy_get_format_capacities(ide_drive_t drive, int __user arg)
	return -EINVAL;		return -EINVAL;

	idefloppy_create_read_capacity_cmd(&pc);		idefloppy_create_read_capacity_cmd(&pc);
	if (idefloppy_queue_pc_tail(drive, &pc)) {		if (ide_queue_pc_tail(drive, floppy->disk, &pc)) {
	printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");		printk(KERN_ERR "ide-floppy: Can't get floppy parameters\n");
	return -EIO;		return -EIO;
	}		}
	@@ -838,7 +822,7 @@ static int ide_floppy_get_format_progress(ide_drive_t drive, int __user arg)

	if (floppy->srfp) {		if (floppy->srfp) {
	idefloppy_create_request_sense_cmd(&pc);		idefloppy_create_request_sense_cmd(&pc);
	if (idefloppy_queue_pc_tail(drive, &pc))		if (ide_queue_pc_tail(drive, floppy->disk, &pc))
	return -EIO;		return -EIO;

	if (floppy->sense_key == 2 &&		if (floppy->sense_key == 2 &&
	@@ -1008,12 +992,13 @@ static ide_driver_t idefloppy_driver = {

	static void ide_floppy_set_media_lock(ide_drive_t *drive, int on)		static void ide_floppy_set_media_lock(ide_drive_t *drive, int on)
	{		{
			struct ide_floppy_obj *floppy = drive->driver_data;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;

	/* IOMEGA Clik! drives do not support lock/unlock commands */		/* IOMEGA Clik! drives do not support lock/unlock commands */
	if ((drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE) == 0) {		if ((drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE) == 0) {
	idefloppy_create_prevent_cmd(&pc, on);		idefloppy_create_prevent_cmd(&pc, on);
	(void)idefloppy_queue_pc_tail(drive, &pc);		(void)ide_queue_pc_tail(drive, floppy->disk, &pc);
	}		}
	}		}

	@@ -1042,9 +1027,9 @@ static int idefloppy_open(struct inode inode, struct file filp)
	ide_init_pc(&pc);		ide_init_pc(&pc);
	pc.c[0] = GPCMD_TEST_UNIT_READY;		pc.c[0] = GPCMD_TEST_UNIT_READY;

	if (idefloppy_queue_pc_tail(drive, &pc)) {		if (ide_queue_pc_tail(drive, disk, &pc)) {
	idefloppy_create_start_stop_cmd(&pc, 1);		idefloppy_create_start_stop_cmd(&pc, 1);
	(void) idefloppy_queue_pc_tail(drive, &pc);		(void)ide_queue_pc_tail(drive, disk, &pc);
	}		}

	if (ide_floppy_get_capacity(drive)		if (ide_floppy_get_capacity(drive)
	@@ -1123,7 +1108,7 @@ static int ide_floppy_lockdoor(ide_drive_t drive, struct ide_atapi_pc pc,

	if (cmd == CDROMEJECT) {		if (cmd == CDROMEJECT) {
	idefloppy_create_start_stop_cmd(pc, 2);		idefloppy_create_start_stop_cmd(pc, 2);
	(void) idefloppy_queue_pc_tail(floppy->drive, pc);		(void)ide_queue_pc_tail(drive, floppy->disk, pc);
	}		}

	return 0;		return 0;
	@@ -1168,7 +1153,7 @@ static int ide_floppy_format_unit(ide_drive_t drive, int __user arg)
	(void) idefloppy_get_sfrp_bit(drive);		(void) idefloppy_get_sfrp_bit(drive);
	idefloppy_create_format_unit_cmd(&pc, blocks, length, flags);		idefloppy_create_format_unit_cmd(&pc, blocks, length, flags);

	if (idefloppy_queue_pc_tail(drive, &pc))		if (ide_queue_pc_tail(drive, floppy->disk, &pc))
	err = -EIO;		err = -EIO;

	out:		out:

drivers/ide/ide-tape.c

+28 −41

Original line number	Original line	Diff line number	Diff line
	@@ -1125,26 +1125,6 @@ static void idetape_create_test_unit_ready_cmd(struct ide_atapi_pc *pc)
	pc->c[0] = TEST_UNIT_READY;		pc->c[0] = TEST_UNIT_READY;
	}		}

	/*
	* We add a special packet command request to the tail of the request queue, and
	* wait for it to be serviced.
	*/
	static int idetape_queue_pc_tail(ide_drive_t drive, struct ide_atapi_pc pc)
	{
	struct ide_tape_obj *tape = drive->driver_data;
	struct request *rq;
	int error;

	rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
	rq->cmd_type = REQ_TYPE_SPECIAL;
	rq->cmd[13] = REQ_IDETAPE_PC1;
	rq->buffer = (char *)pc;
	memcpy(rq->cmd, pc->c, 12);
	error = blk_execute_rq(drive->queue, tape->disk, rq, 0);
	blk_put_request(rq);
	return error;
	}

	static void idetape_create_load_unload_cmd(ide_drive_t *drive,		static void idetape_create_load_unload_cmd(ide_drive_t *drive,
	struct ide_atapi_pc *pc, int cmd)		struct ide_atapi_pc *pc, int cmd)
	{		{
	@@ -1157,6 +1137,7 @@ static void idetape_create_load_unload_cmd(ide_drive_t *drive,
	static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)		static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
	{		{
	idetape_tape_t *tape = drive->driver_data;		idetape_tape_t *tape = drive->driver_data;
			struct gendisk *disk = tape->disk;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;
	int load_attempted = 0;		int load_attempted = 0;

	@@ -1165,7 +1146,7 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
	timeout += jiffies;		timeout += jiffies;
	while (time_before(jiffies, timeout)) {		while (time_before(jiffies, timeout)) {
	idetape_create_test_unit_ready_cmd(&pc);		idetape_create_test_unit_ready_cmd(&pc);
	if (!idetape_queue_pc_tail(drive, &pc))		if (!ide_queue_pc_tail(drive, disk, &pc))
	return 0;		return 0;
	if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2)		if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2)
	\|\| (tape->asc == 0x3A)) {		\|\| (tape->asc == 0x3A)) {
	@@ -1174,7 +1155,7 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
	return -ENOMEDIUM;		return -ENOMEDIUM;
	idetape_create_load_unload_cmd(drive, &pc,		idetape_create_load_unload_cmd(drive, &pc,
	IDETAPE_LU_LOAD_MASK);		IDETAPE_LU_LOAD_MASK);
	idetape_queue_pc_tail(drive, &pc);		ide_queue_pc_tail(drive, disk, &pc);
	load_attempted = 1;		load_attempted = 1;
	/* not about to be ready */		/* not about to be ready */
	} else if (!(tape->sense_key == 2 && tape->asc == 4 &&		} else if (!(tape->sense_key == 2 && tape->asc == 4 &&
	@@ -1187,11 +1168,12 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)

	static int idetape_flush_tape_buffers(ide_drive_t *drive)		static int idetape_flush_tape_buffers(ide_drive_t *drive)
	{		{
			struct ide_tape_obj *tape = drive->driver_data;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;
	int rc;		int rc;

	idetape_create_write_filemark_cmd(drive, &pc, 0);		idetape_create_write_filemark_cmd(drive, &pc, 0);
	rc = idetape_queue_pc_tail(drive, &pc);		rc = ide_queue_pc_tail(drive, tape->disk, &pc);
	if (rc)		if (rc)
	return rc;		return rc;
	idetape_wait_ready(drive, 60 * 5 * HZ);		idetape_wait_ready(drive, 60 * 5 * HZ);
	@@ -1214,7 +1196,7 @@ static int idetape_read_position(ide_drive_t *drive)
	debug_log(DBG_PROCS, "Enter %s\n", __func__);		debug_log(DBG_PROCS, "Enter %s\n", __func__);

	idetape_create_read_position_cmd(&pc);		idetape_create_read_position_cmd(&pc);
	if (idetape_queue_pc_tail(drive, &pc))		if (ide_queue_pc_tail(drive, tape->disk, &pc))
	return -1;		return -1;
	position = tape->first_frame;		position = tape->first_frame;
	return position;		return position;
	@@ -1249,12 +1231,13 @@ static int idetape_create_prevent_cmd(ide_drive_t *drive,

	static int ide_tape_set_media_lock(ide_drive_t *drive, int on)		static int ide_tape_set_media_lock(ide_drive_t *drive, int on)
	{		{
			struct ide_tape_obj *tape = drive->driver_data;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;

	if (!idetape_create_prevent_cmd(drive, &pc, on))		if (!idetape_create_prevent_cmd(drive, &pc, on))
	return 0;		return 0;

	return idetape_queue_pc_tail(drive, &pc);		return ide_queue_pc_tail(drive, tape->disk, &pc);
	}		}

	static void __ide_tape_discard_merge_buffer(ide_drive_t *drive)		static void __ide_tape_discard_merge_buffer(ide_drive_t *drive)
	@@ -1284,6 +1267,7 @@ static int idetape_position_tape(ide_drive_t *drive, unsigned int block,
	u8 partition, int skip)		u8 partition, int skip)
	{		{
	idetape_tape_t *tape = drive->driver_data;		idetape_tape_t *tape = drive->driver_data;
			struct gendisk *disk = tape->disk;
	int retval;		int retval;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;

	@@ -1291,12 +1275,12 @@ static int idetape_position_tape(ide_drive_t *drive, unsigned int block,
	__ide_tape_discard_merge_buffer(drive);		__ide_tape_discard_merge_buffer(drive);
	idetape_wait_ready(drive, 60 * 5 * HZ);		idetape_wait_ready(drive, 60 * 5 * HZ);
	idetape_create_locate_cmd(drive, &pc, block, partition, skip);		idetape_create_locate_cmd(drive, &pc, block, partition, skip);
	retval = idetape_queue_pc_tail(drive, &pc);		retval = ide_queue_pc_tail(drive, disk, &pc);
	if (retval)		if (retval)
	return (retval);		return (retval);

	idetape_create_read_position_cmd(&pc);		idetape_create_read_position_cmd(&pc);
	return (idetape_queue_pc_tail(drive, &pc));		return ide_queue_pc_tail(drive, disk, &pc);
	}		}

	static void ide_tape_discard_merge_buffer(ide_drive_t *drive,		static void ide_tape_discard_merge_buffer(ide_drive_t *drive,
	@@ -1543,20 +1527,20 @@ static void idetape_pad_zeros(ide_drive_t *drive, int bcount)
	*/		*/
	static int idetape_rewind_tape(ide_drive_t *drive)		static int idetape_rewind_tape(ide_drive_t *drive)
	{		{
			struct ide_tape_obj *tape = drive->driver_data;
			struct gendisk *disk = tape->disk;
	int retval;		int retval;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;
	idetape_tape_t *tape;
	tape = drive->driver_data;

	debug_log(DBG_SENSE, "Enter %s\n", __func__);		debug_log(DBG_SENSE, "Enter %s\n", __func__);

	idetape_create_rewind_cmd(drive, &pc);		idetape_create_rewind_cmd(drive, &pc);
	retval = idetape_queue_pc_tail(drive, &pc);		retval = ide_queue_pc_tail(drive, disk, &pc);
	if (retval)		if (retval)
	return retval;		return retval;

	idetape_create_read_position_cmd(&pc);		idetape_create_read_position_cmd(&pc);
	retval = idetape_queue_pc_tail(drive, &pc);		retval = ide_queue_pc_tail(drive, disk, &pc);
	if (retval)		if (retval)
	return retval;		return retval;
	return 0;		return 0;
	@@ -1599,6 +1583,7 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
	int mt_count)		int mt_count)
	{		{
	idetape_tape_t *tape = drive->driver_data;		idetape_tape_t *tape = drive->driver_data;
			struct gendisk *disk = tape->disk;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;
	int retval, count = 0;		int retval, count = 0;
	int sprev = !!(tape->caps[4] & 0x20);		int sprev = !!(tape->caps[4] & 0x20);
	@@ -1623,7 +1608,7 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
	case MTBSF:		case MTBSF:
	idetape_create_space_cmd(&pc, mt_count - count,		idetape_create_space_cmd(&pc, mt_count - count,
	IDETAPE_SPACE_OVER_FILEMARK);		IDETAPE_SPACE_OVER_FILEMARK);
	return idetape_queue_pc_tail(drive, &pc);		return ide_queue_pc_tail(drive, disk, &pc);
	case MTFSFM:		case MTFSFM:
	case MTBSFM:		case MTBSFM:
	if (!sprev)		if (!sprev)
	@@ -1812,11 +1797,12 @@ static ssize_t idetape_chrdev_write(struct file file, const char __user buf,

	static int idetape_write_filemark(ide_drive_t *drive)		static int idetape_write_filemark(ide_drive_t *drive)
	{		{
			struct ide_tape_obj *tape = drive->driver_data;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;

	/* Write a filemark */		/* Write a filemark */
	idetape_create_write_filemark_cmd(drive, &pc, 1);		idetape_create_write_filemark_cmd(drive, &pc, 1);
	if (idetape_queue_pc_tail(drive, &pc)) {		if (ide_queue_pc_tail(drive, tape->disk, &pc)) {
	printk(KERN_ERR "ide-tape: Couldn't write a filemark\n");		printk(KERN_ERR "ide-tape: Couldn't write a filemark\n");
	return -EIO;		return -EIO;
	}		}
	@@ -1839,6 +1825,7 @@ static int idetape_write_filemark(ide_drive_t *drive)
	static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)		static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
	{		{
	idetape_tape_t *tape = drive->driver_data;		idetape_tape_t *tape = drive->driver_data;
			struct gendisk *disk = tape->disk;
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;
	int i, retval;		int i, retval;

	@@ -1877,7 +1864,7 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
	ide_tape_discard_merge_buffer(drive, 0);		ide_tape_discard_merge_buffer(drive, 0);
	idetape_create_load_unload_cmd(drive, &pc,		idetape_create_load_unload_cmd(drive, &pc,
	IDETAPE_LU_LOAD_MASK);		IDETAPE_LU_LOAD_MASK);
	return idetape_queue_pc_tail(drive, &pc);		return ide_queue_pc_tail(drive, disk, &pc);
	case MTUNLOAD:		case MTUNLOAD:
	case MTOFFL:		case MTOFFL:
	/*		/*
	@@ -1891,7 +1878,7 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
	ide_tape_discard_merge_buffer(drive, 0);		ide_tape_discard_merge_buffer(drive, 0);
	idetape_create_load_unload_cmd(drive, &pc,		idetape_create_load_unload_cmd(drive, &pc,
	!IDETAPE_LU_LOAD_MASK);		!IDETAPE_LU_LOAD_MASK);
	retval = idetape_queue_pc_tail(drive, &pc);		retval = ide_queue_pc_tail(drive, disk, &pc);
	if (!retval)		if (!retval)
	clear_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags);		clear_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags);
	return retval;		return retval;
	@@ -1902,14 +1889,14 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
	ide_tape_discard_merge_buffer(drive, 0);		ide_tape_discard_merge_buffer(drive, 0);
	idetape_create_load_unload_cmd(drive, &pc,		idetape_create_load_unload_cmd(drive, &pc,
	IDETAPE_LU_RETENSION_MASK \| IDETAPE_LU_LOAD_MASK);		IDETAPE_LU_RETENSION_MASK \| IDETAPE_LU_LOAD_MASK);
	return idetape_queue_pc_tail(drive, &pc);		return ide_queue_pc_tail(drive, disk, &pc);
	case MTEOM:		case MTEOM:
	idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD);		idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD);
	return idetape_queue_pc_tail(drive, &pc);		return ide_queue_pc_tail(drive, disk, &pc);
	case MTERASE:		case MTERASE:
	(void)idetape_rewind_tape(drive);		(void)idetape_rewind_tape(drive);
	idetape_create_erase_cmd(&pc);		idetape_create_erase_cmd(&pc);
	return idetape_queue_pc_tail(drive, &pc);		return ide_queue_pc_tail(drive, disk, &pc);
	case MTSETBLK:		case MTSETBLK:
	if (mt_count) {		if (mt_count) {
	if (mt_count < tape->blk_size \|\|		if (mt_count < tape->blk_size \|\|
	@@ -2018,7 +2005,7 @@ static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive)
	struct ide_atapi_pc pc;		struct ide_atapi_pc pc;

	idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR);		idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR);
	if (idetape_queue_pc_tail(drive, &pc)) {		if (ide_queue_pc_tail(drive, tape->disk, &pc)) {
	printk(KERN_ERR "ide-tape: Can't get block descriptor\n");		printk(KERN_ERR "ide-tape: Can't get block descriptor\n");
	if (tape->blk_size == 0) {		if (tape->blk_size == 0) {
	printk(KERN_WARNING "ide-tape: Cannot deal with zero "		printk(KERN_WARNING "ide-tape: Cannot deal with zero "
	@@ -2170,7 +2157,7 @@ static void idetape_get_inquiry_results(ide_drive_t *drive)
	char fw_rev[4], vendor_id[8], product_id[16];		char fw_rev[4], vendor_id[8], product_id[16];

	idetape_create_inquiry_cmd(&pc);		idetape_create_inquiry_cmd(&pc);
	if (idetape_queue_pc_tail(drive, &pc)) {		if (ide_queue_pc_tail(drive, tape->disk, &pc)) {
	printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n",		printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n",
	tape->name);		tape->name);
	return;		return;
	@@ -2199,7 +2186,7 @@ static void idetape_get_mode_sense_results(ide_drive_t *drive)
	u8 speed, max_speed;		u8 speed, max_speed;

	idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE);		idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE);
	if (idetape_queue_pc_tail(drive, &pc)) {		if (ide_queue_pc_tail(drive, tape->disk, &pc)) {
	printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming"		printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming"
	" some default values\n");		" some default values\n");
	tape->blk_size = 512;		tape->blk_size = 512;

include/linux/ide.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -1136,6 +1136,7 @@ enum {

	void ide_queue_pc_head(ide_drive_t , struct gendisk , struct ide_atapi_pc *,		void ide_queue_pc_head(ide_drive_t , struct gendisk , struct ide_atapi_pc *,
	struct request *);		struct request *);
			int ide_queue_pc_tail(ide_drive_t , struct gendisk , struct ide_atapi_pc *);

	ide_startstop_t ide_pc_intr(ide_drive_t drive, struct ide_atapi_pc pc,		ide_startstop_t ide_pc_intr(ide_drive_t drive, struct ide_atapi_pc pc,
	ide_handler_t handler, unsigned int timeout, ide_expiry_t expiry,		ide_handler_t handler, unsigned int timeout, ide_expiry_t expiry,