diff options
author | Borislav Petkov <petkovbb@googlemail.com> | 2008-04-17 18:46:27 -0400 |
---|---|---|
committer | Bartlomiej Zolnierkiewicz <bzolnier@gmail.com> | 2008-04-17 18:46:27 -0400 |
commit | d236d74c0d91c7eeaef26560d3690430189e171f (patch) | |
tree | 78b5e3570e4870fc3e8a90962cf2be3cc43eb45b /drivers/ide/ide-tape.c | |
parent | 8303b46e18b58b2d0257e6842e60b50ac880a6d1 (diff) |
ide-tape: convert driver to using generic ide_atapi_pc
Signed-off-by: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
Diffstat (limited to 'drivers/ide/ide-tape.c')
-rw-r--r-- | drivers/ide/ide-tape.c | 251 |
1 files changed, 114 insertions, 137 deletions
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c index ce3a23e18ce9..3f9dcca6f092 100644 --- a/drivers/ide/ide-tape.c +++ b/drivers/ide/ide-tape.c | |||
@@ -181,34 +181,6 @@ struct idetape_bh { | |||
181 | char *b_data; | 181 | char *b_data; |
182 | }; | 182 | }; |
183 | 183 | ||
184 | typedef struct idetape_packet_command_s { | ||
185 | /* Actual packet bytes */ | ||
186 | u8 c[12]; | ||
187 | /* On each retry, we increment retries */ | ||
188 | int retries; | ||
189 | /* Error code */ | ||
190 | int error; | ||
191 | /* Bytes to transfer */ | ||
192 | int request_transfer; | ||
193 | /* Bytes actually transferred */ | ||
194 | int actually_transferred; | ||
195 | /* Size of our data buffer */ | ||
196 | int buffer_size; | ||
197 | struct idetape_bh *bh; | ||
198 | char *b_data; | ||
199 | int b_count; | ||
200 | /* Data buffer */ | ||
201 | u8 *buffer; | ||
202 | /* Pointer into the above buffer */ | ||
203 | u8 *current_position; | ||
204 | /* Called when this packet command is completed */ | ||
205 | ide_startstop_t (*callback) (ide_drive_t *); | ||
206 | /* Temporary buffer */ | ||
207 | u8 pc_buffer[IDETAPE_PC_BUFFER_SIZE]; | ||
208 | /* Status/Action bit flags: long for set_bit */ | ||
209 | unsigned long flags; | ||
210 | } idetape_pc_t; | ||
211 | |||
212 | /* Packet command flag bits. */ | 184 | /* Packet command flag bits. */ |
213 | enum { | 185 | enum { |
214 | /* Set when an error is considered normal - We won't retry */ | 186 | /* Set when an error is considered normal - We won't retry */ |
@@ -316,11 +288,11 @@ typedef struct ide_tape_obj { | |||
316 | * retry, to get detailed information on what went wrong. | 288 | * retry, to get detailed information on what went wrong. |
317 | */ | 289 | */ |
318 | /* Current packet command */ | 290 | /* Current packet command */ |
319 | idetape_pc_t *pc; | 291 | struct ide_atapi_pc *pc; |
320 | /* Last failed packet command */ | 292 | /* Last failed packet command */ |
321 | idetape_pc_t *failed_pc; | 293 | struct ide_atapi_pc *failed_pc; |
322 | /* Packet command stack */ | 294 | /* Packet command stack */ |
323 | idetape_pc_t pc_stack[IDETAPE_PC_STACK]; | 295 | struct ide_atapi_pc pc_stack[IDETAPE_PC_STACK]; |
324 | /* Next free packet command storage space */ | 296 | /* Next free packet command storage space */ |
325 | int pc_stack_index; | 297 | int pc_stack_index; |
326 | struct request rq_stack[IDETAPE_PC_STACK]; | 298 | struct request rq_stack[IDETAPE_PC_STACK]; |
@@ -524,7 +496,7 @@ static struct ide_tape_obj *ide_tape_chrdev_get(unsigned int i) | |||
524 | return tape; | 496 | return tape; |
525 | } | 497 | } |
526 | 498 | ||
527 | static void idetape_input_buffers(ide_drive_t *drive, idetape_pc_t *pc, | 499 | static void idetape_input_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, |
528 | unsigned int bcount) | 500 | unsigned int bcount) |
529 | { | 501 | { |
530 | struct idetape_bh *bh = pc->bh; | 502 | struct idetape_bh *bh = pc->bh; |
@@ -553,7 +525,7 @@ static void idetape_input_buffers(ide_drive_t *drive, idetape_pc_t *pc, | |||
553 | pc->bh = bh; | 525 | pc->bh = bh; |
554 | } | 526 | } |
555 | 527 | ||
556 | static void idetape_output_buffers(ide_drive_t *drive, idetape_pc_t *pc, | 528 | static void idetape_output_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, |
557 | unsigned int bcount) | 529 | unsigned int bcount) |
558 | { | 530 | { |
559 | struct idetape_bh *bh = pc->bh; | 531 | struct idetape_bh *bh = pc->bh; |
@@ -581,11 +553,11 @@ static void idetape_output_buffers(ide_drive_t *drive, idetape_pc_t *pc, | |||
581 | } | 553 | } |
582 | } | 554 | } |
583 | 555 | ||
584 | static void idetape_update_buffers(idetape_pc_t *pc) | 556 | static void idetape_update_buffers(struct ide_atapi_pc *pc) |
585 | { | 557 | { |
586 | struct idetape_bh *bh = pc->bh; | 558 | struct idetape_bh *bh = pc->bh; |
587 | int count; | 559 | int count; |
588 | unsigned int bcount = pc->actually_transferred; | 560 | unsigned int bcount = pc->xferred; |
589 | 561 | ||
590 | if (pc->flags & PC_FLAG_WRITING) | 562 | if (pc->flags & PC_FLAG_WRITING) |
591 | return; | 563 | return; |
@@ -610,7 +582,7 @@ static void idetape_update_buffers(idetape_pc_t *pc) | |||
610 | * driver. A storage space for a maximum of IDETAPE_PC_STACK packet | 582 | * driver. A storage space for a maximum of IDETAPE_PC_STACK packet |
611 | * commands is allocated at initialization time. | 583 | * commands is allocated at initialization time. |
612 | */ | 584 | */ |
613 | static idetape_pc_t *idetape_next_pc_storage(ide_drive_t *drive) | 585 | static struct ide_atapi_pc *idetape_next_pc_storage(ide_drive_t *drive) |
614 | { | 586 | { |
615 | idetape_tape_t *tape = drive->driver_data; | 587 | idetape_tape_t *tape = drive->driver_data; |
616 | 588 | ||
@@ -645,14 +617,14 @@ static struct request *idetape_next_rq_storage(ide_drive_t *drive) | |||
645 | return (&tape->rq_stack[tape->rq_stack_index++]); | 617 | return (&tape->rq_stack[tape->rq_stack_index++]); |
646 | } | 618 | } |
647 | 619 | ||
648 | static void idetape_init_pc(idetape_pc_t *pc) | 620 | static void idetape_init_pc(struct ide_atapi_pc *pc) |
649 | { | 621 | { |
650 | memset(pc->c, 0, 12); | 622 | memset(pc->c, 0, 12); |
651 | pc->retries = 0; | 623 | pc->retries = 0; |
652 | pc->flags = 0; | 624 | pc->flags = 0; |
653 | pc->request_transfer = 0; | 625 | pc->req_xfer = 0; |
654 | pc->buffer = pc->pc_buffer; | 626 | pc->buf = pc->pc_buf; |
655 | pc->buffer_size = IDETAPE_PC_BUFFER_SIZE; | 627 | pc->buf_size = IDETAPE_PC_BUFFER_SIZE; |
656 | pc->bh = NULL; | 628 | pc->bh = NULL; |
657 | pc->b_data = NULL; | 629 | pc->b_data = NULL; |
658 | } | 630 | } |
@@ -664,7 +636,7 @@ static void idetape_init_pc(idetape_pc_t *pc) | |||
664 | static void idetape_analyze_error(ide_drive_t *drive, u8 *sense) | 636 | static void idetape_analyze_error(ide_drive_t *drive, u8 *sense) |
665 | { | 637 | { |
666 | idetape_tape_t *tape = drive->driver_data; | 638 | idetape_tape_t *tape = drive->driver_data; |
667 | idetape_pc_t *pc = tape->failed_pc; | 639 | struct ide_atapi_pc *pc = tape->failed_pc; |
668 | 640 | ||
669 | tape->sense_key = sense[2] & 0xF; | 641 | tape->sense_key = sense[2] & 0xF; |
670 | tape->asc = sense[12]; | 642 | tape->asc = sense[12]; |
@@ -673,9 +645,9 @@ static void idetape_analyze_error(ide_drive_t *drive, u8 *sense) | |||
673 | debug_log(DBG_ERR, "pc = %x, sense key = %x, asc = %x, ascq = %x\n", | 645 | debug_log(DBG_ERR, "pc = %x, sense key = %x, asc = %x, ascq = %x\n", |
674 | pc->c[0], tape->sense_key, tape->asc, tape->ascq); | 646 | pc->c[0], tape->sense_key, tape->asc, tape->ascq); |
675 | 647 | ||
676 | /* Correct pc->actually_transferred by asking the tape. */ | 648 | /* Correct pc->xferred by asking the tape. */ |
677 | if (pc->flags & PC_FLAG_DMA_ERROR) { | 649 | if (pc->flags & PC_FLAG_DMA_ERROR) { |
678 | pc->actually_transferred = pc->request_transfer - | 650 | pc->xferred = pc->req_xfer - |
679 | tape->blk_size * | 651 | tape->blk_size * |
680 | be32_to_cpu(get_unaligned((u32 *)&sense[3])); | 652 | be32_to_cpu(get_unaligned((u32 *)&sense[3])); |
681 | idetape_update_buffers(pc); | 653 | idetape_update_buffers(pc); |
@@ -713,7 +685,7 @@ static void idetape_analyze_error(ide_drive_t *drive, u8 *sense) | |||
713 | pc->flags |= PC_FLAG_ABORT; | 685 | pc->flags |= PC_FLAG_ABORT; |
714 | } | 686 | } |
715 | if (!(pc->flags & PC_FLAG_ABORT) && | 687 | if (!(pc->flags & PC_FLAG_ABORT) && |
716 | pc->actually_transferred) | 688 | pc->xferred) |
717 | pc->retries = IDETAPE_MAX_PC_RETRIES + 1; | 689 | pc->retries = IDETAPE_MAX_PC_RETRIES + 1; |
718 | } | 690 | } |
719 | } | 691 | } |
@@ -922,7 +894,7 @@ static ide_startstop_t idetape_request_sense_callback(ide_drive_t *drive) | |||
922 | debug_log(DBG_PROCS, "Enter %s\n", __func__); | 894 | debug_log(DBG_PROCS, "Enter %s\n", __func__); |
923 | 895 | ||
924 | if (!tape->pc->error) { | 896 | if (!tape->pc->error) { |
925 | idetape_analyze_error(drive, tape->pc->buffer); | 897 | idetape_analyze_error(drive, tape->pc->buf); |
926 | idetape_end_request(drive, 1, 0); | 898 | idetape_end_request(drive, 1, 0); |
927 | } else { | 899 | } else { |
928 | printk(KERN_ERR "ide-tape: Error in REQUEST SENSE itself - " | 900 | printk(KERN_ERR "ide-tape: Error in REQUEST SENSE itself - " |
@@ -932,13 +904,13 @@ static ide_startstop_t idetape_request_sense_callback(ide_drive_t *drive) | |||
932 | return ide_stopped; | 904 | return ide_stopped; |
933 | } | 905 | } |
934 | 906 | ||
935 | static void idetape_create_request_sense_cmd(idetape_pc_t *pc) | 907 | static void idetape_create_request_sense_cmd(struct ide_atapi_pc *pc) |
936 | { | 908 | { |
937 | idetape_init_pc(pc); | 909 | idetape_init_pc(pc); |
938 | pc->c[0] = REQUEST_SENSE; | 910 | pc->c[0] = REQUEST_SENSE; |
939 | pc->c[4] = 20; | 911 | pc->c[4] = 20; |
940 | pc->request_transfer = 20; | 912 | pc->req_xfer = 20; |
941 | pc->callback = &idetape_request_sense_callback; | 913 | pc->idetape_callback = &idetape_request_sense_callback; |
942 | } | 914 | } |
943 | 915 | ||
944 | static void idetape_init_rq(struct request *rq, u8 cmd) | 916 | static void idetape_init_rq(struct request *rq, u8 cmd) |
@@ -963,7 +935,7 @@ static void idetape_init_rq(struct request *rq, u8 cmd) | |||
963 | * handling functions should queue request to the lower level part and wait for | 935 | * handling functions should queue request to the lower level part and wait for |
964 | * their completion using idetape_queue_pc_tail or idetape_queue_rw_tail. | 936 | * their completion using idetape_queue_pc_tail or idetape_queue_rw_tail. |
965 | */ | 937 | */ |
966 | static void idetape_queue_pc_head(ide_drive_t *drive, idetape_pc_t *pc, | 938 | static void idetape_queue_pc_head(ide_drive_t *drive, struct ide_atapi_pc *pc, |
967 | struct request *rq) | 939 | struct request *rq) |
968 | { | 940 | { |
969 | struct ide_tape_obj *tape = drive->driver_data; | 941 | struct ide_tape_obj *tape = drive->driver_data; |
@@ -982,7 +954,7 @@ static void idetape_queue_pc_head(ide_drive_t *drive, idetape_pc_t *pc, | |||
982 | static ide_startstop_t idetape_retry_pc (ide_drive_t *drive) | 954 | static ide_startstop_t idetape_retry_pc (ide_drive_t *drive) |
983 | { | 955 | { |
984 | idetape_tape_t *tape = drive->driver_data; | 956 | idetape_tape_t *tape = drive->driver_data; |
985 | idetape_pc_t *pc; | 957 | struct ide_atapi_pc *pc; |
986 | struct request *rq; | 958 | struct request *rq; |
987 | 959 | ||
988 | (void)ide_read_error(drive); | 960 | (void)ide_read_error(drive); |
@@ -1008,7 +980,7 @@ static void idetape_postpone_request(ide_drive_t *drive) | |||
1008 | ide_stall_queue(drive, tape->dsc_poll_freq); | 980 | ide_stall_queue(drive, tape->dsc_poll_freq); |
1009 | } | 981 | } |
1010 | 982 | ||
1011 | typedef void idetape_io_buf(ide_drive_t *, idetape_pc_t *, unsigned int); | 983 | typedef void idetape_io_buf(ide_drive_t *, struct ide_atapi_pc *, unsigned int); |
1012 | 984 | ||
1013 | /* | 985 | /* |
1014 | * This is the usual interrupt handler which will be called during a packet | 986 | * This is the usual interrupt handler which will be called during a packet |
@@ -1021,7 +993,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) | |||
1021 | { | 993 | { |
1022 | ide_hwif_t *hwif = drive->hwif; | 994 | ide_hwif_t *hwif = drive->hwif; |
1023 | idetape_tape_t *tape = drive->driver_data; | 995 | idetape_tape_t *tape = drive->driver_data; |
1024 | idetape_pc_t *pc = tape->pc; | 996 | struct ide_atapi_pc *pc = tape->pc; |
1025 | xfer_func_t *xferfunc; | 997 | xfer_func_t *xferfunc; |
1026 | idetape_io_buf *iobuf; | 998 | idetape_io_buf *iobuf; |
1027 | unsigned int temp; | 999 | unsigned int temp; |
@@ -1061,7 +1033,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) | |||
1061 | */ | 1033 | */ |
1062 | pc->flags |= PC_FLAG_DMA_ERROR; | 1034 | pc->flags |= PC_FLAG_DMA_ERROR; |
1063 | } else { | 1035 | } else { |
1064 | pc->actually_transferred = pc->request_transfer; | 1036 | pc->xferred = pc->req_xfer; |
1065 | idetape_update_buffers(pc); | 1037 | idetape_update_buffers(pc); |
1066 | } | 1038 | } |
1067 | debug_log(DBG_PROCS, "DMA finished\n"); | 1039 | debug_log(DBG_PROCS, "DMA finished\n"); |
@@ -1071,7 +1043,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) | |||
1071 | /* No more interrupts */ | 1043 | /* No more interrupts */ |
1072 | if ((stat & DRQ_STAT) == 0) { | 1044 | if ((stat & DRQ_STAT) == 0) { |
1073 | debug_log(DBG_SENSE, "Packet command completed, %d bytes" | 1045 | debug_log(DBG_SENSE, "Packet command completed, %d bytes" |
1074 | " transferred\n", pc->actually_transferred); | 1046 | " transferred\n", pc->xferred); |
1075 | 1047 | ||
1076 | pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS; | 1048 | pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS; |
1077 | local_irq_enable(); | 1049 | local_irq_enable(); |
@@ -1115,7 +1087,7 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) | |||
1115 | if (tape->failed_pc == pc) | 1087 | if (tape->failed_pc == pc) |
1116 | tape->failed_pc = NULL; | 1088 | tape->failed_pc = NULL; |
1117 | /* Command finished - Call the callback function */ | 1089 | /* Command finished - Call the callback function */ |
1118 | return pc->callback(drive); | 1090 | return pc->idetape_callback(drive); |
1119 | } | 1091 | } |
1120 | 1092 | ||
1121 | if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { | 1093 | if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { |
@@ -1146,9 +1118,9 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) | |||
1146 | } | 1118 | } |
1147 | if (!(pc->flags & PC_FLAG_WRITING)) { | 1119 | if (!(pc->flags & PC_FLAG_WRITING)) { |
1148 | /* Reading - Check that we have enough space */ | 1120 | /* Reading - Check that we have enough space */ |
1149 | temp = pc->actually_transferred + bcount; | 1121 | temp = pc->xferred + bcount; |
1150 | if (temp > pc->request_transfer) { | 1122 | if (temp > pc->req_xfer) { |
1151 | if (temp > pc->buffer_size) { | 1123 | if (temp > pc->buf_size) { |
1152 | printk(KERN_ERR "ide-tape: The tape wants to " | 1124 | printk(KERN_ERR "ide-tape: The tape wants to " |
1153 | "send us more data than expected " | 1125 | "send us more data than expected " |
1154 | "- discarding data\n"); | 1126 | "- discarding data\n"); |
@@ -1170,11 +1142,11 @@ static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) | |||
1170 | if (pc->bh) | 1142 | if (pc->bh) |
1171 | iobuf(drive, pc, bcount); | 1143 | iobuf(drive, pc, bcount); |
1172 | else | 1144 | else |
1173 | xferfunc(drive, pc->current_position, bcount); | 1145 | xferfunc(drive, pc->cur_pos, bcount); |
1174 | 1146 | ||
1175 | /* Update the current position */ | 1147 | /* Update the current position */ |
1176 | pc->actually_transferred += bcount; | 1148 | pc->xferred += bcount; |
1177 | pc->current_position += bcount; | 1149 | pc->cur_pos += bcount; |
1178 | 1150 | ||
1179 | debug_log(DBG_SENSE, "[cmd %x] transferred %d bytes on that intr.\n", | 1151 | debug_log(DBG_SENSE, "[cmd %x] transferred %d bytes on that intr.\n", |
1180 | pc->c[0], bcount); | 1152 | pc->c[0], bcount); |
@@ -1224,7 +1196,7 @@ static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive) | |||
1224 | { | 1196 | { |
1225 | ide_hwif_t *hwif = drive->hwif; | 1197 | ide_hwif_t *hwif = drive->hwif; |
1226 | idetape_tape_t *tape = drive->driver_data; | 1198 | idetape_tape_t *tape = drive->driver_data; |
1227 | idetape_pc_t *pc = tape->pc; | 1199 | struct ide_atapi_pc *pc = tape->pc; |
1228 | int retries = 100; | 1200 | int retries = 100; |
1229 | ide_startstop_t startstop; | 1201 | ide_startstop_t startstop; |
1230 | u8 ireason; | 1202 | u8 ireason; |
@@ -1264,7 +1236,8 @@ static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive) | |||
1264 | return ide_started; | 1236 | return ide_started; |
1265 | } | 1237 | } |
1266 | 1238 | ||
1267 | static ide_startstop_t idetape_issue_pc(ide_drive_t *drive, idetape_pc_t *pc) | 1239 | static ide_startstop_t idetape_issue_pc(ide_drive_t *drive, |
1240 | struct ide_atapi_pc *pc) | ||
1268 | { | 1241 | { |
1269 | ide_hwif_t *hwif = drive->hwif; | 1242 | ide_hwif_t *hwif = drive->hwif; |
1270 | idetape_tape_t *tape = drive->driver_data; | 1243 | idetape_tape_t *tape = drive->driver_data; |
@@ -1304,16 +1277,16 @@ static ide_startstop_t idetape_issue_pc(ide_drive_t *drive, idetape_pc_t *pc) | |||
1304 | pc->error = IDETAPE_ERROR_GENERAL; | 1277 | pc->error = IDETAPE_ERROR_GENERAL; |
1305 | } | 1278 | } |
1306 | tape->failed_pc = NULL; | 1279 | tape->failed_pc = NULL; |
1307 | return pc->callback(drive); | 1280 | return pc->idetape_callback(drive); |
1308 | } | 1281 | } |
1309 | debug_log(DBG_SENSE, "Retry #%d, cmd = %02X\n", pc->retries, pc->c[0]); | 1282 | debug_log(DBG_SENSE, "Retry #%d, cmd = %02X\n", pc->retries, pc->c[0]); |
1310 | 1283 | ||
1311 | pc->retries++; | 1284 | pc->retries++; |
1312 | /* We haven't transferred any data yet */ | 1285 | /* We haven't transferred any data yet */ |
1313 | pc->actually_transferred = 0; | 1286 | pc->xferred = 0; |
1314 | pc->current_position = pc->buffer; | 1287 | pc->cur_pos = pc->buf; |
1315 | /* Request to transfer the entire buffer at once */ | 1288 | /* Request to transfer the entire buffer at once */ |
1316 | bcount = pc->request_transfer; | 1289 | bcount = pc->req_xfer; |
1317 | 1290 | ||
1318 | if (pc->flags & PC_FLAG_DMA_ERROR) { | 1291 | if (pc->flags & PC_FLAG_DMA_ERROR) { |
1319 | pc->flags &= ~PC_FLAG_DMA_ERROR; | 1292 | pc->flags &= ~PC_FLAG_DMA_ERROR; |
@@ -1351,7 +1324,7 @@ static ide_startstop_t idetape_pc_callback(ide_drive_t *drive) | |||
1351 | } | 1324 | } |
1352 | 1325 | ||
1353 | /* A mode sense command is used to "sense" tape parameters. */ | 1326 | /* A mode sense command is used to "sense" tape parameters. */ |
1354 | static void idetape_create_mode_sense_cmd(idetape_pc_t *pc, u8 page_code) | 1327 | static void idetape_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code) |
1355 | { | 1328 | { |
1356 | idetape_init_pc(pc); | 1329 | idetape_init_pc(pc); |
1357 | pc->c[0] = MODE_SENSE; | 1330 | pc->c[0] = MODE_SENSE; |
@@ -1370,12 +1343,12 @@ static void idetape_create_mode_sense_cmd(idetape_pc_t *pc, u8 page_code) | |||
1370 | /* We will just discard data in that case */ | 1343 | /* We will just discard data in that case */ |
1371 | pc->c[4] = 255; | 1344 | pc->c[4] = 255; |
1372 | if (page_code == IDETAPE_BLOCK_DESCRIPTOR) | 1345 | if (page_code == IDETAPE_BLOCK_DESCRIPTOR) |
1373 | pc->request_transfer = 12; | 1346 | pc->req_xfer = 12; |
1374 | else if (page_code == IDETAPE_CAPABILITIES_PAGE) | 1347 | else if (page_code == IDETAPE_CAPABILITIES_PAGE) |
1375 | pc->request_transfer = 24; | 1348 | pc->req_xfer = 24; |
1376 | else | 1349 | else |
1377 | pc->request_transfer = 50; | 1350 | pc->req_xfer = 50; |
1378 | pc->callback = &idetape_pc_callback; | 1351 | pc->idetape_callback = &idetape_pc_callback; |
1379 | } | 1352 | } |
1380 | 1353 | ||
1381 | static void idetape_calculate_speeds(ide_drive_t *drive) | 1354 | static void idetape_calculate_speeds(ide_drive_t *drive) |
@@ -1444,7 +1417,7 @@ static void idetape_calculate_speeds(ide_drive_t *drive) | |||
1444 | static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive) | 1417 | static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive) |
1445 | { | 1418 | { |
1446 | idetape_tape_t *tape = drive->driver_data; | 1419 | idetape_tape_t *tape = drive->driver_data; |
1447 | idetape_pc_t *pc = tape->pc; | 1420 | struct ide_atapi_pc *pc = tape->pc; |
1448 | u8 stat; | 1421 | u8 stat; |
1449 | 1422 | ||
1450 | stat = ide_read_status(drive); | 1423 | stat = ide_read_status(drive); |
@@ -1465,14 +1438,14 @@ static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive) | |||
1465 | pc->error = IDETAPE_ERROR_GENERAL; | 1438 | pc->error = IDETAPE_ERROR_GENERAL; |
1466 | tape->failed_pc = NULL; | 1439 | tape->failed_pc = NULL; |
1467 | } | 1440 | } |
1468 | return pc->callback(drive); | 1441 | return pc->idetape_callback(drive); |
1469 | } | 1442 | } |
1470 | 1443 | ||
1471 | static ide_startstop_t idetape_rw_callback(ide_drive_t *drive) | 1444 | static ide_startstop_t idetape_rw_callback(ide_drive_t *drive) |
1472 | { | 1445 | { |
1473 | idetape_tape_t *tape = drive->driver_data; | 1446 | idetape_tape_t *tape = drive->driver_data; |
1474 | struct request *rq = HWGROUP(drive)->rq; | 1447 | struct request *rq = HWGROUP(drive)->rq; |
1475 | int blocks = tape->pc->actually_transferred / tape->blk_size; | 1448 | int blocks = tape->pc->xferred / tape->blk_size; |
1476 | 1449 | ||
1477 | tape->avg_size += blocks * tape->blk_size; | 1450 | tape->avg_size += blocks * tape->blk_size; |
1478 | tape->insert_size += blocks * tape->blk_size; | 1451 | tape->insert_size += blocks * tape->blk_size; |
@@ -1504,39 +1477,41 @@ static ide_startstop_t idetape_rw_callback(ide_drive_t *drive) | |||
1504 | return ide_stopped; | 1477 | return ide_stopped; |
1505 | } | 1478 | } |
1506 | 1479 | ||
1507 | static void idetape_create_read_cmd(idetape_tape_t *tape, idetape_pc_t *pc, | 1480 | static void idetape_create_read_cmd(idetape_tape_t *tape, |
1481 | struct ide_atapi_pc *pc, | ||
1508 | unsigned int length, struct idetape_bh *bh) | 1482 | unsigned int length, struct idetape_bh *bh) |
1509 | { | 1483 | { |
1510 | idetape_init_pc(pc); | 1484 | idetape_init_pc(pc); |
1511 | pc->c[0] = READ_6; | 1485 | pc->c[0] = READ_6; |
1512 | put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); | 1486 | put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); |
1513 | pc->c[1] = 1; | 1487 | pc->c[1] = 1; |
1514 | pc->callback = &idetape_rw_callback; | 1488 | pc->idetape_callback = &idetape_rw_callback; |
1515 | pc->bh = bh; | 1489 | pc->bh = bh; |
1516 | atomic_set(&bh->b_count, 0); | 1490 | atomic_set(&bh->b_count, 0); |
1517 | pc->buffer = NULL; | 1491 | pc->buf = NULL; |
1518 | pc->buffer_size = length * tape->blk_size; | 1492 | pc->buf_size = length * tape->blk_size; |
1519 | pc->request_transfer = pc->buffer_size; | 1493 | pc->req_xfer = pc->buf_size; |
1520 | if (pc->request_transfer == tape->stage_size) | 1494 | if (pc->req_xfer == tape->stage_size) |
1521 | pc->flags |= PC_FLAG_DMA_RECOMMENDED; | 1495 | pc->flags |= PC_FLAG_DMA_RECOMMENDED; |
1522 | } | 1496 | } |
1523 | 1497 | ||
1524 | static void idetape_create_write_cmd(idetape_tape_t *tape, idetape_pc_t *pc, | 1498 | static void idetape_create_write_cmd(idetape_tape_t *tape, |
1499 | struct ide_atapi_pc *pc, | ||
1525 | unsigned int length, struct idetape_bh *bh) | 1500 | unsigned int length, struct idetape_bh *bh) |
1526 | { | 1501 | { |
1527 | idetape_init_pc(pc); | 1502 | idetape_init_pc(pc); |
1528 | pc->c[0] = WRITE_6; | 1503 | pc->c[0] = WRITE_6; |
1529 | put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); | 1504 | put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); |
1530 | pc->c[1] = 1; | 1505 | pc->c[1] = 1; |
1531 | pc->callback = &idetape_rw_callback; | 1506 | pc->idetape_callback = &idetape_rw_callback; |
1532 | pc->flags |= PC_FLAG_WRITING; | 1507 | pc->flags |= PC_FLAG_WRITING; |
1533 | pc->bh = bh; | 1508 | pc->bh = bh; |
1534 | pc->b_data = bh->b_data; | 1509 | pc->b_data = bh->b_data; |
1535 | pc->b_count = atomic_read(&bh->b_count); | 1510 | pc->b_count = atomic_read(&bh->b_count); |
1536 | pc->buffer = NULL; | 1511 | pc->buf = NULL; |
1537 | pc->buffer_size = length * tape->blk_size; | 1512 | pc->buf_size = length * tape->blk_size; |
1538 | pc->request_transfer = pc->buffer_size; | 1513 | pc->req_xfer = pc->buf_size; |
1539 | if (pc->request_transfer == tape->stage_size) | 1514 | if (pc->req_xfer == tape->stage_size) |
1540 | pc->flags |= PC_FLAG_DMA_RECOMMENDED; | 1515 | pc->flags |= PC_FLAG_DMA_RECOMMENDED; |
1541 | } | 1516 | } |
1542 | 1517 | ||
@@ -1544,7 +1519,7 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive, | |||
1544 | struct request *rq, sector_t block) | 1519 | struct request *rq, sector_t block) |
1545 | { | 1520 | { |
1546 | idetape_tape_t *tape = drive->driver_data; | 1521 | idetape_tape_t *tape = drive->driver_data; |
1547 | idetape_pc_t *pc = NULL; | 1522 | struct ide_atapi_pc *pc = NULL; |
1548 | struct request *postponed_rq = tape->postponed_rq; | 1523 | struct request *postponed_rq = tape->postponed_rq; |
1549 | u8 stat; | 1524 | u8 stat; |
1550 | 1525 | ||
@@ -1631,7 +1606,7 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive, | |||
1631 | goto out; | 1606 | goto out; |
1632 | } | 1607 | } |
1633 | if (rq->cmd[0] & REQ_IDETAPE_PC1) { | 1608 | if (rq->cmd[0] & REQ_IDETAPE_PC1) { |
1634 | pc = (idetape_pc_t *) rq->buffer; | 1609 | pc = (struct ide_atapi_pc *) rq->buffer; |
1635 | rq->cmd[0] &= ~(REQ_IDETAPE_PC1); | 1610 | rq->cmd[0] &= ~(REQ_IDETAPE_PC1); |
1636 | rq->cmd[0] |= REQ_IDETAPE_PC2; | 1611 | rq->cmd[0] |= REQ_IDETAPE_PC2; |
1637 | goto out; | 1612 | goto out; |
@@ -1883,7 +1858,7 @@ static void idetape_wait_for_request(ide_drive_t *drive, struct request *rq) | |||
1883 | static ide_startstop_t idetape_read_position_callback(ide_drive_t *drive) | 1858 | static ide_startstop_t idetape_read_position_callback(ide_drive_t *drive) |
1884 | { | 1859 | { |
1885 | idetape_tape_t *tape = drive->driver_data; | 1860 | idetape_tape_t *tape = drive->driver_data; |
1886 | u8 *readpos = tape->pc->buffer; | 1861 | u8 *readpos = tape->pc->buf; |
1887 | 1862 | ||
1888 | debug_log(DBG_PROCS, "Enter %s\n", __func__); | 1863 | debug_log(DBG_PROCS, "Enter %s\n", __func__); |
1889 | 1864 | ||
@@ -1919,20 +1894,20 @@ static ide_startstop_t idetape_read_position_callback(ide_drive_t *drive) | |||
1919 | * writing a filemark otherwise. | 1894 | * writing a filemark otherwise. |
1920 | */ | 1895 | */ |
1921 | static void idetape_create_write_filemark_cmd(ide_drive_t *drive, | 1896 | static void idetape_create_write_filemark_cmd(ide_drive_t *drive, |
1922 | idetape_pc_t *pc, int write_filemark) | 1897 | struct ide_atapi_pc *pc, int write_filemark) |
1923 | { | 1898 | { |
1924 | idetape_init_pc(pc); | 1899 | idetape_init_pc(pc); |
1925 | pc->c[0] = WRITE_FILEMARKS; | 1900 | pc->c[0] = WRITE_FILEMARKS; |
1926 | pc->c[4] = write_filemark; | 1901 | pc->c[4] = write_filemark; |
1927 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; | 1902 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; |
1928 | pc->callback = &idetape_pc_callback; | 1903 | pc->idetape_callback = &idetape_pc_callback; |
1929 | } | 1904 | } |
1930 | 1905 | ||
1931 | static void idetape_create_test_unit_ready_cmd(idetape_pc_t *pc) | 1906 | static void idetape_create_test_unit_ready_cmd(struct ide_atapi_pc *pc) |
1932 | { | 1907 | { |
1933 | idetape_init_pc(pc); | 1908 | idetape_init_pc(pc); |
1934 | pc->c[0] = TEST_UNIT_READY; | 1909 | pc->c[0] = TEST_UNIT_READY; |
1935 | pc->callback = &idetape_pc_callback; | 1910 | pc->idetape_callback = &idetape_pc_callback; |
1936 | } | 1911 | } |
1937 | 1912 | ||
1938 | /* | 1913 | /* |
@@ -1948,7 +1923,7 @@ static void idetape_create_test_unit_ready_cmd(idetape_pc_t *pc) | |||
1948 | * to the request list without waiting for it to be serviced! In that case, we | 1923 | * to the request list without waiting for it to be serviced! In that case, we |
1949 | * usually use idetape_queue_pc_head(). | 1924 | * usually use idetape_queue_pc_head(). |
1950 | */ | 1925 | */ |
1951 | static int __idetape_queue_pc_tail(ide_drive_t *drive, idetape_pc_t *pc) | 1926 | static int __idetape_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc) |
1952 | { | 1927 | { |
1953 | struct ide_tape_obj *tape = drive->driver_data; | 1928 | struct ide_tape_obj *tape = drive->driver_data; |
1954 | struct request rq; | 1929 | struct request rq; |
@@ -1959,20 +1934,20 @@ static int __idetape_queue_pc_tail(ide_drive_t *drive, idetape_pc_t *pc) | |||
1959 | return ide_do_drive_cmd(drive, &rq, ide_wait); | 1934 | return ide_do_drive_cmd(drive, &rq, ide_wait); |
1960 | } | 1935 | } |
1961 | 1936 | ||
1962 | static void idetape_create_load_unload_cmd(ide_drive_t *drive, idetape_pc_t *pc, | 1937 | static void idetape_create_load_unload_cmd(ide_drive_t *drive, |
1963 | int cmd) | 1938 | struct ide_atapi_pc *pc, int cmd) |
1964 | { | 1939 | { |
1965 | idetape_init_pc(pc); | 1940 | idetape_init_pc(pc); |
1966 | pc->c[0] = START_STOP; | 1941 | pc->c[0] = START_STOP; |
1967 | pc->c[4] = cmd; | 1942 | pc->c[4] = cmd; |
1968 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; | 1943 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; |
1969 | pc->callback = &idetape_pc_callback; | 1944 | pc->idetape_callback = &idetape_pc_callback; |
1970 | } | 1945 | } |
1971 | 1946 | ||
1972 | static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout) | 1947 | static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout) |
1973 | { | 1948 | { |
1974 | idetape_tape_t *tape = drive->driver_data; | 1949 | idetape_tape_t *tape = drive->driver_data; |
1975 | idetape_pc_t pc; | 1950 | struct ide_atapi_pc pc; |
1976 | int load_attempted = 0; | 1951 | int load_attempted = 0; |
1977 | 1952 | ||
1978 | /* Wait for the tape to become ready */ | 1953 | /* Wait for the tape to become ready */ |
@@ -2000,14 +1975,14 @@ static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout) | |||
2000 | return -EIO; | 1975 | return -EIO; |
2001 | } | 1976 | } |
2002 | 1977 | ||
2003 | static int idetape_queue_pc_tail(ide_drive_t *drive, idetape_pc_t *pc) | 1978 | static int idetape_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc) |
2004 | { | 1979 | { |
2005 | return __idetape_queue_pc_tail(drive, pc); | 1980 | return __idetape_queue_pc_tail(drive, pc); |
2006 | } | 1981 | } |
2007 | 1982 | ||
2008 | static int idetape_flush_tape_buffers(ide_drive_t *drive) | 1983 | static int idetape_flush_tape_buffers(ide_drive_t *drive) |
2009 | { | 1984 | { |
2010 | idetape_pc_t pc; | 1985 | struct ide_atapi_pc pc; |
2011 | int rc; | 1986 | int rc; |
2012 | 1987 | ||
2013 | idetape_create_write_filemark_cmd(drive, &pc, 0); | 1988 | idetape_create_write_filemark_cmd(drive, &pc, 0); |
@@ -2018,18 +1993,18 @@ static int idetape_flush_tape_buffers(ide_drive_t *drive) | |||
2018 | return 0; | 1993 | return 0; |
2019 | } | 1994 | } |
2020 | 1995 | ||
2021 | static void idetape_create_read_position_cmd(idetape_pc_t *pc) | 1996 | static void idetape_create_read_position_cmd(struct ide_atapi_pc *pc) |
2022 | { | 1997 | { |
2023 | idetape_init_pc(pc); | 1998 | idetape_init_pc(pc); |
2024 | pc->c[0] = READ_POSITION; | 1999 | pc->c[0] = READ_POSITION; |
2025 | pc->request_transfer = 20; | 2000 | pc->req_xfer = 20; |
2026 | pc->callback = &idetape_read_position_callback; | 2001 | pc->idetape_callback = &idetape_read_position_callback; |
2027 | } | 2002 | } |
2028 | 2003 | ||
2029 | static int idetape_read_position(ide_drive_t *drive) | 2004 | static int idetape_read_position(ide_drive_t *drive) |
2030 | { | 2005 | { |
2031 | idetape_tape_t *tape = drive->driver_data; | 2006 | idetape_tape_t *tape = drive->driver_data; |
2032 | idetape_pc_t pc; | 2007 | struct ide_atapi_pc pc; |
2033 | int position; | 2008 | int position; |
2034 | 2009 | ||
2035 | debug_log(DBG_PROCS, "Enter %s\n", __func__); | 2010 | debug_log(DBG_PROCS, "Enter %s\n", __func__); |
@@ -2041,7 +2016,8 @@ static int idetape_read_position(ide_drive_t *drive) | |||
2041 | return position; | 2016 | return position; |
2042 | } | 2017 | } |
2043 | 2018 | ||
2044 | static void idetape_create_locate_cmd(ide_drive_t *drive, idetape_pc_t *pc, | 2019 | static void idetape_create_locate_cmd(ide_drive_t *drive, |
2020 | struct ide_atapi_pc *pc, | ||
2045 | unsigned int block, u8 partition, int skip) | 2021 | unsigned int block, u8 partition, int skip) |
2046 | { | 2022 | { |
2047 | idetape_init_pc(pc); | 2023 | idetape_init_pc(pc); |
@@ -2050,11 +2026,11 @@ static void idetape_create_locate_cmd(ide_drive_t *drive, idetape_pc_t *pc, | |||
2050 | put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[3]); | 2026 | put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[3]); |
2051 | pc->c[8] = partition; | 2027 | pc->c[8] = partition; |
2052 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; | 2028 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; |
2053 | pc->callback = &idetape_pc_callback; | 2029 | pc->idetape_callback = &idetape_pc_callback; |
2054 | } | 2030 | } |
2055 | 2031 | ||
2056 | static int idetape_create_prevent_cmd(ide_drive_t *drive, idetape_pc_t *pc, | 2032 | static int idetape_create_prevent_cmd(ide_drive_t *drive, |
2057 | int prevent) | 2033 | struct ide_atapi_pc *pc, int prevent) |
2058 | { | 2034 | { |
2059 | idetape_tape_t *tape = drive->driver_data; | 2035 | idetape_tape_t *tape = drive->driver_data; |
2060 | 2036 | ||
@@ -2065,7 +2041,7 @@ static int idetape_create_prevent_cmd(ide_drive_t *drive, idetape_pc_t *pc, | |||
2065 | idetape_init_pc(pc); | 2041 | idetape_init_pc(pc); |
2066 | pc->c[0] = ALLOW_MEDIUM_REMOVAL; | 2042 | pc->c[0] = ALLOW_MEDIUM_REMOVAL; |
2067 | pc->c[4] = prevent; | 2043 | pc->c[4] = prevent; |
2068 | pc->callback = &idetape_pc_callback; | 2044 | pc->idetape_callback = &idetape_pc_callback; |
2069 | return 1; | 2045 | return 1; |
2070 | } | 2046 | } |
2071 | 2047 | ||
@@ -2126,7 +2102,7 @@ static int idetape_position_tape(ide_drive_t *drive, unsigned int block, | |||
2126 | { | 2102 | { |
2127 | idetape_tape_t *tape = drive->driver_data; | 2103 | idetape_tape_t *tape = drive->driver_data; |
2128 | int retval; | 2104 | int retval; |
2129 | idetape_pc_t pc; | 2105 | struct ide_atapi_pc pc; |
2130 | 2106 | ||
2131 | if (tape->chrdev_dir == IDETAPE_DIR_READ) | 2107 | if (tape->chrdev_dir == IDETAPE_DIR_READ) |
2132 | __idetape_discard_read_pipeline(drive); | 2108 | __idetape_discard_read_pipeline(drive); |
@@ -2209,40 +2185,41 @@ static void idetape_plug_pipeline(ide_drive_t *drive) | |||
2209 | } | 2185 | } |
2210 | } | 2186 | } |
2211 | 2187 | ||
2212 | static void idetape_create_inquiry_cmd(idetape_pc_t *pc) | 2188 | static void idetape_create_inquiry_cmd(struct ide_atapi_pc *pc) |
2213 | { | 2189 | { |
2214 | idetape_init_pc(pc); | 2190 | idetape_init_pc(pc); |
2215 | pc->c[0] = INQUIRY; | 2191 | pc->c[0] = INQUIRY; |
2216 | pc->c[4] = 254; | 2192 | pc->c[4] = 254; |
2217 | pc->request_transfer = 254; | 2193 | pc->req_xfer = 254; |
2218 | pc->callback = &idetape_pc_callback; | 2194 | pc->idetape_callback = &idetape_pc_callback; |
2219 | } | 2195 | } |
2220 | 2196 | ||
2221 | static void idetape_create_rewind_cmd(ide_drive_t *drive, idetape_pc_t *pc) | 2197 | static void idetape_create_rewind_cmd(ide_drive_t *drive, |
2198 | struct ide_atapi_pc *pc) | ||
2222 | { | 2199 | { |
2223 | idetape_init_pc(pc); | 2200 | idetape_init_pc(pc); |
2224 | pc->c[0] = REZERO_UNIT; | 2201 | pc->c[0] = REZERO_UNIT; |
2225 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; | 2202 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; |
2226 | pc->callback = &idetape_pc_callback; | 2203 | pc->idetape_callback = &idetape_pc_callback; |
2227 | } | 2204 | } |
2228 | 2205 | ||
2229 | static void idetape_create_erase_cmd(idetape_pc_t *pc) | 2206 | static void idetape_create_erase_cmd(struct ide_atapi_pc *pc) |
2230 | { | 2207 | { |
2231 | idetape_init_pc(pc); | 2208 | idetape_init_pc(pc); |
2232 | pc->c[0] = ERASE; | 2209 | pc->c[0] = ERASE; |
2233 | pc->c[1] = 1; | 2210 | pc->c[1] = 1; |
2234 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; | 2211 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; |
2235 | pc->callback = &idetape_pc_callback; | 2212 | pc->idetape_callback = &idetape_pc_callback; |
2236 | } | 2213 | } |
2237 | 2214 | ||
2238 | static void idetape_create_space_cmd(idetape_pc_t *pc, int count, u8 cmd) | 2215 | static void idetape_create_space_cmd(struct ide_atapi_pc *pc, int count, u8 cmd) |
2239 | { | 2216 | { |
2240 | idetape_init_pc(pc); | 2217 | idetape_init_pc(pc); |
2241 | pc->c[0] = SPACE; | 2218 | pc->c[0] = SPACE; |
2242 | put_unaligned(cpu_to_be32(count), (unsigned int *) &pc->c[1]); | 2219 | put_unaligned(cpu_to_be32(count), (unsigned int *) &pc->c[1]); |
2243 | pc->c[1] = cmd; | 2220 | pc->c[1] = cmd; |
2244 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; | 2221 | pc->flags |= PC_FLAG_WAIT_FOR_DSC; |
2245 | pc->callback = &idetape_pc_callback; | 2222 | pc->idetape_callback = &idetape_pc_callback; |
2246 | } | 2223 | } |
2247 | 2224 | ||
2248 | static void idetape_wait_first_stage(ide_drive_t *drive) | 2225 | static void idetape_wait_first_stage(ide_drive_t *drive) |
@@ -2620,7 +2597,7 @@ static int idetape_pipeline_size(ide_drive_t *drive) | |||
2620 | static int idetape_rewind_tape(ide_drive_t *drive) | 2597 | static int idetape_rewind_tape(ide_drive_t *drive) |
2621 | { | 2598 | { |
2622 | int retval; | 2599 | int retval; |
2623 | idetape_pc_t pc; | 2600 | struct ide_atapi_pc pc; |
2624 | idetape_tape_t *tape; | 2601 | idetape_tape_t *tape; |
2625 | tape = drive->driver_data; | 2602 | tape = drive->driver_data; |
2626 | 2603 | ||
@@ -2683,7 +2660,7 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op, | |||
2683 | int mt_count) | 2660 | int mt_count) |
2684 | { | 2661 | { |
2685 | idetape_tape_t *tape = drive->driver_data; | 2662 | idetape_tape_t *tape = drive->driver_data; |
2686 | idetape_pc_t pc; | 2663 | struct ide_atapi_pc pc; |
2687 | unsigned long flags; | 2664 | unsigned long flags; |
2688 | int retval, count = 0; | 2665 | int retval, count = 0; |
2689 | int sprev = !!(tape->caps[4] & 0x20); | 2666 | int sprev = !!(tape->caps[4] & 0x20); |
@@ -2941,7 +2918,7 @@ static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf, | |||
2941 | 2918 | ||
2942 | static int idetape_write_filemark(ide_drive_t *drive) | 2919 | static int idetape_write_filemark(ide_drive_t *drive) |
2943 | { | 2920 | { |
2944 | idetape_pc_t pc; | 2921 | struct ide_atapi_pc pc; |
2945 | 2922 | ||
2946 | /* Write a filemark */ | 2923 | /* Write a filemark */ |
2947 | idetape_create_write_filemark_cmd(drive, &pc, 1); | 2924 | idetape_create_write_filemark_cmd(drive, &pc, 1); |
@@ -2969,7 +2946,7 @@ static int idetape_write_filemark(ide_drive_t *drive) | |||
2969 | static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count) | 2946 | static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count) |
2970 | { | 2947 | { |
2971 | idetape_tape_t *tape = drive->driver_data; | 2948 | idetape_tape_t *tape = drive->driver_data; |
2972 | idetape_pc_t pc; | 2949 | struct ide_atapi_pc pc; |
2973 | int i, retval; | 2950 | int i, retval; |
2974 | 2951 | ||
2975 | debug_log(DBG_ERR, "Handling MTIOCTOP ioctl: mt_op=%d, mt_count=%d\n", | 2952 | debug_log(DBG_ERR, "Handling MTIOCTOP ioctl: mt_op=%d, mt_count=%d\n", |
@@ -3152,7 +3129,7 @@ static int idetape_chrdev_ioctl(struct inode *inode, struct file *file, | |||
3152 | static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive) | 3129 | static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive) |
3153 | { | 3130 | { |
3154 | idetape_tape_t *tape = drive->driver_data; | 3131 | idetape_tape_t *tape = drive->driver_data; |
3155 | idetape_pc_t pc; | 3132 | struct ide_atapi_pc pc; |
3156 | 3133 | ||
3157 | idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR); | 3134 | idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR); |
3158 | if (idetape_queue_pc_tail(drive, &pc)) { | 3135 | if (idetape_queue_pc_tail(drive, &pc)) { |
@@ -3164,10 +3141,10 @@ static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive) | |||
3164 | } | 3141 | } |
3165 | return; | 3142 | return; |
3166 | } | 3143 | } |
3167 | tape->blk_size = (pc.buffer[4 + 5] << 16) + | 3144 | tape->blk_size = (pc.buf[4 + 5] << 16) + |
3168 | (pc.buffer[4 + 6] << 8) + | 3145 | (pc.buf[4 + 6] << 8) + |
3169 | pc.buffer[4 + 7]; | 3146 | pc.buf[4 + 7]; |
3170 | tape->drv_write_prot = (pc.buffer[2] & 0x80) >> 7; | 3147 | tape->drv_write_prot = (pc.buf[2] & 0x80) >> 7; |
3171 | } | 3148 | } |
3172 | 3149 | ||
3173 | static int idetape_chrdev_open(struct inode *inode, struct file *filp) | 3150 | static int idetape_chrdev_open(struct inode *inode, struct file *filp) |
@@ -3175,7 +3152,7 @@ static int idetape_chrdev_open(struct inode *inode, struct file *filp) | |||
3175 | unsigned int minor = iminor(inode), i = minor & ~0xc0; | 3152 | unsigned int minor = iminor(inode), i = minor & ~0xc0; |
3176 | ide_drive_t *drive; | 3153 | ide_drive_t *drive; |
3177 | idetape_tape_t *tape; | 3154 | idetape_tape_t *tape; |
3178 | idetape_pc_t pc; | 3155 | struct ide_atapi_pc pc; |
3179 | int retval; | 3156 | int retval; |
3180 | 3157 | ||
3181 | if (i >= MAX_HWIFS * MAX_DRIVES) | 3158 | if (i >= MAX_HWIFS * MAX_DRIVES) |
@@ -3275,7 +3252,7 @@ static int idetape_chrdev_release(struct inode *inode, struct file *filp) | |||
3275 | { | 3252 | { |
3276 | struct ide_tape_obj *tape = ide_tape_f(filp); | 3253 | struct ide_tape_obj *tape = ide_tape_f(filp); |
3277 | ide_drive_t *drive = tape->drive; | 3254 | ide_drive_t *drive = tape->drive; |
3278 | idetape_pc_t pc; | 3255 | struct ide_atapi_pc pc; |
3279 | unsigned int minor = iminor(inode); | 3256 | unsigned int minor = iminor(inode); |
3280 | 3257 | ||
3281 | lock_kernel(); | 3258 | lock_kernel(); |
@@ -3353,7 +3330,7 @@ static int idetape_identify_device(ide_drive_t *drive) | |||
3353 | static void idetape_get_inquiry_results(ide_drive_t *drive) | 3330 | static void idetape_get_inquiry_results(ide_drive_t *drive) |
3354 | { | 3331 | { |
3355 | idetape_tape_t *tape = drive->driver_data; | 3332 | idetape_tape_t *tape = drive->driver_data; |
3356 | idetape_pc_t pc; | 3333 | struct ide_atapi_pc pc; |
3357 | char fw_rev[6], vendor_id[10], product_id[18]; | 3334 | char fw_rev[6], vendor_id[10], product_id[18]; |
3358 | 3335 | ||
3359 | idetape_create_inquiry_cmd(&pc); | 3336 | idetape_create_inquiry_cmd(&pc); |
@@ -3362,9 +3339,9 @@ static void idetape_get_inquiry_results(ide_drive_t *drive) | |||
3362 | tape->name); | 3339 | tape->name); |
3363 | return; | 3340 | return; |
3364 | } | 3341 | } |
3365 | memcpy(vendor_id, &pc.buffer[8], 8); | 3342 | memcpy(vendor_id, &pc.buf[8], 8); |
3366 | memcpy(product_id, &pc.buffer[16], 16); | 3343 | memcpy(product_id, &pc.buf[16], 16); |
3367 | memcpy(fw_rev, &pc.buffer[32], 4); | 3344 | memcpy(fw_rev, &pc.buf[32], 4); |
3368 | 3345 | ||
3369 | ide_fixstring(vendor_id, 10, 0); | 3346 | ide_fixstring(vendor_id, 10, 0); |
3370 | ide_fixstring(product_id, 18, 0); | 3347 | ide_fixstring(product_id, 18, 0); |
@@ -3381,7 +3358,7 @@ static void idetape_get_inquiry_results(ide_drive_t *drive) | |||
3381 | static void idetape_get_mode_sense_results(ide_drive_t *drive) | 3358 | static void idetape_get_mode_sense_results(ide_drive_t *drive) |
3382 | { | 3359 | { |
3383 | idetape_tape_t *tape = drive->driver_data; | 3360 | idetape_tape_t *tape = drive->driver_data; |
3384 | idetape_pc_t pc; | 3361 | struct ide_atapi_pc pc; |
3385 | u8 *caps; | 3362 | u8 *caps; |
3386 | u8 speed, max_speed; | 3363 | u8 speed, max_speed; |
3387 | 3364 | ||
@@ -3395,7 +3372,7 @@ static void idetape_get_mode_sense_results(ide_drive_t *drive) | |||
3395 | put_unaligned(6*52, (u16 *)&tape->caps[16]); | 3372 | put_unaligned(6*52, (u16 *)&tape->caps[16]); |
3396 | return; | 3373 | return; |
3397 | } | 3374 | } |
3398 | caps = pc.buffer + 4 + pc.buffer[3]; | 3375 | caps = pc.buf + 4 + pc.buf[3]; |
3399 | 3376 | ||
3400 | /* convert to host order and save for later use */ | 3377 | /* convert to host order and save for later use */ |
3401 | speed = be16_to_cpu(*(u16 *)&caps[14]); | 3378 | speed = be16_to_cpu(*(u16 *)&caps[14]); |