From 346331f82823682fb5c2df6e827db25d95cc2e92 Mon Sep 17 00:00:00 2001 From: Borislav Petkov Date: Fri, 18 Apr 2008 00:46:26 +0200 Subject: [PATCH] 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: Borislav Petkov Signed-off-by: Bartlomiej Zolnierkiewicz --- drivers/ide/ide-tape.c | 207 ++++++++++++++++++++++------------------- 1 file changed, 110 insertions(+), 97 deletions(-) diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c index b34d1bb94e5..ce3a23e18ce 100644 --- a/drivers/ide/ide-tape.c +++ b/drivers/ide/ide-tape.c @@ -209,21 +209,21 @@ typedef struct idetape_packet_command_s { unsigned long flags; } idetape_pc_t; -/* - * Packet command flag bits. - */ -/* Set when an error is considered normal - We won't retry */ -#define PC_ABORT 0 -/* 1 When polling for DSC on a media access command */ -#define PC_WAIT_FOR_DSC 1 -/* 1 when we prefer to use DMA if possible */ -#define PC_DMA_RECOMMENDED 2 -/* 1 while DMA in progress */ -#define PC_DMA_IN_PROGRESS 3 -/* 1 when encountered problem during DMA */ -#define PC_DMA_ERROR 4 -/* Data direction */ -#define PC_WRITING 5 +/* Packet command flag bits. */ +enum { + /* Set when an error is considered normal - We won't retry */ + PC_FLAG_ABORT = (1 << 0), + /* 1 When polling for DSC on a media access command */ + PC_FLAG_WAIT_FOR_DSC = (1 << 1), + /* 1 when we prefer to use DMA if possible */ + PC_FLAG_DMA_RECOMMENDED = (1 << 2), + /* 1 while DMA in progress */ + PC_FLAG_DMA_IN_PROGRESS = (1 << 3), + /* 1 when encountered problem during DMA */ + PC_FLAG_DMA_ERROR = (1 << 4), + /* Data direction */ + 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; -- 2.41.0