OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ide-tape: convert to using the new atapi_flags 

There should be no functionality change resulting from this patch.

[bart: IDE_FLAG_* -> IDE_AFLAG_*, dev_flags -> atapi_flags]

Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
This commit is contained in:
Borislav Petkov 2008-07-23 19:56:01 +02:00 committed by Bartlomiej Zolnierkiewicz
parent ea68d270ff
commit f2e3ab52af
1 changed files with 23 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
drivers/ide/ide-tape.c
View File

@ -195,23 +195,6 @@ enum {
#define IDETAPE_BLOCK_DESCRIPTOR 0 #define IDETAPE_BLOCK_DESCRIPTOR 0
#define IDETAPE_CAPABILITIES_PAGE 0x2a #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),
/* Attempt to auto-detect the current user block size */
IDETAPE_FLAG_DETECT_BS = (1 << 3),
/* Currently on a filemark */
IDETAPE_FLAG_FILEMARK = (1 << 4),
/* DRQ interrupt device */
IDETAPE_FLAG_DRQ_INTERRUPT = (1 << 5),
/* 0 = no tape is loaded, so we don't rewind after ejecting */
IDETAPE_FLAG_MEDIUM_PRESENT = (1 << 6),
};
/* /*
* Most of our global data which we need to save even as we leave the driver due * Most of our global data which we need to save even as we leave the driver due
* to an interrupt or a timer event is stored in the struct defined below. * to an interrupt or a timer event is stored in the struct defined below.
@ -312,8 +295,6 @@ typedef struct ide_tape_obj {
/* Wasted space in each stage */ /* Wasted space in each stage */
int excess_bh_size; int excess_bh_size;
/* Status/Action flags: long for set_bit */
unsigned long flags;
/* protects the ide-tape queue */ /* protects the ide-tape queue */
spinlock_t lock; spinlock_t lock;
@ -664,7 +645,7 @@ static void ide_tape_callback(ide_drive_t *drive)
if (readpos[0] & 0x4) { if (readpos[0] & 0x4) {
printk(KERN_INFO "ide-tape: Block location is unknown" printk(KERN_INFO "ide-tape: Block location is unknown"
"to the tape\n"); "to the tape\n");
clear_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags); clear_bit(IDE_AFLAG_ADDRESS_VALID, &drive->atapi_flags);
uptodate = 0; uptodate = 0;
} else { } else {
debug_log(DBG_SENSE, "Block Location - %u\n", debug_log(DBG_SENSE, "Block Location - %u\n",
@ -672,7 +653,7 @@ static void ide_tape_callback(ide_drive_t *drive)
tape->partition = readpos[1]; tape->partition = readpos[1];
tape->first_frame = be32_to_cpu(*(u32 *)&readpos[4]); tape->first_frame = be32_to_cpu(*(u32 *)&readpos[4]);
set_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags); set_bit(IDE_AFLAG_ADDRESS_VALID, &drive->atapi_flags);
} }
} }
@ -741,7 +722,6 @@ static void idetape_queue_pc_head(ide_drive_t *drive, struct ide_atapi_pc *pc,
*/ */
static void idetape_retry_pc(ide_drive_t *drive) static void idetape_retry_pc(ide_drive_t *drive)
{ {
idetape_tape_t *tape = drive->driver_data;
struct ide_atapi_pc *pc; struct ide_atapi_pc *pc;
struct request *rq; struct request *rq;
@ -749,7 +729,7 @@ static void idetape_retry_pc(ide_drive_t *drive)
pc = idetape_next_pc_storage(drive); pc = idetape_next_pc_storage(drive);
rq = idetape_next_rq_storage(drive); rq = idetape_next_rq_storage(drive);
idetape_create_request_sense_cmd(pc); idetape_create_request_sense_cmd(pc);
set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags); set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags);
idetape_queue_pc_head(drive, pc, rq); idetape_queue_pc_head(drive, pc, rq);
} }
@ -1026,14 +1006,14 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
stat = hwif->tp_ops->read_status(hwif); stat = hwif->tp_ops->read_status(hwif);
if (!drive->dsc_overlap && !(rq->cmd[13] & REQ_IDETAPE_PC2)) if (!drive->dsc_overlap && !(rq->cmd[13] & REQ_IDETAPE_PC2))
set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags); set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags);
if (drive->post_reset == 1) { if (drive->post_reset == 1) {
set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags); set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags);
drive->post_reset = 0; drive->post_reset = 0;
} }
if (!test_and_clear_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags) && if (!test_and_clear_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags) &&
(stat & SEEK_STAT) == 0) { (stat & SEEK_STAT) == 0) {
if (postponed_rq == NULL) { if (postponed_rq == NULL) {
tape->dsc_polling_start = jiffies; tape->dsc_polling_start = jiffies;
@ -1076,10 +1056,8 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
return ide_stopped; return ide_stopped;
} }
BUG(); BUG();
out:
if (test_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags))
pc->flags |= PC_FLAG_DRQ_INTERRUPT;
out:
return idetape_issue_pc(drive, pc); return idetape_issue_pc(drive, pc);
} }
@ -1307,7 +1285,7 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
int load_attempted = 0; int load_attempted = 0;
/* Wait for the tape to become ready */ /* Wait for the tape to become ready */
set_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags); set_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags);
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);
@ -1400,7 +1378,7 @@ static void __ide_tape_discard_merge_buffer(ide_drive_t *drive)
if (tape->chrdev_dir != IDETAPE_DIR_READ) if (tape->chrdev_dir != IDETAPE_DIR_READ)
return; return;
clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags); clear_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags);
tape->merge_bh_size = 0; tape->merge_bh_size = 0;
if (tape->merge_bh != NULL) { if (tape->merge_bh != NULL) {
ide_tape_kfree_buffer(tape); ide_tape_kfree_buffer(tape);
@ -1639,7 +1617,7 @@ static int idetape_add_chrdev_read_request(ide_drive_t *drive, int blocks)
debug_log(DBG_PROCS, "Enter %s, %d blocks\n", __func__, 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 we are at a filemark, return a read length of 0 */
if (test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) if (test_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags))
return 0; return 0;
idetape_init_read(drive); idetape_init_read(drive);
@ -1749,7 +1727,7 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
if (tape->chrdev_dir == IDETAPE_DIR_READ) { if (tape->chrdev_dir == IDETAPE_DIR_READ) {
tape->merge_bh_size = 0; tape->merge_bh_size = 0;
if (test_and_clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) if (test_and_clear_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags))
++count; ++count;
ide_tape_discard_merge_buffer(drive, 0); ide_tape_discard_merge_buffer(drive, 0);
} }
@ -1804,7 +1782,7 @@ static ssize_t idetape_chrdev_read(struct file *file, char __user *buf,
debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count); debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count);
if (tape->chrdev_dir != IDETAPE_DIR_READ) { if (tape->chrdev_dir != IDETAPE_DIR_READ) {
if (test_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags)) if (test_bit(IDE_AFLAG_DETECT_BS, &drive->atapi_flags))
if (count > tape->blk_size && if (count > tape->blk_size &&
(count % tape->blk_size) == 0) (count % tape->blk_size) == 0)
tape->user_bs_factor = count / tape->blk_size; tape->user_bs_factor = count / tape->blk_size;
@ -1844,7 +1822,7 @@ static ssize_t idetape_chrdev_read(struct file *file, char __user *buf,
tape->merge_bh_size = bytes_read-temp; tape->merge_bh_size = bytes_read-temp;
} }
finish: finish:
if (!actually_read && test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) { if (!actually_read && test_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags)) {
debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name); debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name);
idetape_space_over_filemarks(drive, MTFSF, 1); idetape_space_over_filemarks(drive, MTFSF, 1);
@ -2030,7 +2008,7 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
!IDETAPE_LU_LOAD_MASK); !IDETAPE_LU_LOAD_MASK);
retval = idetape_queue_pc_tail(drive, &pc); retval = idetape_queue_pc_tail(drive, &pc);
if (!retval) if (!retval)
clear_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags); clear_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags);
return retval; return retval;
case MTNOP: case MTNOP:
ide_tape_discard_merge_buffer(drive, 0); ide_tape_discard_merge_buffer(drive, 0);
@ -2053,9 +2031,9 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
mt_count % tape->blk_size) mt_count % tape->blk_size)
return -EIO; return -EIO;
tape->user_bs_factor = mt_count / tape->blk_size; tape->user_bs_factor = mt_count / tape->blk_size;
clear_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags); clear_bit(IDE_AFLAG_DETECT_BS, &drive->atapi_flags);
} else } else
set_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags); set_bit(IDE_AFLAG_DETECT_BS, &drive->atapi_flags);
return 0; return 0;
case MTSEEK: case MTSEEK:
ide_tape_discard_merge_buffer(drive, 0); ide_tape_discard_merge_buffer(drive, 0);
@ -2205,20 +2183,20 @@ static int idetape_chrdev_open(struct inode *inode, struct file *filp)
filp->private_data = tape; filp->private_data = tape;
if (test_and_set_bit(IDETAPE_FLAG_BUSY, &tape->flags)) { if (test_and_set_bit(IDE_AFLAG_BUSY, &drive->atapi_flags)) {
retval = -EBUSY; retval = -EBUSY;
goto out_put_tape; goto out_put_tape;
} }
retval = idetape_wait_ready(drive, 60 * HZ); retval = idetape_wait_ready(drive, 60 * HZ);
if (retval) { if (retval) {
clear_bit(IDETAPE_FLAG_BUSY, &tape->flags); clear_bit(IDE_AFLAG_BUSY, &drive->atapi_flags);
printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name); printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name);
goto out_put_tape; goto out_put_tape;
} }
idetape_read_position(drive); idetape_read_position(drive);
if (!test_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags)) if (!test_bit(IDE_AFLAG_ADDRESS_VALID, &drive->atapi_flags))
(void)idetape_rewind_tape(drive); (void)idetape_rewind_tape(drive);
/* Read block size and write protect status from drive. */ /* Read block size and write protect status from drive. */
@ -2234,7 +2212,7 @@ static int idetape_chrdev_open(struct inode *inode, struct file *filp)
if (tape->write_prot) { if (tape->write_prot) {
if ((filp->f_flags & O_ACCMODE) == O_WRONLY || if ((filp->f_flags & O_ACCMODE) == O_WRONLY ||
(filp->f_flags & O_ACCMODE) == O_RDWR) { (filp->f_flags & O_ACCMODE) == O_RDWR) {
clear_bit(IDETAPE_FLAG_BUSY, &tape->flags); clear_bit(IDE_AFLAG_BUSY, &drive->atapi_flags);
retval = -EROFS; retval = -EROFS;
goto out_put_tape; goto out_put_tape;
} }
@ -2294,7 +2272,7 @@ static int idetape_chrdev_release(struct inode *inode, struct file *filp)
ide_tape_discard_merge_buffer(drive, 1); ide_tape_discard_merge_buffer(drive, 1);
} }
if (minor < 128 && test_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags)) if (minor < 128 && test_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags))
(void) idetape_rewind_tape(drive); (void) idetape_rewind_tape(drive);
if (tape->chrdev_dir == IDETAPE_DIR_NONE) { if (tape->chrdev_dir == IDETAPE_DIR_NONE) {
if (tape->door_locked == DOOR_LOCKED) { if (tape->door_locked == DOOR_LOCKED) {
@ -2304,7 +2282,7 @@ static int idetape_chrdev_release(struct inode *inode, struct file *filp)
} }
} }
} }
clear_bit(IDETAPE_FLAG_BUSY, &tape->flags); clear_bit(IDE_AFLAG_BUSY, &drive->atapi_flags);
ide_tape_put(tape); ide_tape_put(tape);
unlock_kernel(); unlock_kernel();
return 0; return 0;
@ -2489,7 +2467,7 @@ static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor)
/* Command packet DRQ type */ /* Command packet DRQ type */
if (((gcw[0] & 0x60) >> 5) == 1) if (((gcw[0] & 0x60) >> 5) == 1)
set_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags); set_bit(IDE_AFLAG_DRQ_INTERRUPT, &drive->atapi_flags);
idetape_get_inquiry_results(drive); idetape_get_inquiry_results(drive);
idetape_get_mode_sense_results(drive); idetape_get_mode_sense_results(drive);