diff options
Diffstat (limited to 'drivers/ide/ide-tape.c')
-rw-r--r-- | drivers/ide/ide-tape.c | 127 |
1 files changed, 55 insertions, 72 deletions
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c index 353dd11b9283..6962ca4891a1 100644 --- a/drivers/ide/ide-tape.c +++ b/drivers/ide/ide-tape.c | |||
@@ -195,23 +195,6 @@ enum { | |||
195 | #define IDETAPE_BLOCK_DESCRIPTOR 0 | 195 | #define IDETAPE_BLOCK_DESCRIPTOR 0 |
196 | #define IDETAPE_CAPABILITIES_PAGE 0x2a | 196 | #define IDETAPE_CAPABILITIES_PAGE 0x2a |
197 | 197 | ||
198 | /* Tape flag bits values. */ | ||
199 | enum { | ||
200 | IDETAPE_FLAG_IGNORE_DSC = (1 << 0), | ||
201 | /* 0 When the tape position is unknown */ | ||
202 | IDETAPE_FLAG_ADDRESS_VALID = (1 << 1), | ||
203 | /* Device already opened */ | ||
204 | IDETAPE_FLAG_BUSY = (1 << 2), | ||
205 | /* Attempt to auto-detect the current user block size */ | ||
206 | IDETAPE_FLAG_DETECT_BS = (1 << 3), | ||
207 | /* Currently on a filemark */ | ||
208 | IDETAPE_FLAG_FILEMARK = (1 << 4), | ||
209 | /* DRQ interrupt device */ | ||
210 | IDETAPE_FLAG_DRQ_INTERRUPT = (1 << 5), | ||
211 | /* 0 = no tape is loaded, so we don't rewind after ejecting */ | ||
212 | IDETAPE_FLAG_MEDIUM_PRESENT = (1 << 6), | ||
213 | }; | ||
214 | |||
215 | /* | 198 | /* |
216 | * Most of our global data which we need to save even as we leave the driver due | 199 | * Most of our global data which we need to save even as we leave the driver due |
217 | * to an interrupt or a timer event is stored in the struct defined below. | 200 | * to an interrupt or a timer event is stored in the struct defined below. |
@@ -312,8 +295,6 @@ typedef struct ide_tape_obj { | |||
312 | /* Wasted space in each stage */ | 295 | /* Wasted space in each stage */ |
313 | int excess_bh_size; | 296 | int excess_bh_size; |
314 | 297 | ||
315 | /* Status/Action flags: long for set_bit */ | ||
316 | unsigned long flags; | ||
317 | /* protects the ide-tape queue */ | 298 | /* protects the ide-tape queue */ |
318 | spinlock_t lock; | 299 | spinlock_t lock; |
319 | 300 | ||
@@ -398,7 +379,7 @@ static void idetape_input_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, | |||
398 | count = min( | 379 | count = min( |
399 | (unsigned int)(bh->b_size - atomic_read(&bh->b_count)), | 380 | (unsigned int)(bh->b_size - atomic_read(&bh->b_count)), |
400 | bcount); | 381 | bcount); |
401 | drive->hwif->input_data(drive, NULL, bh->b_data + | 382 | drive->hwif->tp_ops->input_data(drive, NULL, bh->b_data + |
402 | atomic_read(&bh->b_count), count); | 383 | atomic_read(&bh->b_count), count); |
403 | bcount -= count; | 384 | bcount -= count; |
404 | atomic_add(count, &bh->b_count); | 385 | atomic_add(count, &bh->b_count); |
@@ -424,7 +405,7 @@ static void idetape_output_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, | |||
424 | return; | 405 | return; |
425 | } | 406 | } |
426 | count = min((unsigned int)pc->b_count, (unsigned int)bcount); | 407 | count = min((unsigned int)pc->b_count, (unsigned int)bcount); |
427 | drive->hwif->output_data(drive, NULL, pc->b_data, count); | 408 | drive->hwif->tp_ops->output_data(drive, NULL, pc->b_data, count); |
428 | bcount -= count; | 409 | bcount -= count; |
429 | pc->b_data += count; | 410 | pc->b_data += count; |
430 | pc->b_count -= count; | 411 | pc->b_count -= count; |
@@ -585,7 +566,6 @@ static void ide_tape_kfree_buffer(idetape_tape_t *tape) | |||
585 | bh = bh->b_reqnext; | 566 | bh = bh->b_reqnext; |
586 | kfree(prev_bh); | 567 | kfree(prev_bh); |
587 | } | 568 | } |
588 | kfree(tape->merge_bh); | ||
589 | } | 569 | } |
590 | 570 | ||
591 | static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects) | 571 | static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects) |
@@ -665,7 +645,7 @@ static void ide_tape_callback(ide_drive_t *drive) | |||
665 | if (readpos[0] & 0x4) { | 645 | if (readpos[0] & 0x4) { |
666 | printk(KERN_INFO "ide-tape: Block location is unknown" | 646 | printk(KERN_INFO "ide-tape: Block location is unknown" |
667 | "to the tape\n"); | 647 | "to the tape\n"); |
668 | clear_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags); | 648 | clear_bit(IDE_AFLAG_ADDRESS_VALID, &drive->atapi_flags); |
669 | uptodate = 0; | 649 | uptodate = 0; |
670 | } else { | 650 | } else { |
671 | debug_log(DBG_SENSE, "Block Location - %u\n", | 651 | debug_log(DBG_SENSE, "Block Location - %u\n", |
@@ -673,7 +653,7 @@ static void ide_tape_callback(ide_drive_t *drive) | |||
673 | 653 | ||
674 | tape->partition = readpos[1]; | 654 | tape->partition = readpos[1]; |
675 | tape->first_frame = be32_to_cpu(*(u32 *)&readpos[4]); | 655 | tape->first_frame = be32_to_cpu(*(u32 *)&readpos[4]); |
676 | set_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags); | 656 | set_bit(IDE_AFLAG_ADDRESS_VALID, &drive->atapi_flags); |
677 | } | 657 | } |
678 | } | 658 | } |
679 | 659 | ||
@@ -690,7 +670,6 @@ static void idetape_init_pc(struct ide_atapi_pc *pc) | |||
690 | pc->buf_size = IDETAPE_PC_BUFFER_SIZE; | 670 | pc->buf_size = IDETAPE_PC_BUFFER_SIZE; |
691 | pc->bh = NULL; | 671 | pc->bh = NULL; |
692 | pc->b_data = NULL; | 672 | pc->b_data = NULL; |
693 | pc->callback = ide_tape_callback; | ||
694 | } | 673 | } |
695 | 674 | ||
696 | static void idetape_create_request_sense_cmd(struct ide_atapi_pc *pc) | 675 | static void idetape_create_request_sense_cmd(struct ide_atapi_pc *pc) |
@@ -705,7 +684,7 @@ static void idetape_init_rq(struct request *rq, u8 cmd) | |||
705 | { | 684 | { |
706 | blk_rq_init(NULL, rq); | 685 | blk_rq_init(NULL, rq); |
707 | rq->cmd_type = REQ_TYPE_SPECIAL; | 686 | rq->cmd_type = REQ_TYPE_SPECIAL; |
708 | rq->cmd[0] = cmd; | 687 | rq->cmd[13] = cmd; |
709 | } | 688 | } |
710 | 689 | ||
711 | /* | 690 | /* |
@@ -732,6 +711,7 @@ static void idetape_queue_pc_head(ide_drive_t *drive, struct ide_atapi_pc *pc, | |||
732 | rq->cmd_flags |= REQ_PREEMPT; | 711 | rq->cmd_flags |= REQ_PREEMPT; |
733 | rq->buffer = (char *) pc; | 712 | rq->buffer = (char *) pc; |
734 | rq->rq_disk = tape->disk; | 713 | rq->rq_disk = tape->disk; |
714 | memcpy(rq->cmd, pc->c, 12); | ||
735 | ide_do_drive_cmd(drive, rq); | 715 | ide_do_drive_cmd(drive, rq); |
736 | } | 716 | } |
737 | 717 | ||
@@ -742,7 +722,6 @@ static void idetape_queue_pc_head(ide_drive_t *drive, struct ide_atapi_pc *pc, | |||
742 | */ | 722 | */ |
743 | static void idetape_retry_pc(ide_drive_t *drive) | 723 | static void idetape_retry_pc(ide_drive_t *drive) |
744 | { | 724 | { |
745 | idetape_tape_t *tape = drive->driver_data; | ||
746 | struct ide_atapi_pc *pc; | 725 | struct ide_atapi_pc *pc; |
747 | struct request *rq; | 726 | struct request *rq; |
748 | 727 | ||
@@ -750,7 +729,7 @@ static void idetape_retry_pc(ide_drive_t *drive) | |||
750 | pc = idetape_next_pc_storage(drive); | 729 | pc = idetape_next_pc_storage(drive); |
751 | rq = idetape_next_rq_storage(drive); | 730 | rq = idetape_next_rq_storage(drive); |
752 | idetape_create_request_sense_cmd(pc); | 731 | idetape_create_request_sense_cmd(pc); |
753 | set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags); | 732 | set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags); |
754 | idetape_queue_pc_head(drive, pc, rq); | 733 | idetape_queue_pc_head(drive, pc, rq); |
755 | } | 734 | } |
756 | 735 | ||
@@ -887,7 +866,7 @@ static ide_startstop_t idetape_issue_pc(ide_drive_t *drive, | |||
887 | pc->error = IDETAPE_ERROR_GENERAL; | 866 | pc->error = IDETAPE_ERROR_GENERAL; |
888 | } | 867 | } |
889 | tape->failed_pc = NULL; | 868 | tape->failed_pc = NULL; |
890 | pc->callback(drive); | 869 | drive->pc_callback(drive); |
891 | return ide_stopped; | 870 | return ide_stopped; |
892 | } | 871 | } |
893 | debug_log(DBG_SENSE, "Retry #%d, cmd = %02X\n", pc->retries, pc->c[0]); | 872 | debug_log(DBG_SENSE, "Retry #%d, cmd = %02X\n", pc->retries, pc->c[0]); |
@@ -927,11 +906,12 @@ static void idetape_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code) | |||
927 | 906 | ||
928 | static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive) | 907 | static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive) |
929 | { | 908 | { |
909 | ide_hwif_t *hwif = drive->hwif; | ||
930 | idetape_tape_t *tape = drive->driver_data; | 910 | idetape_tape_t *tape = drive->driver_data; |
931 | struct ide_atapi_pc *pc = tape->pc; | 911 | struct ide_atapi_pc *pc = tape->pc; |
932 | u8 stat; | 912 | u8 stat; |
933 | 913 | ||
934 | stat = ide_read_status(drive); | 914 | stat = hwif->tp_ops->read_status(hwif); |
935 | 915 | ||
936 | if (stat & SEEK_STAT) { | 916 | if (stat & SEEK_STAT) { |
937 | if (stat & ERR_STAT) { | 917 | if (stat & ERR_STAT) { |
@@ -948,14 +928,17 @@ static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive) | |||
948 | pc->error = IDETAPE_ERROR_GENERAL; | 928 | pc->error = IDETAPE_ERROR_GENERAL; |
949 | tape->failed_pc = NULL; | 929 | tape->failed_pc = NULL; |
950 | } | 930 | } |
951 | pc->callback(drive); | 931 | drive->pc_callback(drive); |
952 | return ide_stopped; | 932 | return ide_stopped; |
953 | } | 933 | } |
954 | 934 | ||
955 | static void ide_tape_create_rw_cmd(idetape_tape_t *tape, | 935 | static void ide_tape_create_rw_cmd(idetape_tape_t *tape, |
956 | struct ide_atapi_pc *pc, unsigned int length, | 936 | struct ide_atapi_pc *pc, struct request *rq, |
957 | struct idetape_bh *bh, u8 opcode) | 937 | u8 opcode) |
958 | { | 938 | { |
939 | struct idetape_bh *bh = (struct idetape_bh *)rq->special; | ||
940 | unsigned int length = rq->current_nr_sectors; | ||
941 | |||
959 | idetape_init_pc(pc); | 942 | idetape_init_pc(pc); |
960 | put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); | 943 | put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); |
961 | pc->c[1] = 1; | 944 | pc->c[1] = 1; |
@@ -975,11 +958,14 @@ static void ide_tape_create_rw_cmd(idetape_tape_t *tape, | |||
975 | pc->b_data = bh->b_data; | 958 | pc->b_data = bh->b_data; |
976 | pc->b_count = atomic_read(&bh->b_count); | 959 | pc->b_count = atomic_read(&bh->b_count); |
977 | } | 960 | } |
961 | |||
962 | memcpy(rq->cmd, pc->c, 12); | ||
978 | } | 963 | } |
979 | 964 | ||
980 | static ide_startstop_t idetape_do_request(ide_drive_t *drive, | 965 | static ide_startstop_t idetape_do_request(ide_drive_t *drive, |
981 | struct request *rq, sector_t block) | 966 | struct request *rq, sector_t block) |
982 | { | 967 | { |
968 | ide_hwif_t *hwif = drive->hwif; | ||
983 | idetape_tape_t *tape = drive->driver_data; | 969 | idetape_tape_t *tape = drive->driver_data; |
984 | struct ide_atapi_pc *pc = NULL; | 970 | struct ide_atapi_pc *pc = NULL; |
985 | struct request *postponed_rq = tape->postponed_rq; | 971 | struct request *postponed_rq = tape->postponed_rq; |
@@ -1017,17 +1003,17 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive, | |||
1017 | * If the tape is still busy, postpone our request and service | 1003 | * If the tape is still busy, postpone our request and service |
1018 | * the other device meanwhile. | 1004 | * the other device meanwhile. |
1019 | */ | 1005 | */ |
1020 | stat = ide_read_status(drive); | 1006 | stat = hwif->tp_ops->read_status(hwif); |
1021 | 1007 | ||
1022 | if (!drive->dsc_overlap && !(rq->cmd[0] & REQ_IDETAPE_PC2)) | 1008 | if (!drive->dsc_overlap && !(rq->cmd[13] & REQ_IDETAPE_PC2)) |
1023 | set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags); | 1009 | set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags); |
1024 | 1010 | ||
1025 | if (drive->post_reset == 1) { | 1011 | if (drive->post_reset == 1) { |
1026 | set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags); | 1012 | set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags); |
1027 | drive->post_reset = 0; | 1013 | drive->post_reset = 0; |
1028 | } | 1014 | } |
1029 | 1015 | ||
1030 | if (!test_and_clear_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags) && | 1016 | if (!test_and_clear_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags) && |
1031 | (stat & SEEK_STAT) == 0) { | 1017 | (stat & SEEK_STAT) == 0) { |
1032 | if (postponed_rq == NULL) { | 1018 | if (postponed_rq == NULL) { |
1033 | tape->dsc_polling_start = jiffies; | 1019 | tape->dsc_polling_start = jiffies; |
@@ -1036,7 +1022,7 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive, | |||
1036 | } else if (time_after(jiffies, tape->dsc_timeout)) { | 1022 | } else if (time_after(jiffies, tape->dsc_timeout)) { |
1037 | printk(KERN_ERR "ide-tape: %s: DSC timeout\n", | 1023 | printk(KERN_ERR "ide-tape: %s: DSC timeout\n", |
1038 | tape->name); | 1024 | tape->name); |
1039 | if (rq->cmd[0] & REQ_IDETAPE_PC2) { | 1025 | if (rq->cmd[13] & REQ_IDETAPE_PC2) { |
1040 | idetape_media_access_finished(drive); | 1026 | idetape_media_access_finished(drive); |
1041 | return ide_stopped; | 1027 | return ide_stopped; |
1042 | } else { | 1028 | } else { |
@@ -1049,35 +1035,29 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive, | |||
1049 | idetape_postpone_request(drive); | 1035 | idetape_postpone_request(drive); |
1050 | return ide_stopped; | 1036 | return ide_stopped; |
1051 | } | 1037 | } |
1052 | if (rq->cmd[0] & REQ_IDETAPE_READ) { | 1038 | if (rq->cmd[13] & REQ_IDETAPE_READ) { |
1053 | pc = idetape_next_pc_storage(drive); | 1039 | pc = idetape_next_pc_storage(drive); |
1054 | ide_tape_create_rw_cmd(tape, pc, rq->current_nr_sectors, | 1040 | ide_tape_create_rw_cmd(tape, pc, rq, READ_6); |
1055 | (struct idetape_bh *)rq->special, | ||
1056 | READ_6); | ||
1057 | goto out; | 1041 | goto out; |
1058 | } | 1042 | } |
1059 | if (rq->cmd[0] & REQ_IDETAPE_WRITE) { | 1043 | if (rq->cmd[13] & REQ_IDETAPE_WRITE) { |
1060 | pc = idetape_next_pc_storage(drive); | 1044 | pc = idetape_next_pc_storage(drive); |
1061 | ide_tape_create_rw_cmd(tape, pc, rq->current_nr_sectors, | 1045 | ide_tape_create_rw_cmd(tape, pc, rq, WRITE_6); |
1062 | (struct idetape_bh *)rq->special, | ||
1063 | WRITE_6); | ||
1064 | goto out; | 1046 | goto out; |
1065 | } | 1047 | } |
1066 | if (rq->cmd[0] & REQ_IDETAPE_PC1) { | 1048 | if (rq->cmd[13] & REQ_IDETAPE_PC1) { |
1067 | pc = (struct ide_atapi_pc *) rq->buffer; | 1049 | pc = (struct ide_atapi_pc *) rq->buffer; |
1068 | rq->cmd[0] &= ~(REQ_IDETAPE_PC1); | 1050 | rq->cmd[13] &= ~(REQ_IDETAPE_PC1); |
1069 | rq->cmd[0] |= REQ_IDETAPE_PC2; | 1051 | rq->cmd[13] |= REQ_IDETAPE_PC2; |
1070 | goto out; | 1052 | goto out; |
1071 | } | 1053 | } |
1072 | if (rq->cmd[0] & REQ_IDETAPE_PC2) { | 1054 | if (rq->cmd[13] & REQ_IDETAPE_PC2) { |
1073 | idetape_media_access_finished(drive); | 1055 | idetape_media_access_finished(drive); |
1074 | return ide_stopped; | 1056 | return ide_stopped; |
1075 | } | 1057 | } |
1076 | BUG(); | 1058 | BUG(); |
1077 | out: | ||
1078 | if (test_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags)) | ||
1079 | pc->flags |= PC_FLAG_DRQ_INTERRUPT; | ||
1080 | 1059 | ||
1060 | out: | ||
1081 | return idetape_issue_pc(drive, pc); | 1061 | return idetape_issue_pc(drive, pc); |
1082 | } | 1062 | } |
1083 | 1063 | ||
@@ -1281,8 +1261,9 @@ static int idetape_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc) | |||
1281 | 1261 | ||
1282 | rq = blk_get_request(drive->queue, READ, __GFP_WAIT); | 1262 | rq = blk_get_request(drive->queue, READ, __GFP_WAIT); |
1283 | rq->cmd_type = REQ_TYPE_SPECIAL; | 1263 | rq->cmd_type = REQ_TYPE_SPECIAL; |
1284 | rq->cmd[0] = REQ_IDETAPE_PC1; | 1264 | rq->cmd[13] = REQ_IDETAPE_PC1; |
1285 | rq->buffer = (char *)pc; | 1265 | rq->buffer = (char *)pc; |
1266 | memcpy(rq->cmd, pc->c, 12); | ||
1286 | error = blk_execute_rq(drive->queue, tape->disk, rq, 0); | 1267 | error = blk_execute_rq(drive->queue, tape->disk, rq, 0); |
1287 | blk_put_request(rq); | 1268 | blk_put_request(rq); |
1288 | return error; | 1269 | return error; |
@@ -1304,7 +1285,7 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout) | |||
1304 | int load_attempted = 0; | 1285 | int load_attempted = 0; |
1305 | 1286 | ||
1306 | /* Wait for the tape to become ready */ | 1287 | /* Wait for the tape to become ready */ |
1307 | set_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags); | 1288 | set_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags); |
1308 | timeout += jiffies; | 1289 | timeout += jiffies; |
1309 | while (time_before(jiffies, timeout)) { | 1290 | while (time_before(jiffies, timeout)) { |
1310 | idetape_create_test_unit_ready_cmd(&pc); | 1291 | idetape_create_test_unit_ready_cmd(&pc); |
@@ -1397,7 +1378,7 @@ static void __ide_tape_discard_merge_buffer(ide_drive_t *drive) | |||
1397 | if (tape->chrdev_dir != IDETAPE_DIR_READ) | 1378 | if (tape->chrdev_dir != IDETAPE_DIR_READ) |
1398 | return; | 1379 | return; |
1399 | 1380 | ||
1400 | clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags); | 1381 | clear_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags); |
1401 | tape->merge_bh_size = 0; | 1382 | tape->merge_bh_size = 0; |
1402 | if (tape->merge_bh != NULL) { | 1383 | if (tape->merge_bh != NULL) { |
1403 | ide_tape_kfree_buffer(tape); | 1384 | ide_tape_kfree_buffer(tape); |
@@ -1465,7 +1446,7 @@ static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int blocks, | |||
1465 | 1446 | ||
1466 | rq = blk_get_request(drive->queue, READ, __GFP_WAIT); | 1447 | rq = blk_get_request(drive->queue, READ, __GFP_WAIT); |
1467 | rq->cmd_type = REQ_TYPE_SPECIAL; | 1448 | rq->cmd_type = REQ_TYPE_SPECIAL; |
1468 | rq->cmd[0] = cmd; | 1449 | rq->cmd[13] = cmd; |
1469 | rq->rq_disk = tape->disk; | 1450 | rq->rq_disk = tape->disk; |
1470 | rq->special = (void *)bh; | 1451 | rq->special = (void *)bh; |
1471 | rq->sector = tape->first_frame; | 1452 | rq->sector = tape->first_frame; |
@@ -1636,7 +1617,7 @@ static int idetape_add_chrdev_read_request(ide_drive_t *drive, int blocks) | |||
1636 | debug_log(DBG_PROCS, "Enter %s, %d blocks\n", __func__, blocks); | 1617 | debug_log(DBG_PROCS, "Enter %s, %d blocks\n", __func__, blocks); |
1637 | 1618 | ||
1638 | /* If we are at a filemark, return a read length of 0 */ | 1619 | /* If we are at a filemark, return a read length of 0 */ |
1639 | if (test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) | 1620 | if (test_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags)) |
1640 | return 0; | 1621 | return 0; |
1641 | 1622 | ||
1642 | idetape_init_read(drive); | 1623 | idetape_init_read(drive); |
@@ -1746,7 +1727,7 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op, | |||
1746 | 1727 | ||
1747 | if (tape->chrdev_dir == IDETAPE_DIR_READ) { | 1728 | if (tape->chrdev_dir == IDETAPE_DIR_READ) { |
1748 | tape->merge_bh_size = 0; | 1729 | tape->merge_bh_size = 0; |
1749 | if (test_and_clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) | 1730 | if (test_and_clear_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags)) |
1750 | ++count; | 1731 | ++count; |
1751 | ide_tape_discard_merge_buffer(drive, 0); | 1732 | ide_tape_discard_merge_buffer(drive, 0); |
1752 | } | 1733 | } |
@@ -1801,7 +1782,7 @@ static ssize_t idetape_chrdev_read(struct file *file, char __user *buf, | |||
1801 | debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count); | 1782 | debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count); |
1802 | 1783 | ||
1803 | if (tape->chrdev_dir != IDETAPE_DIR_READ) { | 1784 | if (tape->chrdev_dir != IDETAPE_DIR_READ) { |
1804 | if (test_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags)) | 1785 | if (test_bit(IDE_AFLAG_DETECT_BS, &drive->atapi_flags)) |
1805 | if (count > tape->blk_size && | 1786 | if (count > tape->blk_size && |
1806 | (count % tape->blk_size) == 0) | 1787 | (count % tape->blk_size) == 0) |
1807 | tape->user_bs_factor = count / tape->blk_size; | 1788 | tape->user_bs_factor = count / tape->blk_size; |
@@ -1841,7 +1822,7 @@ static ssize_t idetape_chrdev_read(struct file *file, char __user *buf, | |||
1841 | tape->merge_bh_size = bytes_read-temp; | 1822 | tape->merge_bh_size = bytes_read-temp; |
1842 | } | 1823 | } |
1843 | finish: | 1824 | finish: |
1844 | if (!actually_read && test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) { | 1825 | if (!actually_read && test_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags)) { |
1845 | debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name); | 1826 | debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name); |
1846 | 1827 | ||
1847 | idetape_space_over_filemarks(drive, MTFSF, 1); | 1828 | idetape_space_over_filemarks(drive, MTFSF, 1); |
@@ -2027,7 +2008,7 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count) | |||
2027 | !IDETAPE_LU_LOAD_MASK); | 2008 | !IDETAPE_LU_LOAD_MASK); |
2028 | retval = idetape_queue_pc_tail(drive, &pc); | 2009 | retval = idetape_queue_pc_tail(drive, &pc); |
2029 | if (!retval) | 2010 | if (!retval) |
2030 | clear_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags); | 2011 | clear_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags); |
2031 | return retval; | 2012 | return retval; |
2032 | case MTNOP: | 2013 | case MTNOP: |
2033 | ide_tape_discard_merge_buffer(drive, 0); | 2014 | ide_tape_discard_merge_buffer(drive, 0); |
@@ -2050,9 +2031,9 @@ static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count) | |||
2050 | mt_count % tape->blk_size) | 2031 | mt_count % tape->blk_size) |
2051 | return -EIO; | 2032 | return -EIO; |
2052 | tape->user_bs_factor = mt_count / tape->blk_size; | 2033 | tape->user_bs_factor = mt_count / tape->blk_size; |
2053 | clear_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags); | 2034 | clear_bit(IDE_AFLAG_DETECT_BS, &drive->atapi_flags); |
2054 | } else | 2035 | } else |
2055 | set_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags); | 2036 | set_bit(IDE_AFLAG_DETECT_BS, &drive->atapi_flags); |
2056 | return 0; | 2037 | return 0; |
2057 | case MTSEEK: | 2038 | case MTSEEK: |
2058 | ide_tape_discard_merge_buffer(drive, 0); | 2039 | ide_tape_discard_merge_buffer(drive, 0); |
@@ -2202,20 +2183,20 @@ static int idetape_chrdev_open(struct inode *inode, struct file *filp) | |||
2202 | 2183 | ||
2203 | filp->private_data = tape; | 2184 | filp->private_data = tape; |
2204 | 2185 | ||
2205 | if (test_and_set_bit(IDETAPE_FLAG_BUSY, &tape->flags)) { | 2186 | if (test_and_set_bit(IDE_AFLAG_BUSY, &drive->atapi_flags)) { |
2206 | retval = -EBUSY; | 2187 | retval = -EBUSY; |
2207 | goto out_put_tape; | 2188 | goto out_put_tape; |
2208 | } | 2189 | } |
2209 | 2190 | ||
2210 | retval = idetape_wait_ready(drive, 60 * HZ); | 2191 | retval = idetape_wait_ready(drive, 60 * HZ); |
2211 | if (retval) { | 2192 | if (retval) { |
2212 | clear_bit(IDETAPE_FLAG_BUSY, &tape->flags); | 2193 | clear_bit(IDE_AFLAG_BUSY, &drive->atapi_flags); |
2213 | printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name); | 2194 | printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name); |
2214 | goto out_put_tape; | 2195 | goto out_put_tape; |
2215 | } | 2196 | } |
2216 | 2197 | ||
2217 | idetape_read_position(drive); | 2198 | idetape_read_position(drive); |
2218 | if (!test_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags)) | 2199 | if (!test_bit(IDE_AFLAG_ADDRESS_VALID, &drive->atapi_flags)) |
2219 | (void)idetape_rewind_tape(drive); | 2200 | (void)idetape_rewind_tape(drive); |
2220 | 2201 | ||
2221 | /* Read block size and write protect status from drive. */ | 2202 | /* Read block size and write protect status from drive. */ |
@@ -2231,7 +2212,7 @@ static int idetape_chrdev_open(struct inode *inode, struct file *filp) | |||
2231 | if (tape->write_prot) { | 2212 | if (tape->write_prot) { |
2232 | if ((filp->f_flags & O_ACCMODE) == O_WRONLY || | 2213 | if ((filp->f_flags & O_ACCMODE) == O_WRONLY || |
2233 | (filp->f_flags & O_ACCMODE) == O_RDWR) { | 2214 | (filp->f_flags & O_ACCMODE) == O_RDWR) { |
2234 | clear_bit(IDETAPE_FLAG_BUSY, &tape->flags); | 2215 | clear_bit(IDE_AFLAG_BUSY, &drive->atapi_flags); |
2235 | retval = -EROFS; | 2216 | retval = -EROFS; |
2236 | goto out_put_tape; | 2217 | goto out_put_tape; |
2237 | } | 2218 | } |
@@ -2291,7 +2272,7 @@ static int idetape_chrdev_release(struct inode *inode, struct file *filp) | |||
2291 | ide_tape_discard_merge_buffer(drive, 1); | 2272 | ide_tape_discard_merge_buffer(drive, 1); |
2292 | } | 2273 | } |
2293 | 2274 | ||
2294 | if (minor < 128 && test_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags)) | 2275 | if (minor < 128 && test_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags)) |
2295 | (void) idetape_rewind_tape(drive); | 2276 | (void) idetape_rewind_tape(drive); |
2296 | if (tape->chrdev_dir == IDETAPE_DIR_NONE) { | 2277 | if (tape->chrdev_dir == IDETAPE_DIR_NONE) { |
2297 | if (tape->door_locked == DOOR_LOCKED) { | 2278 | if (tape->door_locked == DOOR_LOCKED) { |
@@ -2301,7 +2282,7 @@ static int idetape_chrdev_release(struct inode *inode, struct file *filp) | |||
2301 | } | 2282 | } |
2302 | } | 2283 | } |
2303 | } | 2284 | } |
2304 | clear_bit(IDETAPE_FLAG_BUSY, &tape->flags); | 2285 | clear_bit(IDE_AFLAG_BUSY, &drive->atapi_flags); |
2305 | ide_tape_put(tape); | 2286 | ide_tape_put(tape); |
2306 | unlock_kernel(); | 2287 | unlock_kernel(); |
2307 | return 0; | 2288 | return 0; |
@@ -2464,6 +2445,8 @@ static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor) | |||
2464 | u8 gcw[2]; | 2445 | u8 gcw[2]; |
2465 | u16 *ctl = (u16 *)&tape->caps[12]; | 2446 | u16 *ctl = (u16 *)&tape->caps[12]; |
2466 | 2447 | ||
2448 | drive->pc_callback = ide_tape_callback; | ||
2449 | |||
2467 | spin_lock_init(&tape->lock); | 2450 | spin_lock_init(&tape->lock); |
2468 | drive->dsc_overlap = 1; | 2451 | drive->dsc_overlap = 1; |
2469 | if (drive->hwif->host_flags & IDE_HFLAG_NO_DSC) { | 2452 | if (drive->hwif->host_flags & IDE_HFLAG_NO_DSC) { |
@@ -2484,7 +2467,7 @@ static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor) | |||
2484 | 2467 | ||
2485 | /* Command packet DRQ type */ | 2468 | /* Command packet DRQ type */ |
2486 | if (((gcw[0] & 0x60) >> 5) == 1) | 2469 | if (((gcw[0] & 0x60) >> 5) == 1) |
2487 | set_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags); | 2470 | set_bit(IDE_AFLAG_DRQ_INTERRUPT, &drive->atapi_flags); |
2488 | 2471 | ||
2489 | idetape_get_inquiry_results(drive); | 2472 | idetape_get_inquiry_results(drive); |
2490 | idetape_get_mode_sense_results(drive); | 2473 | idetape_get_mode_sense_results(drive); |