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

Commit 346331f8 authored by Borislav Petkov's avatar Borislav Petkov Committed by Bartlomiej Zolnierkiewicz
Browse files

ide-tape: remove atomic test/set macros for packet commands 



Removing the atomic tests for pc's is unobjectionable. Since this driver will
probably go to /dev/null soon, the atomic tests for tape->flags are left in
place for there are some situations where they're needed (chrdev DSC handling,
low level pipeline operation and so on). While at it, rename all test/set flag
bit defines explicitly to *_FLAG_* for clarity.

Signed-off-by: default avatarBorislav Petkov <petkovbb@gmail.com>
Signed-off-by: default avatarBartlomiej Zolnierkiewicz <bzolnier@gmail.com>
parent 03056b90

drivers/ide/ide-tape.c

+110 −97
Original line number Diff line number Diff line
@@ -209,21 +209,21 @@ typedef struct idetape_packet_command_s { 
	unsigned long flags;

} idetape_pc_t;



/*

 *	Packet command flag bits.

 */

/* Packet command flag bits. */

enum {

	/* Set when an error is considered normal - We won't retry */

#define	PC_ABORT			0

	PC_FLAG_ABORT		= (1 << 0),

	/* 1 When polling for DSC on a media access command */

#define PC_WAIT_FOR_DSC			1

	PC_FLAG_WAIT_FOR_DSC	= (1 << 1),

	/* 1 when we prefer to use DMA if possible */

#define PC_DMA_RECOMMENDED		2

	PC_FLAG_DMA_RECOMMENDED	= (1 << 2),

	/* 1 while DMA in progress */

#define	PC_DMA_IN_PROGRESS		3

	PC_FLAG_DMA_IN_PROGRESS	= (1 << 3),

	/* 1 when encountered problem during DMA */

#define	PC_DMA_ERROR			4

	PC_FLAG_DMA_ERROR	= (1 << 4),

	/* Data direction */

#define	PC_WRITING			5

	PC_FLAG_WRITING		= (1 <<	5),

};



/* Tape door status */

#define DOOR_UNLOCKED			0
@@ -262,6 +262,27 @@ enum { 
#define IDETAPE_BLOCK_DESCRIPTOR	0

#define IDETAPE_CAPABILITIES_PAGE	0x2a



/* Tape flag bits values. */

enum {

	IDETAPE_FLAG_IGNORE_DSC		= (1 << 0),

	/* 0 When the tape position is unknown */

	IDETAPE_FLAG_ADDRESS_VALID	= (1 <<	1),

	/* Device already opened */

	IDETAPE_FLAG_BUSY			= (1 << 2),

	/* Error detected in a pipeline stage */

	IDETAPE_FLAG_PIPELINE_ERR	= (1 <<	3),

	/* Attempt to auto-detect the current user block size */

	IDETAPE_FLAG_DETECT_BS		= (1 << 4),

	/* Currently on a filemark */

	IDETAPE_FLAG_FILEMARK		= (1 << 5),

	/* DRQ interrupt device */

	IDETAPE_FLAG_DRQ_INTERRUPT	= (1 << 6),

	/* pipeline active */

	IDETAPE_FLAG_PIPELINE_ACTIVE	= (1 << 7),

	/* 0 = no tape is loaded, so we don't rewind after ejecting */

	IDETAPE_FLAG_MEDIUM_PRESENT	= (1 << 8),

};



/* A pipeline stage. */

typedef struct idetape_stage_s {

	struct request rq;			/* The corresponding request */
@@ -483,21 +504,6 @@ static void ide_tape_put(struct ide_tape_obj *tape) 
	mutex_unlock(&idetape_ref_mutex);

}



/*

 *	Tape flag bits values.

 */

#define IDETAPE_IGNORE_DSC		0

#define IDETAPE_ADDRESS_VALID		1	/* 0 When the tape position is unknown */

#define IDETAPE_BUSY			2	/* Device already opened */

#define IDETAPE_PIPELINE_ERROR		3	/* Error detected in a pipeline stage */

#define IDETAPE_DETECT_BS		4	/* Attempt to auto-detect the current user block size */

#define IDETAPE_FILEMARK		5	/* Currently on a filemark */

#define IDETAPE_DRQ_INTERRUPT		6	/* DRQ interrupt device */

#define IDETAPE_READ_ERROR		7

#define IDETAPE_PIPELINE_ACTIVE		8	/* pipeline active */

/* 0 = no tape is loaded, so we don't rewind after ejecting */

#define IDETAPE_MEDIUM_PRESENT		9



/*

 * The variables below are used for the character device interface. Additional

 * state variables are defined in our ide_drive_t structure.
@@ -581,7 +587,7 @@ static void idetape_update_buffers(idetape_pc_t *pc) 
	int count;

	unsigned int bcount = pc->actually_transferred;



	if (test_bit(PC_WRITING, &pc->flags))

	if (pc->flags & PC_FLAG_WRITING)

		return;

	while (bcount) {

		if (bh == NULL) {
@@ -668,7 +674,7 @@ static void idetape_analyze_error(ide_drive_t *drive, u8 *sense) 
		 pc->c[0], tape->sense_key, tape->asc, tape->ascq);



	/* Correct pc->actually_transferred by asking the tape.	 */

	if (test_bit(PC_DMA_ERROR, &pc->flags)) {

	if (pc->flags & PC_FLAG_DMA_ERROR) {

		pc->actually_transferred = pc->request_transfer -

			tape->blk_size *

			be32_to_cpu(get_unaligned((u32 *)&sense[3]));
@@ -687,26 +693,26 @@ static void idetape_analyze_error(ide_drive_t *drive, u8 *sense) 
			/* don't report an error, everything's ok */

			pc->error = 0;

			/* don't retry read/write */

			set_bit(PC_ABORT, &pc->flags);

			pc->flags |= PC_FLAG_ABORT;

		}

	}

	if (pc->c[0] == READ_6 && (sense[2] & 0x80)) {

		pc->error = IDETAPE_ERROR_FILEMARK;

		set_bit(PC_ABORT, &pc->flags);

		pc->flags |= PC_FLAG_ABORT;

	}

	if (pc->c[0] == WRITE_6) {

		if ((sense[2] & 0x40) || (tape->sense_key == 0xd

		     && tape->asc == 0x0 && tape->ascq == 0x2)) {

			pc->error = IDETAPE_ERROR_EOD;

			set_bit(PC_ABORT, &pc->flags);

			pc->flags |= PC_FLAG_ABORT;

		}

	}

	if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) {

		if (tape->sense_key == 8) {

			pc->error = IDETAPE_ERROR_EOD;

			set_bit(PC_ABORT, &pc->flags);

			pc->flags |= PC_FLAG_ABORT;

		}

		if (!test_bit(PC_ABORT, &pc->flags) &&

		if (!(pc->flags & PC_FLAG_ABORT) &&

		    pc->actually_transferred)

			pc->retries = IDETAPE_MAX_PC_RETRIES + 1;

	}
@@ -862,14 +868,16 @@ static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects) 
		if (rq->cmd[0] & REQ_IDETAPE_WRITE) {

			remove_stage = 1;

			if (error) {

				set_bit(IDETAPE_PIPELINE_ERROR, &tape->flags);

				set_bit(IDETAPE_FLAG_PIPELINE_ERR,

					&tape->flags);

				if (error == IDETAPE_ERROR_EOD)

					idetape_abort_pipeline(drive,

								active_stage);

			}

		} else if (rq->cmd[0] & REQ_IDETAPE_READ) {

			if (error == IDETAPE_ERROR_EOD) {

				set_bit(IDETAPE_PIPELINE_ERROR, &tape->flags);

				set_bit(IDETAPE_FLAG_PIPELINE_ERR,

					&tape->flags);

				idetape_abort_pipeline(drive, active_stage);

			}

		}
@@ -902,7 +910,7 @@ static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects) 
	if (remove_stage)

		idetape_remove_stage_head(drive);

	if (tape->active_data_rq == NULL)

		clear_bit(IDETAPE_PIPELINE_ACTIVE, &tape->flags);

		clear_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags);

	spin_unlock_irqrestore(&tape->lock, flags);

	return 0;

}
@@ -981,7 +989,7 @@ static ide_startstop_t idetape_retry_pc (ide_drive_t *drive) 
	pc = idetape_next_pc_storage(drive);

	rq = idetape_next_rq_storage(drive);

	idetape_create_request_sense_cmd(pc);

	set_bit(IDETAPE_IGNORE_DSC, &tape->flags);

	set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags);

	idetape_queue_pc_head(drive, pc, rq);

	return ide_stopped;

}
@@ -1028,7 +1036,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 
	/* Clear the interrupt */

	stat = ide_read_status(drive);



	if (test_bit(PC_DMA_IN_PROGRESS, &pc->flags)) {

	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {

		if (hwif->ide_dma_end(drive) || (stat & ERR_STAT)) {

			/*

			 * A DMA error is sometimes expected. For example,
@@ -1051,7 +1059,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 
			 * data transfer will occur, but no DMA error.

			 * (AS, 19 Apr 2001)

			 */

			set_bit(PC_DMA_ERROR, &pc->flags);

			pc->flags |= PC_FLAG_DMA_ERROR;

		} else {

			pc->actually_transferred = pc->request_transfer;

			idetape_update_buffers(pc);
@@ -1065,7 +1073,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 
		debug_log(DBG_SENSE, "Packet command completed, %d bytes"

				" transferred\n", pc->actually_transferred);



		clear_bit(PC_DMA_IN_PROGRESS, &pc->flags);

		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;

		local_irq_enable();



#if SIMULATE_ERRORS
@@ -1078,7 +1086,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 
#endif

		if ((stat & ERR_STAT) && pc->c[0] == REQUEST_SENSE)

			stat &= ~ERR_STAT;

		if ((stat & ERR_STAT) || test_bit(PC_DMA_ERROR, &pc->flags)) {

		if ((stat & ERR_STAT) || (pc->flags & PC_FLAG_DMA_ERROR)) {

			/* Error detected */

			debug_log(DBG_ERR, "%s: I/O error\n", tape->name);
@@ -1094,7 +1102,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 
			return idetape_retry_pc(drive);

		}

		pc->error = 0;

		if (test_bit(PC_WAIT_FOR_DSC, &pc->flags) &&

		if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) &&

		    (stat & SEEK_STAT) == 0) {

			/* Media access command */

			tape->dsc_polling_start = jiffies;
@@ -1109,7 +1117,9 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 
		/* Command finished - Call the callback function */

		return pc->callback(drive);

	}

	if (test_and_clear_bit(PC_DMA_IN_PROGRESS, &pc->flags)) {



	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {

		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;

		printk(KERN_ERR "ide-tape: The tape wants to issue more "

				"interrupts in DMA mode\n");

		printk(KERN_ERR "ide-tape: DMA disabled, reverting to PIO\n");
@@ -1126,7 +1136,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 
		printk(KERN_ERR "ide-tape: CoD != 0 in %s\n", __func__);

		return ide_do_reset(drive);

	}

	if (((ireason & IO) == IO) == test_bit(PC_WRITING, &pc->flags)) {

	if (((ireason & IO) == IO) == !!(pc->flags & PC_FLAG_WRITING)) {

		/* Hopefully, we will never get here */

		printk(KERN_ERR "ide-tape: We wanted to %s, ",

				(ireason & IO) ? "Write" : "Read");
@@ -1134,7 +1144,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 
				(ireason & IO) ? "Read" : "Write");

		return ide_do_reset(drive);

	}

	if (!test_bit(PC_WRITING, &pc->flags)) {

	if (!(pc->flags & PC_FLAG_WRITING)) {

		/* Reading - Check that we have enough space */

		temp = pc->actually_transferred + bcount;

		if (temp > pc->request_transfer) {
@@ -1246,7 +1256,7 @@ static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive) 
	ide_set_handler(drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL);

#ifdef CONFIG_BLK_DEV_IDEDMA

	/* Begin DMA, if necessary */

	if (test_bit(PC_DMA_IN_PROGRESS, &pc->flags))

	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS)

		hwif->dma_start(drive);

#endif

	/* Send the actual packet */
@@ -1273,13 +1283,13 @@ static ide_startstop_t idetape_issue_pc(ide_drive_t *drive, idetape_pc_t *pc) 
	tape->pc = pc;



	if (pc->retries > IDETAPE_MAX_PC_RETRIES ||

	    test_bit(PC_ABORT, &pc->flags)) {

		(pc->flags & PC_FLAG_ABORT)) {

		/*

		 * We will "abort" retrying a packet command in case legitimate

		 * error code was received (crossing a filemark, or end of the

		 * media, for example).

		 */

		if (!test_bit(PC_ABORT, &pc->flags)) {

		if (!(pc->flags & PC_FLAG_ABORT)) {

			if (!(pc->c[0] == TEST_UNIT_READY &&

			      tape->sense_key == 2 && tape->asc == 4 &&

			     (tape->ascq == 1 || tape->ascq == 8))) {
@@ -1305,20 +1315,22 @@ static ide_startstop_t idetape_issue_pc(ide_drive_t *drive, idetape_pc_t *pc) 
	/* Request to transfer the entire buffer at once */

	bcount = pc->request_transfer;



	if (test_and_clear_bit(PC_DMA_ERROR, &pc->flags)) {

	if (pc->flags & PC_FLAG_DMA_ERROR) {

		pc->flags &= ~PC_FLAG_DMA_ERROR;

		printk(KERN_WARNING "ide-tape: DMA disabled, "

				"reverting to PIO\n");

		ide_dma_off(drive);

	}

	if (test_bit(PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma)

	if ((pc->flags & PC_FLAG_DMA_RECOMMENDED) && drive->using_dma)

		dma_ok = !hwif->dma_setup(drive);



	ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK |

			   IDE_TFLAG_OUT_DEVICE, bcount, dma_ok);



	if (dma_ok)			/* Will begin DMA later */

		set_bit(PC_DMA_IN_PROGRESS, &pc->flags);

	if (test_bit(IDETAPE_DRQ_INTERRUPT, &tape->flags)) {

	if (dma_ok)

		/* Will begin DMA later */

		pc->flags |= PC_FLAG_DMA_IN_PROGRESS;

	if (test_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags)) {

		ide_execute_command(drive, WIN_PACKETCMD, &idetape_transfer_pc,

				    IDETAPE_WAIT_CMD, NULL);

		return ide_started;
@@ -1506,7 +1518,7 @@ static void idetape_create_read_cmd(idetape_tape_t *tape, idetape_pc_t *pc, 
	pc->buffer_size = length * tape->blk_size;

	pc->request_transfer = pc->buffer_size;

	if (pc->request_transfer == tape->stage_size)

		set_bit(PC_DMA_RECOMMENDED, &pc->flags);

		pc->flags |= PC_FLAG_DMA_RECOMMENDED;

}



static void idetape_create_write_cmd(idetape_tape_t *tape, idetape_pc_t *pc,
@@ -1517,7 +1529,7 @@ static void idetape_create_write_cmd(idetape_tape_t *tape, idetape_pc_t *pc, 
	put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]);

	pc->c[1] = 1;

	pc->callback = &idetape_rw_callback;

	set_bit(PC_WRITING, &pc->flags);

	pc->flags |= PC_FLAG_WRITING;

	pc->bh = bh;

	pc->b_data = bh->b_data;

	pc->b_count = atomic_read(&bh->b_count);
@@ -1525,7 +1537,7 @@ static void idetape_create_write_cmd(idetape_tape_t *tape, idetape_pc_t *pc, 
	pc->buffer_size = length * tape->blk_size;

	pc->request_transfer = pc->buffer_size;

	if (pc->request_transfer == tape->stage_size)

		set_bit(PC_DMA_RECOMMENDED, &pc->flags);

		pc->flags |= PC_FLAG_DMA_RECOMMENDED;

}



static ide_startstop_t idetape_do_request(ide_drive_t *drive,
@@ -1569,10 +1581,10 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive, 
	stat = ide_read_status(drive);



	if (!drive->dsc_overlap && !(rq->cmd[0] & REQ_IDETAPE_PC2))

		set_bit(IDETAPE_IGNORE_DSC, &tape->flags);

		set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags);



	if (drive->post_reset == 1) {

		set_bit(IDETAPE_IGNORE_DSC, &tape->flags);

		set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags);

		drive->post_reset = 0;

	}
@@ -1580,7 +1592,7 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive, 
		tape->insert_speed = tape->insert_size / 1024 * HZ /

					(jiffies - tape->insert_time);

	idetape_calculate_speeds(drive);

	if (!test_and_clear_bit(IDETAPE_IGNORE_DSC, &tape->flags) &&

	if (!test_and_clear_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags) &&

	    (stat & SEEK_STAT) == 0) {

		if (postponed_rq == NULL) {

			tape->dsc_polling_start = jiffies;
@@ -1638,7 +1650,7 @@ static inline int idetape_pipeline_active(idetape_tape_t *tape) 
{

	int rc1, rc2;



	rc1 = test_bit(IDETAPE_PIPELINE_ACTIVE, &tape->flags);

	rc1 = test_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags);

	rc2 = (tape->active_data_rq != NULL);

	return rc1;

}
@@ -1884,7 +1896,7 @@ static ide_startstop_t idetape_read_position_callback(ide_drive_t *drive) 
		if (readpos[0] & 0x4) {

			printk(KERN_INFO "ide-tape: Block location is unknown"

					 "to the tape\n");

			clear_bit(IDETAPE_ADDRESS_VALID, &tape->flags);

			clear_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags);

			idetape_end_request(drive, 0, 0);

		} else {

			debug_log(DBG_SENSE, "Block Location - %u\n",
@@ -1893,7 +1905,7 @@ static ide_startstop_t idetape_read_position_callback(ide_drive_t *drive) 
			tape->partition = readpos[1];

			tape->first_frame =

				be32_to_cpu(*(u32 *)&readpos[4]);

			set_bit(IDETAPE_ADDRESS_VALID, &tape->flags);

			set_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags);

			idetape_end_request(drive, 1, 0);

		}

	} else {
@@ -1912,7 +1924,7 @@ static void idetape_create_write_filemark_cmd(ide_drive_t *drive, 
	idetape_init_pc(pc);

	pc->c[0] = WRITE_FILEMARKS;

	pc->c[4] = write_filemark;

	set_bit(PC_WAIT_FOR_DSC, &pc->flags);

	pc->flags |= PC_FLAG_WAIT_FOR_DSC;

	pc->callback = &idetape_pc_callback;

}
@@ -1953,7 +1965,7 @@ static void idetape_create_load_unload_cmd(ide_drive_t *drive, idetape_pc_t *pc, 
	idetape_init_pc(pc);

	pc->c[0] = START_STOP;

	pc->c[4] = cmd;

	set_bit(PC_WAIT_FOR_DSC, &pc->flags);

	pc->flags |= PC_FLAG_WAIT_FOR_DSC;

	pc->callback = &idetape_pc_callback;

}
@@ -1964,7 +1976,7 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout) 
	int load_attempted = 0;



	/* Wait for the tape to become ready */

	set_bit(IDETAPE_MEDIUM_PRESENT, &tape->flags);

	set_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags);

	timeout += jiffies;

	while (time_before(jiffies, timeout)) {

		idetape_create_test_unit_ready_cmd(&pc);
@@ -2037,7 +2049,7 @@ static void idetape_create_locate_cmd(ide_drive_t *drive, idetape_pc_t *pc, 
	pc->c[1] = 2;

	put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[3]);

	pc->c[8] = partition;

	set_bit(PC_WAIT_FOR_DSC, &pc->flags);

	pc->flags |= PC_FLAG_WAIT_FOR_DSC;

	pc->callback = &idetape_pc_callback;

}
@@ -2068,7 +2080,7 @@ static int __idetape_discard_read_pipeline(ide_drive_t *drive) 


	/* Remove merge stage. */

	cnt = tape->merge_stage_size / tape->blk_size;

	if (test_and_clear_bit(IDETAPE_FILEMARK, &tape->flags))

	if (test_and_clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags))

		++cnt;		/* Filemarks count as 1 sector */

	tape->merge_stage_size = 0;

	if (tape->merge_stage != NULL) {
@@ -2077,7 +2089,7 @@ static int __idetape_discard_read_pipeline(ide_drive_t *drive) 
	}



	/* Clear pipeline flags. */

	clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags);

	clear_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags);

	tape->chrdev_dir = IDETAPE_DIR_NONE;



	/* Remove pipeline stages. */
@@ -2191,7 +2203,7 @@ static void idetape_plug_pipeline(ide_drive_t *drive) 
	if (tape->next_stage == NULL)

		return;

	if (!idetape_pipeline_active(tape)) {

		set_bit(IDETAPE_PIPELINE_ACTIVE, &tape->flags);

		set_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags);

		idetape_activate_next_stage(drive);

		(void) ide_do_drive_cmd(drive, tape->active_data_rq, ide_end);

	}
@@ -2210,7 +2222,7 @@ static void idetape_create_rewind_cmd(ide_drive_t *drive, idetape_pc_t *pc) 
{

	idetape_init_pc(pc);

	pc->c[0] = REZERO_UNIT;

	set_bit(PC_WAIT_FOR_DSC, &pc->flags);

	pc->flags |= PC_FLAG_WAIT_FOR_DSC;

	pc->callback = &idetape_pc_callback;

}
@@ -2219,7 +2231,7 @@ static void idetape_create_erase_cmd(idetape_pc_t *pc) 
	idetape_init_pc(pc);

	pc->c[0] = ERASE;

	pc->c[1] = 1;

	set_bit(PC_WAIT_FOR_DSC, &pc->flags);

	pc->flags |= PC_FLAG_WAIT_FOR_DSC;

	pc->callback = &idetape_pc_callback;

}
@@ -2229,7 +2241,7 @@ static void idetape_create_space_cmd(idetape_pc_t *pc, int count, u8 cmd) 
	pc->c[0] = SPACE;

	put_unaligned(cpu_to_be32(count), (unsigned int *) &pc->c[1]);

	pc->c[1] = cmd;

	set_bit(PC_WAIT_FOR_DSC, &pc->flags);

	pc->flags |= PC_FLAG_WAIT_FOR_DSC;

	pc->callback = &idetape_pc_callback;

}
@@ -2316,7 +2328,7 @@ static int idetape_add_chrdev_write_request(ide_drive_t *drive, int blocks) 
			idetape_plug_pipeline(drive);

		}

	}

	if (test_and_clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags))

	if (test_and_clear_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags))

		/* Return a deferred error */

		return -EIO;

	return blocks;
@@ -2392,7 +2404,7 @@ static void idetape_empty_write_pipeline(ide_drive_t *drive) 
		__idetape_kfree_stage(tape->merge_stage);

		tape->merge_stage = NULL;

	}

	clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags);

	clear_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags);

	tape->chrdev_dir = IDETAPE_DIR_NONE;



	/*
@@ -2480,7 +2492,7 @@ static int idetape_init_read(ide_drive_t *drive, int max_stages) 
	rq.sector = tape->first_frame;

	rq.nr_sectors = blocks;

	rq.current_nr_sectors = blocks;

	if (!test_bit(IDETAPE_PIPELINE_ERROR, &tape->flags) &&

	if (!test_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags) &&

	    tape->nr_stages < max_stages) {

		new_stage = idetape_kmalloc_stage(tape);

		while (new_stage != NULL) {
@@ -2517,13 +2529,13 @@ static int idetape_add_chrdev_read_request(ide_drive_t *drive, int blocks) 
	debug_log(DBG_PROCS, "Enter %s, %d blocks\n", __func__, blocks);



	/* If we are at a filemark, return a read length of 0 */

	if (test_bit(IDETAPE_FILEMARK, &tape->flags))

	if (test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags))

		return 0;



	/* Wait for the next block to reach the head of the pipeline. */

	idetape_init_read(drive, tape->max_stages);

	if (tape->first_stage == NULL) {

		if (test_bit(IDETAPE_PIPELINE_ERROR, &tape->flags))

		if (test_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags))

			return 0;

		return idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, blocks,

					tape->merge_stage->bh);
@@ -2540,7 +2552,7 @@ static int idetape_add_chrdev_read_request(ide_drive_t *drive, int blocks) 
	else {

		idetape_switch_buffers(tape, tape->first_stage);

		if (rq_ptr->errors == IDETAPE_ERROR_FILEMARK)

			set_bit(IDETAPE_FILEMARK, &tape->flags);

			set_bit(IDETAPE_FLAG_FILEMARK, &tape->flags);

		spin_lock_irqsave(&tape->lock, flags);

		idetape_remove_stage_head(drive);

		spin_unlock_irqrestore(&tape->lock, flags);
@@ -2687,12 +2699,13 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op, 
	if (tape->chrdev_dir == IDETAPE_DIR_READ) {

		/* its a read-ahead buffer, scan it for crossed filemarks. */

		tape->merge_stage_size = 0;

		if (test_and_clear_bit(IDETAPE_FILEMARK, &tape->flags))

		if (test_and_clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags))

			++count;

		while (tape->first_stage != NULL) {

			if (count == mt_count) {

				if (mt_op == MTFSFM)

					set_bit(IDETAPE_FILEMARK, &tape->flags);

					set_bit(IDETAPE_FLAG_FILEMARK,

						&tape->flags);

				return 0;

			}

			spin_lock_irqsave(&tape->lock, flags);
@@ -2776,7 +2789,7 @@ static ssize_t idetape_chrdev_read(struct file *file, char __user *buf, 
	debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count);



	if (tape->chrdev_dir != IDETAPE_DIR_READ) {

		if (test_bit(IDETAPE_DETECT_BS, &tape->flags))

		if (test_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags))

			if (count > tape->blk_size &&

			    (count % tape->blk_size) == 0)

				tape->user_bs_factor = count / tape->blk_size;
@@ -2819,7 +2832,7 @@ static ssize_t idetape_chrdev_read(struct file *file, char __user *buf, 
		tape->merge_stage_size = bytes_read-temp;

	}

finish:

	if (!actually_read && test_bit(IDETAPE_FILEMARK, &tape->flags)) {

	if (!actually_read && test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) {

		debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name);



		idetape_space_over_filemarks(drive, MTFSF, 1);
@@ -3012,7 +3025,7 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count) 
					      !IDETAPE_LU_LOAD_MASK);

		retval = idetape_queue_pc_tail(drive, &pc);

		if (!retval)

			clear_bit(IDETAPE_MEDIUM_PRESENT, &tape->flags);

			clear_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags);

		return retval;

	case MTNOP:

		idetape_discard_read_pipeline(drive, 0);
@@ -3035,9 +3048,9 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count) 
			    mt_count % tape->blk_size)

				return -EIO;

			tape->user_bs_factor = mt_count / tape->blk_size;

			clear_bit(IDETAPE_DETECT_BS, &tape->flags);

			clear_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags);

		} else

			set_bit(IDETAPE_DETECT_BS, &tape->flags);

			set_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags);

		return 0;

	case MTSEEK:

		idetape_discard_read_pipeline(drive, 0);
@@ -3185,24 +3198,24 @@ static int idetape_chrdev_open(struct inode *inode, struct file *filp) 


	filp->private_data = tape;



	if (test_and_set_bit(IDETAPE_BUSY, &tape->flags)) {

	if (test_and_set_bit(IDETAPE_FLAG_BUSY, &tape->flags)) {

		retval = -EBUSY;

		goto out_put_tape;

	}



	retval = idetape_wait_ready(drive, 60 * HZ);

	if (retval) {

		clear_bit(IDETAPE_BUSY, &tape->flags);

		clear_bit(IDETAPE_FLAG_BUSY, &tape->flags);

		printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name);

		goto out_put_tape;

	}



	idetape_read_position(drive);

	if (!test_bit(IDETAPE_ADDRESS_VALID, &tape->flags))

	if (!test_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags))

		(void)idetape_rewind_tape(drive);



	if (tape->chrdev_dir != IDETAPE_DIR_READ)

		clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags);

		clear_bit(IDETAPE_FLAG_PIPELINE_ERR, &tape->flags);



	/* Read block size and write protect status from drive. */

	ide_tape_get_bsize_from_bdesc(drive);
@@ -3217,7 +3230,7 @@ static int idetape_chrdev_open(struct inode *inode, struct file *filp) 
	if (tape->write_prot) {

		if ((filp->f_flags & O_ACCMODE) == O_WRONLY ||

		    (filp->f_flags & O_ACCMODE) == O_RDWR) {

			clear_bit(IDETAPE_BUSY, &tape->flags);

			clear_bit(IDETAPE_FLAG_BUSY, &tape->flags);

			retval = -EROFS;

			goto out_put_tape;

		}
@@ -3282,7 +3295,7 @@ static int idetape_chrdev_release(struct inode *inode, struct file *filp) 
		__idetape_kfree_stage(tape->cache_stage);

		tape->cache_stage = NULL;

	}

	if (minor < 128 && test_bit(IDETAPE_MEDIUM_PRESENT, &tape->flags))

	if (minor < 128 && test_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags))

		(void) idetape_rewind_tape(drive);

	if (tape->chrdev_dir == IDETAPE_DIR_NONE) {

		if (tape->door_locked == DOOR_LOCKED) {
@@ -3292,7 +3305,7 @@ static int idetape_chrdev_release(struct inode *inode, struct file *filp) 
			}

		}

	}

	clear_bit(IDETAPE_BUSY, &tape->flags);

	clear_bit(IDETAPE_FLAG_BUSY, &tape->flags);

	ide_tape_put(tape);

	unlock_kernel();

	return 0;
@@ -3496,7 +3509,7 @@ static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor) 


	/* Command packet DRQ type */

	if (((gcw[0] & 0x60) >> 5) == 1)

		set_bit(IDETAPE_DRQ_INTERRUPT, &tape->flags);

		set_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags);



	tape->min_pipeline = 10;

	tape->max_pipeline = 10;