1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#define DRV_NAME "ide-tape"
19
20#define IDETAPE_VERSION "1.20"
21
22#include <linux/module.h>
23#include <linux/types.h>
24#include <linux/string.h>
25#include <linux/kernel.h>
26#include <linux/delay.h>
27#include <linux/timer.h>
28#include <linux/mm.h>
29#include <linux/interrupt.h>
30#include <linux/jiffies.h>
31#include <linux/major.h>
32#include <linux/errno.h>
33#include <linux/genhd.h>
34#include <linux/seq_file.h>
35#include <linux/slab.h>
36#include <linux/pci.h>
37#include <linux/ide.h>
38#include <linux/completion.h>
39#include <linux/bitops.h>
40#include <linux/mutex.h>
41#include <scsi/scsi.h>
42
43#include <asm/byteorder.h>
44#include <linux/irq.h>
45#include <linux/uaccess.h>
46#include <linux/io.h>
47#include <asm/unaligned.h>
48#include <linux/mtio.h>
49
50
51#undef IDETAPE_DEBUG_LOG
52
53#ifdef IDETAPE_DEBUG_LOG
54#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, ## args)
55#else
56#define ide_debug_log(lvl, fmt, args...) do {} while (0)
57#endif
58
59
60
61
62
63
64
65
66#define IDETAPE_MAX_PC_RETRIES 3
67
68
69
70
71
72
73
74#define IDETAPE_FIFO_THRESHOLD 2
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102#define IDETAPE_DSC_RW_MIN 5*HZ/100
103#define IDETAPE_DSC_RW_MAX 40*HZ/100
104#define IDETAPE_DSC_RW_TIMEOUT 2*60*HZ
105#define IDETAPE_DSC_MA_FAST 2*HZ
106#define IDETAPE_DSC_MA_THRESHOLD 5*60*HZ
107#define IDETAPE_DSC_MA_SLOW 30*HZ
108#define IDETAPE_DSC_MA_TIMEOUT 2*60*60*HZ
109
110
111
112
113enum {
114 IDETAPE_DIR_NONE = (1 << 0),
115 IDETAPE_DIR_READ = (1 << 1),
116 IDETAPE_DIR_WRITE = (1 << 2),
117};
118
119
120#define DOOR_UNLOCKED 0
121#define DOOR_LOCKED 1
122#define DOOR_EXPLICITLY_LOCKED 2
123
124
125#define IDETAPE_SPACE_OVER_FILEMARK 1
126#define IDETAPE_SPACE_TO_EOD 3
127
128
129#define IDETAPE_LU_LOAD_MASK 1
130#define IDETAPE_LU_RETENSION_MASK 2
131#define IDETAPE_LU_EOT_MASK 4
132
133
134#define IDETAPE_BLOCK_DESCRIPTOR 0
135#define IDETAPE_CAPABILITIES_PAGE 0x2a
136
137
138
139
140
141typedef struct ide_tape_obj {
142 ide_drive_t *drive;
143 struct ide_driver *driver;
144 struct gendisk *disk;
145 struct device dev;
146
147
148 struct ide_atapi_pc queued_pc;
149
150
151
152
153
154
155
156
157
158 bool postponed_rq;
159
160
161 unsigned long dsc_polling_start;
162
163 struct timer_list dsc_timer;
164
165 unsigned long best_dsc_rw_freq;
166 unsigned long dsc_poll_freq;
167 unsigned long dsc_timeout;
168
169
170 u8 partition;
171
172 unsigned int first_frame;
173
174
175 u8 sense_key, asc, ascq;
176
177
178 unsigned int minor;
179
180 char name[4];
181
182 u8 chrdev_dir;
183
184
185 unsigned short blk_size;
186 int user_bs_factor;
187
188
189 u8 caps[20];
190
191
192
193
194
195
196
197
198
199
200 int buffer_size;
201
202 void *buf;
203
204 void *cur;
205
206 size_t valid;
207
208
209 unsigned long avg_time;
210 int avg_size;
211 int avg_speed;
212
213
214 int door_locked;
215
216 char drv_write_prot;
217
218 char write_prot;
219} idetape_tape_t;
220
221static DEFINE_MUTEX(ide_tape_mutex);
222static DEFINE_MUTEX(idetape_ref_mutex);
223
224static DEFINE_MUTEX(idetape_chrdev_mutex);
225
226static struct class *idetape_sysfs_class;
227
228static void ide_tape_release(struct device *);
229
230static struct ide_tape_obj *idetape_devs[MAX_HWIFS * MAX_DRIVES];
231
232static struct ide_tape_obj *ide_tape_get(struct gendisk *disk, bool cdev,
233 unsigned int i)
234{
235 struct ide_tape_obj *tape = NULL;
236
237 mutex_lock(&idetape_ref_mutex);
238
239 if (cdev)
240 tape = idetape_devs[i];
241 else
242 tape = ide_drv_g(disk, ide_tape_obj);
243
244 if (tape) {
245 if (ide_device_get(tape->drive))
246 tape = NULL;
247 else
248 get_device(&tape->dev);
249 }
250
251 mutex_unlock(&idetape_ref_mutex);
252 return tape;
253}
254
255static void ide_tape_put(struct ide_tape_obj *tape)
256{
257 ide_drive_t *drive = tape->drive;
258
259 mutex_lock(&idetape_ref_mutex);
260 put_device(&tape->dev);
261 ide_device_put(drive);
262 mutex_unlock(&idetape_ref_mutex);
263}
264
265
266
267
268
269static void idetape_analyze_error(ide_drive_t *drive)
270{
271 idetape_tape_t *tape = drive->driver_data;
272 struct ide_atapi_pc *pc = drive->failed_pc;
273 struct request *rq = drive->hwif->rq;
274 u8 *sense = bio_data(rq->bio);
275
276 tape->sense_key = sense[2] & 0xF;
277 tape->asc = sense[12];
278 tape->ascq = sense[13];
279
280 ide_debug_log(IDE_DBG_FUNC,
281 "cmd: 0x%x, sense key = %x, asc = %x, ascq = %x",
282 rq->cmd[0], tape->sense_key, tape->asc, tape->ascq);
283
284
285 if (pc->flags & PC_FLAG_DMA_ERROR)
286 rq->resid_len = tape->blk_size * get_unaligned_be32(&sense[3]);
287
288
289
290
291
292
293 if ((pc->c[0] == READ_6 || pc->c[0] == WRITE_6)
294
295 && pc->c[4] == 0 && pc->c[3] == 0 && pc->c[2] == 0) {
296 if (tape->sense_key == 5) {
297
298 pc->error = 0;
299
300 pc->flags |= PC_FLAG_ABORT;
301 }
302 }
303 if (pc->c[0] == READ_6 && (sense[2] & 0x80)) {
304 pc->error = IDE_DRV_ERROR_FILEMARK;
305 pc->flags |= PC_FLAG_ABORT;
306 }
307 if (pc->c[0] == WRITE_6) {
308 if ((sense[2] & 0x40) || (tape->sense_key == 0xd
309 && tape->asc == 0x0 && tape->ascq == 0x2)) {
310 pc->error = IDE_DRV_ERROR_EOD;
311 pc->flags |= PC_FLAG_ABORT;
312 }
313 }
314 if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) {
315 if (tape->sense_key == 8) {
316 pc->error = IDE_DRV_ERROR_EOD;
317 pc->flags |= PC_FLAG_ABORT;
318 }
319 if (!(pc->flags & PC_FLAG_ABORT) &&
320 (blk_rq_bytes(rq) - rq->resid_len))
321 pc->retries = IDETAPE_MAX_PC_RETRIES + 1;
322 }
323}
324
325static void ide_tape_handle_dsc(ide_drive_t *);
326
327static int ide_tape_callback(ide_drive_t *drive, int dsc)
328{
329 idetape_tape_t *tape = drive->driver_data;
330 struct ide_atapi_pc *pc = drive->pc;
331 struct request *rq = drive->hwif->rq;
332 int uptodate = pc->error ? 0 : 1;
333 int err = uptodate ? 0 : IDE_DRV_ERROR_GENERAL;
334
335 ide_debug_log(IDE_DBG_FUNC, "cmd: 0x%x, dsc: %d, err: %d", rq->cmd[0],
336 dsc, err);
337
338 if (dsc)
339 ide_tape_handle_dsc(drive);
340
341 if (drive->failed_pc == pc)
342 drive->failed_pc = NULL;
343
344 if (pc->c[0] == REQUEST_SENSE) {
345 if (uptodate)
346 idetape_analyze_error(drive);
347 else
348 printk(KERN_ERR "ide-tape: Error in REQUEST SENSE "
349 "itself - Aborting request!\n");
350 } else if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) {
351 unsigned int blocks =
352 (blk_rq_bytes(rq) - rq->resid_len) / tape->blk_size;
353
354 tape->avg_size += blocks * tape->blk_size;
355
356 if (time_after_eq(jiffies, tape->avg_time + HZ)) {
357 tape->avg_speed = tape->avg_size * HZ /
358 (jiffies - tape->avg_time) / 1024;
359 tape->avg_size = 0;
360 tape->avg_time = jiffies;
361 }
362
363 tape->first_frame += blocks;
364
365 if (pc->error) {
366 uptodate = 0;
367 err = pc->error;
368 }
369 }
370 rq->errors = err;
371
372 return uptodate;
373}
374
375
376
377
378
379static void ide_tape_stall_queue(ide_drive_t *drive)
380{
381 idetape_tape_t *tape = drive->driver_data;
382
383 ide_debug_log(IDE_DBG_FUNC, "cmd: 0x%x, dsc_poll_freq: %lu",
384 drive->hwif->rq->cmd[0], tape->dsc_poll_freq);
385
386 tape->postponed_rq = true;
387
388 ide_stall_queue(drive, tape->dsc_poll_freq);
389}
390
391static void ide_tape_handle_dsc(ide_drive_t *drive)
392{
393 idetape_tape_t *tape = drive->driver_data;
394
395
396 tape->dsc_polling_start = jiffies;
397 tape->dsc_poll_freq = IDETAPE_DSC_MA_FAST;
398 tape->dsc_timeout = jiffies + IDETAPE_DSC_MA_TIMEOUT;
399
400 ide_tape_stall_queue(drive);
401}
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440static ide_startstop_t ide_tape_issue_pc(ide_drive_t *drive,
441 struct ide_cmd *cmd,
442 struct ide_atapi_pc *pc)
443{
444 idetape_tape_t *tape = drive->driver_data;
445 struct request *rq = drive->hwif->rq;
446
447 if (drive->failed_pc == NULL && pc->c[0] != REQUEST_SENSE)
448 drive->failed_pc = pc;
449
450
451 drive->pc = pc;
452
453 if (pc->retries > IDETAPE_MAX_PC_RETRIES ||
454 (pc->flags & PC_FLAG_ABORT)) {
455
456
457
458
459
460
461 if (!(pc->flags & PC_FLAG_ABORT)) {
462 if (!(pc->c[0] == TEST_UNIT_READY &&
463 tape->sense_key == 2 && tape->asc == 4 &&
464 (tape->ascq == 1 || tape->ascq == 8))) {
465 printk(KERN_ERR "ide-tape: %s: I/O error, "
466 "pc = %2x, key = %2x, "
467 "asc = %2x, ascq = %2x\n",
468 tape->name, pc->c[0],
469 tape->sense_key, tape->asc,
470 tape->ascq);
471 }
472
473 pc->error = IDE_DRV_ERROR_GENERAL;
474 }
475
476 drive->failed_pc = NULL;
477 drive->pc_callback(drive, 0);
478 ide_complete_rq(drive, -EIO, blk_rq_bytes(rq));
479 return ide_stopped;
480 }
481 ide_debug_log(IDE_DBG_SENSE, "retry #%d, cmd: 0x%02x", pc->retries,
482 pc->c[0]);
483
484 pc->retries++;
485
486 return ide_issue_pc(drive, cmd);
487}
488
489
490static void idetape_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code)
491{
492 ide_init_pc(pc);
493 pc->c[0] = MODE_SENSE;
494 if (page_code != IDETAPE_BLOCK_DESCRIPTOR)
495
496 pc->c[1] = 8;
497 pc->c[2] = page_code;
498
499
500
501
502
503
504
505 pc->c[3] = 0;
506
507 pc->c[4] = 255;
508 if (page_code == IDETAPE_BLOCK_DESCRIPTOR)
509 pc->req_xfer = 12;
510 else if (page_code == IDETAPE_CAPABILITIES_PAGE)
511 pc->req_xfer = 24;
512 else
513 pc->req_xfer = 50;
514}
515
516static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive)
517{
518 ide_hwif_t *hwif = drive->hwif;
519 idetape_tape_t *tape = drive->driver_data;
520 struct ide_atapi_pc *pc = drive->pc;
521 u8 stat;
522
523 stat = hwif->tp_ops->read_status(hwif);
524
525 if (stat & ATA_DSC) {
526 if (stat & ATA_ERR) {
527
528 if (pc->c[0] != TEST_UNIT_READY)
529 printk(KERN_ERR "ide-tape: %s: I/O error, ",
530 tape->name);
531
532 ide_retry_pc(drive);
533 return ide_stopped;
534 }
535 pc->error = 0;
536 } else {
537 pc->error = IDE_DRV_ERROR_GENERAL;
538 drive->failed_pc = NULL;
539 }
540 drive->pc_callback(drive, 0);
541 return ide_stopped;
542}
543
544static void ide_tape_create_rw_cmd(idetape_tape_t *tape,
545 struct ide_atapi_pc *pc, struct request *rq,
546 u8 opcode)
547{
548 unsigned int length = blk_rq_sectors(rq) / (tape->blk_size >> 9);
549
550 ide_init_pc(pc);
551 put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]);
552 pc->c[1] = 1;
553
554 if (blk_rq_bytes(rq) == tape->buffer_size)
555 pc->flags |= PC_FLAG_DMA_OK;
556
557 if (opcode == READ_6)
558 pc->c[0] = READ_6;
559 else if (opcode == WRITE_6) {
560 pc->c[0] = WRITE_6;
561 pc->flags |= PC_FLAG_WRITING;
562 }
563
564 memcpy(rq->cmd, pc->c, 12);
565}
566
567static ide_startstop_t idetape_do_request(ide_drive_t *drive,
568 struct request *rq, sector_t block)
569{
570 ide_hwif_t *hwif = drive->hwif;
571 idetape_tape_t *tape = drive->driver_data;
572 struct ide_atapi_pc *pc = NULL;
573 struct ide_cmd cmd;
574 u8 stat;
575
576 ide_debug_log(IDE_DBG_RQ, "cmd: 0x%x, sector: %llu, nr_sectors: %u",
577 rq->cmd[0], (unsigned long long)blk_rq_pos(rq),
578 blk_rq_sectors(rq));
579
580 BUG_ON(!(rq->cmd_type == REQ_TYPE_SPECIAL ||
581 rq->cmd_type == REQ_TYPE_SENSE));
582
583
584 if (drive->failed_pc && drive->pc->c[0] == REQUEST_SENSE) {
585 pc = drive->failed_pc;
586 goto out;
587 }
588
589
590
591
592
593 stat = hwif->tp_ops->read_status(hwif);
594
595 if ((drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) == 0 &&
596 (rq->cmd[13] & REQ_IDETAPE_PC2) == 0)
597 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
598
599 if (drive->dev_flags & IDE_DFLAG_POST_RESET) {
600 drive->atapi_flags |= IDE_AFLAG_IGNORE_DSC;
601 drive->dev_flags &= ~IDE_DFLAG_POST_RESET;
602 }
603
604 if (!(drive->atapi_flags & IDE_AFLAG_IGNORE_DSC) &&
605 !(stat & ATA_DSC)) {
606 if (!tape->postponed_rq) {
607 tape->dsc_polling_start = jiffies;
608 tape->dsc_poll_freq = tape->best_dsc_rw_freq;
609 tape->dsc_timeout = jiffies + IDETAPE_DSC_RW_TIMEOUT;
610 } else if (time_after(jiffies, tape->dsc_timeout)) {
611 printk(KERN_ERR "ide-tape: %s: DSC timeout\n",
612 tape->name);
613 if (rq->cmd[13] & REQ_IDETAPE_PC2) {
614 idetape_media_access_finished(drive);
615 return ide_stopped;
616 } else {
617 return ide_do_reset(drive);
618 }
619 } else if (time_after(jiffies,
620 tape->dsc_polling_start +
621 IDETAPE_DSC_MA_THRESHOLD))
622 tape->dsc_poll_freq = IDETAPE_DSC_MA_SLOW;
623 ide_tape_stall_queue(drive);
624 return ide_stopped;
625 } else {
626 drive->atapi_flags &= ~IDE_AFLAG_IGNORE_DSC;
627 tape->postponed_rq = false;
628 }
629
630 if (rq->cmd[13] & REQ_IDETAPE_READ) {
631 pc = &tape->queued_pc;
632 ide_tape_create_rw_cmd(tape, pc, rq, READ_6);
633 goto out;
634 }
635 if (rq->cmd[13] & REQ_IDETAPE_WRITE) {
636 pc = &tape->queued_pc;
637 ide_tape_create_rw_cmd(tape, pc, rq, WRITE_6);
638 goto out;
639 }
640 if (rq->cmd[13] & REQ_IDETAPE_PC1) {
641 pc = (struct ide_atapi_pc *)rq->special;
642 rq->cmd[13] &= ~(REQ_IDETAPE_PC1);
643 rq->cmd[13] |= REQ_IDETAPE_PC2;
644 goto out;
645 }
646 if (rq->cmd[13] & REQ_IDETAPE_PC2) {
647 idetape_media_access_finished(drive);
648 return ide_stopped;
649 }
650 BUG();
651
652out:
653
654 ide_prep_sense(drive, rq);
655
656 memset(&cmd, 0, sizeof(cmd));
657
658 if (rq_data_dir(rq))
659 cmd.tf_flags |= IDE_TFLAG_WRITE;
660
661 cmd.rq = rq;
662
663 ide_init_sg_cmd(&cmd, blk_rq_bytes(rq));
664 ide_map_sg(drive, &cmd);
665
666 return ide_tape_issue_pc(drive, &cmd, pc);
667}
668
669
670
671
672
673static void idetape_create_write_filemark_cmd(ide_drive_t *drive,
674 struct ide_atapi_pc *pc, int write_filemark)
675{
676 ide_init_pc(pc);
677 pc->c[0] = WRITE_FILEMARKS;
678 pc->c[4] = write_filemark;
679 pc->flags |= PC_FLAG_WAIT_FOR_DSC;
680}
681
682static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout)
683{
684 idetape_tape_t *tape = drive->driver_data;
685 struct gendisk *disk = tape->disk;
686 int load_attempted = 0;
687
688
689 set_bit(ilog2(IDE_AFLAG_MEDIUM_PRESENT), &drive->atapi_flags);
690 timeout += jiffies;
691 while (time_before(jiffies, timeout)) {
692 if (ide_do_test_unit_ready(drive, disk) == 0)
693 return 0;
694 if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2)
695 || (tape->asc == 0x3A)) {
696
697 if (load_attempted)
698 return -ENOMEDIUM;
699 ide_do_start_stop(drive, disk, IDETAPE_LU_LOAD_MASK);
700 load_attempted = 1;
701
702 } else if (!(tape->sense_key == 2 && tape->asc == 4 &&
703 (tape->ascq == 1 || tape->ascq == 8)))
704 return -EIO;
705 msleep(100);
706 }
707 return -EIO;
708}
709
710static int idetape_flush_tape_buffers(ide_drive_t *drive)
711{
712 struct ide_tape_obj *tape = drive->driver_data;
713 struct ide_atapi_pc pc;
714 int rc;
715
716 idetape_create_write_filemark_cmd(drive, &pc, 0);
717 rc = ide_queue_pc_tail(drive, tape->disk, &pc, NULL, 0);
718 if (rc)
719 return rc;
720 idetape_wait_ready(drive, 60 * 5 * HZ);
721 return 0;
722}
723
724static int ide_tape_read_position(ide_drive_t *drive)
725{
726 idetape_tape_t *tape = drive->driver_data;
727 struct ide_atapi_pc pc;
728 u8 buf[20];
729
730 ide_debug_log(IDE_DBG_FUNC, "enter");
731
732
733 ide_init_pc(&pc);
734 pc.c[0] = READ_POSITION;
735 pc.req_xfer = 20;
736
737 if (ide_queue_pc_tail(drive, tape->disk, &pc, buf, pc.req_xfer))
738 return -1;
739
740 if (!pc.error) {
741 ide_debug_log(IDE_DBG_FUNC, "BOP - %s",
742 (buf[0] & 0x80) ? "Yes" : "No");
743 ide_debug_log(IDE_DBG_FUNC, "EOP - %s",
744 (buf[0] & 0x40) ? "Yes" : "No");
745
746 if (buf[0] & 0x4) {
747 printk(KERN_INFO "ide-tape: Block location is unknown"
748 "to the tape\n");
749 clear_bit(ilog2(IDE_AFLAG_ADDRESS_VALID),
750 &drive->atapi_flags);
751 return -1;
752 } else {
753 ide_debug_log(IDE_DBG_FUNC, "Block Location: %u",
754 be32_to_cpup((__be32 *)&buf[4]));
755
756 tape->partition = buf[1];
757 tape->first_frame = be32_to_cpup((__be32 *)&buf[4]);
758 set_bit(ilog2(IDE_AFLAG_ADDRESS_VALID),
759 &drive->atapi_flags);
760 }
761 }
762
763 return tape->first_frame;
764}
765
766static void idetape_create_locate_cmd(ide_drive_t *drive,
767 struct ide_atapi_pc *pc,
768 unsigned int block, u8 partition, int skip)
769{
770 ide_init_pc(pc);
771 pc->c[0] = POSITION_TO_ELEMENT;
772 pc->c[1] = 2;
773 put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[3]);
774 pc->c[8] = partition;
775 pc->flags |= PC_FLAG_WAIT_FOR_DSC;
776}
777
778static void __ide_tape_discard_merge_buffer(ide_drive_t *drive)
779{
780 idetape_tape_t *tape = drive->driver_data;
781
782 if (tape->chrdev_dir != IDETAPE_DIR_READ)
783 return;
784
785 clear_bit(ilog2(IDE_AFLAG_FILEMARK), &drive->atapi_flags);
786 tape->valid = 0;
787 if (tape->buf != NULL) {
788 kfree(tape->buf);
789 tape->buf = NULL;
790 }
791
792 tape->chrdev_dir = IDETAPE_DIR_NONE;
793}
794
795
796
797
798
799
800
801static int idetape_position_tape(ide_drive_t *drive, unsigned int block,
802 u8 partition, int skip)
803{
804 idetape_tape_t *tape = drive->driver_data;
805 struct gendisk *disk = tape->disk;
806 int ret;
807 struct ide_atapi_pc pc;
808
809 if (tape->chrdev_dir == IDETAPE_DIR_READ)
810 __ide_tape_discard_merge_buffer(drive);
811 idetape_wait_ready(drive, 60 * 5 * HZ);
812 idetape_create_locate_cmd(drive, &pc, block, partition, skip);
813 ret = ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
814 if (ret)
815 return ret;
816
817 ret = ide_tape_read_position(drive);
818 if (ret < 0)
819 return ret;
820 return 0;
821}
822
823static void ide_tape_discard_merge_buffer(ide_drive_t *drive,
824 int restore_position)
825{
826 idetape_tape_t *tape = drive->driver_data;
827 int seek, position;
828
829 __ide_tape_discard_merge_buffer(drive);
830 if (restore_position) {
831 position = ide_tape_read_position(drive);
832 seek = position > 0 ? position : 0;
833 if (idetape_position_tape(drive, seek, 0, 0)) {
834 printk(KERN_INFO "ide-tape: %s: position_tape failed in"
835 " %s\n", tape->name, __func__);
836 return;
837 }
838 }
839}
840
841
842
843
844
845static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int size)
846{
847 idetape_tape_t *tape = drive->driver_data;
848 struct request *rq;
849 int ret;
850
851 ide_debug_log(IDE_DBG_FUNC, "cmd: 0x%x, size: %d", cmd, size);
852
853 BUG_ON(cmd != REQ_IDETAPE_READ && cmd != REQ_IDETAPE_WRITE);
854 BUG_ON(size < 0 || size % tape->blk_size);
855
856 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
857 rq->cmd_type = REQ_TYPE_SPECIAL;
858 rq->cmd[13] = cmd;
859 rq->rq_disk = tape->disk;
860 rq->__sector = tape->first_frame;
861
862 if (size) {
863 ret = blk_rq_map_kern(drive->queue, rq, tape->buf, size,
864 __GFP_WAIT);
865 if (ret)
866 goto out_put;
867 }
868
869 blk_execute_rq(drive->queue, tape->disk, rq, 0);
870
871
872 size -= rq->resid_len;
873 tape->cur = tape->buf;
874 if (cmd == REQ_IDETAPE_READ)
875 tape->valid = size;
876 else
877 tape->valid = 0;
878
879 ret = size;
880 if (rq->errors == IDE_DRV_ERROR_GENERAL)
881 ret = -EIO;
882out_put:
883 blk_put_request(rq);
884 return ret;
885}
886
887static void idetape_create_inquiry_cmd(struct ide_atapi_pc *pc)
888{
889 ide_init_pc(pc);
890 pc->c[0] = INQUIRY;
891 pc->c[4] = 254;
892 pc->req_xfer = 254;
893}
894
895static void idetape_create_rewind_cmd(ide_drive_t *drive,
896 struct ide_atapi_pc *pc)
897{
898 ide_init_pc(pc);
899 pc->c[0] = REZERO_UNIT;
900 pc->flags |= PC_FLAG_WAIT_FOR_DSC;
901}
902
903static void idetape_create_erase_cmd(struct ide_atapi_pc *pc)
904{
905 ide_init_pc(pc);
906 pc->c[0] = ERASE;
907 pc->c[1] = 1;
908 pc->flags |= PC_FLAG_WAIT_FOR_DSC;
909}
910
911static void idetape_create_space_cmd(struct ide_atapi_pc *pc, int count, u8 cmd)
912{
913 ide_init_pc(pc);
914 pc->c[0] = SPACE;
915 put_unaligned(cpu_to_be32(count), (unsigned int *) &pc->c[1]);
916 pc->c[1] = cmd;
917 pc->flags |= PC_FLAG_WAIT_FOR_DSC;
918}
919
920static void ide_tape_flush_merge_buffer(ide_drive_t *drive)
921{
922 idetape_tape_t *tape = drive->driver_data;
923
924 if (tape->chrdev_dir != IDETAPE_DIR_WRITE) {
925 printk(KERN_ERR "ide-tape: bug: Trying to empty merge buffer"
926 " but we are not writing.\n");
927 return;
928 }
929 if (tape->buf) {
930 size_t aligned = roundup(tape->valid, tape->blk_size);
931
932 memset(tape->cur, 0, aligned - tape->valid);
933 idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, aligned);
934 kfree(tape->buf);
935 tape->buf = NULL;
936 }
937 tape->chrdev_dir = IDETAPE_DIR_NONE;
938}
939
940static int idetape_init_rw(ide_drive_t *drive, int dir)
941{
942 idetape_tape_t *tape = drive->driver_data;
943 int rc;
944
945 BUG_ON(dir != IDETAPE_DIR_READ && dir != IDETAPE_DIR_WRITE);
946
947 if (tape->chrdev_dir == dir)
948 return 0;
949
950 if (tape->chrdev_dir == IDETAPE_DIR_READ)
951 ide_tape_discard_merge_buffer(drive, 1);
952 else if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
953 ide_tape_flush_merge_buffer(drive);
954 idetape_flush_tape_buffers(drive);
955 }
956
957 if (tape->buf || tape->valid) {
958 printk(KERN_ERR "ide-tape: valid should be 0 now\n");
959 tape->valid = 0;
960 }
961
962 tape->buf = kmalloc(tape->buffer_size, GFP_KERNEL);
963 if (!tape->buf)
964 return -ENOMEM;
965 tape->chrdev_dir = dir;
966 tape->cur = tape->buf;
967
968
969
970
971
972
973
974 if (drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) {
975 int cmd = dir == IDETAPE_DIR_READ ? REQ_IDETAPE_READ
976 : REQ_IDETAPE_WRITE;
977
978 rc = idetape_queue_rw_tail(drive, cmd, 0);
979 if (rc < 0) {
980 kfree(tape->buf);
981 tape->buf = NULL;
982 tape->chrdev_dir = IDETAPE_DIR_NONE;
983 return rc;
984 }
985 }
986
987 return 0;
988}
989
990static void idetape_pad_zeros(ide_drive_t *drive, int bcount)
991{
992 idetape_tape_t *tape = drive->driver_data;
993
994 memset(tape->buf, 0, tape->buffer_size);
995
996 while (bcount) {
997 unsigned int count = min(tape->buffer_size, bcount);
998
999 idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, count);
1000 bcount -= count;
1001 }
1002}
1003
1004
1005
1006
1007
1008static int idetape_rewind_tape(ide_drive_t *drive)
1009{
1010 struct ide_tape_obj *tape = drive->driver_data;
1011 struct gendisk *disk = tape->disk;
1012 struct ide_atapi_pc pc;
1013 int ret;
1014
1015 ide_debug_log(IDE_DBG_FUNC, "enter");
1016
1017 idetape_create_rewind_cmd(drive, &pc);
1018 ret = ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
1019 if (ret)
1020 return ret;
1021
1022 ret = ide_tape_read_position(drive);
1023 if (ret < 0)
1024 return ret;
1025 return 0;
1026}
1027
1028
1029static int idetape_blkdev_ioctl(ide_drive_t *drive, unsigned int cmd,
1030 unsigned long arg)
1031{
1032 idetape_tape_t *tape = drive->driver_data;
1033 void __user *argp = (void __user *)arg;
1034
1035 struct idetape_config {
1036 int dsc_rw_frequency;
1037 int dsc_media_access_frequency;
1038 int nr_stages;
1039 } config;
1040
1041 ide_debug_log(IDE_DBG_FUNC, "cmd: 0x%04x", cmd);
1042
1043 switch (cmd) {
1044 case 0x0340:
1045 if (copy_from_user(&config, argp, sizeof(config)))
1046 return -EFAULT;
1047 tape->best_dsc_rw_freq = config.dsc_rw_frequency;
1048 break;
1049 case 0x0350:
1050 memset(&config, 0, sizeof(config));
1051 config.dsc_rw_frequency = (int) tape->best_dsc_rw_freq;
1052 config.nr_stages = 1;
1053 if (copy_to_user(argp, &config, sizeof(config)))
1054 return -EFAULT;
1055 break;
1056 default:
1057 return -EIO;
1058 }
1059 return 0;
1060}
1061
1062static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
1063 int mt_count)
1064{
1065 idetape_tape_t *tape = drive->driver_data;
1066 struct gendisk *disk = tape->disk;
1067 struct ide_atapi_pc pc;
1068 int retval, count = 0;
1069 int sprev = !!(tape->caps[4] & 0x20);
1070
1071
1072 ide_debug_log(IDE_DBG_FUNC, "mt_op: %d, mt_count: %d", mt_op, mt_count);
1073
1074 if (mt_count == 0)
1075 return 0;
1076 if (MTBSF == mt_op || MTBSFM == mt_op) {
1077 if (!sprev)
1078 return -EIO;
1079 mt_count = -mt_count;
1080 }
1081
1082 if (tape->chrdev_dir == IDETAPE_DIR_READ) {
1083 tape->valid = 0;
1084 if (test_and_clear_bit(ilog2(IDE_AFLAG_FILEMARK),
1085 &drive->atapi_flags))
1086 ++count;
1087 ide_tape_discard_merge_buffer(drive, 0);
1088 }
1089
1090 switch (mt_op) {
1091 case MTFSF:
1092 case MTBSF:
1093 idetape_create_space_cmd(&pc, mt_count - count,
1094 IDETAPE_SPACE_OVER_FILEMARK);
1095 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
1096 case MTFSFM:
1097 case MTBSFM:
1098 if (!sprev)
1099 return -EIO;
1100 retval = idetape_space_over_filemarks(drive, MTFSF,
1101 mt_count - count);
1102 if (retval)
1103 return retval;
1104 count = (MTBSFM == mt_op ? 1 : -1);
1105 return idetape_space_over_filemarks(drive, MTFSF, count);
1106 default:
1107 printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n",
1108 mt_op);
1109 return -EIO;
1110 }
1111}
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128static ssize_t idetape_chrdev_read(struct file *file, char __user *buf,
1129 size_t count, loff_t *ppos)
1130{
1131 struct ide_tape_obj *tape = file->private_data;
1132 ide_drive_t *drive = tape->drive;
1133 size_t done = 0;
1134 ssize_t ret = 0;
1135 int rc;
1136
1137 ide_debug_log(IDE_DBG_FUNC, "count %Zd", count);
1138
1139 if (tape->chrdev_dir != IDETAPE_DIR_READ) {
1140 if (test_bit(ilog2(IDE_AFLAG_DETECT_BS), &drive->atapi_flags))
1141 if (count > tape->blk_size &&
1142 (count % tape->blk_size) == 0)
1143 tape->user_bs_factor = count / tape->blk_size;
1144 }
1145
1146 rc = idetape_init_rw(drive, IDETAPE_DIR_READ);
1147 if (rc < 0)
1148 return rc;
1149
1150 while (done < count) {
1151 size_t todo;
1152
1153
1154 if (!tape->valid) {
1155
1156 if (test_bit(ilog2(IDE_AFLAG_FILEMARK),
1157 &drive->atapi_flags))
1158 break;
1159
1160 if (idetape_queue_rw_tail(drive, REQ_IDETAPE_READ,
1161 tape->buffer_size) <= 0)
1162 break;
1163 }
1164
1165
1166 todo = min_t(size_t, count - done, tape->valid);
1167 if (copy_to_user(buf + done, tape->cur, todo))
1168 ret = -EFAULT;
1169
1170 tape->cur += todo;
1171 tape->valid -= todo;
1172 done += todo;
1173 }
1174
1175 if (!done && test_bit(ilog2(IDE_AFLAG_FILEMARK), &drive->atapi_flags)) {
1176 idetape_space_over_filemarks(drive, MTFSF, 1);
1177 return 0;
1178 }
1179
1180 return ret ? ret : done;
1181}
1182
1183static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
1184 size_t count, loff_t *ppos)
1185{
1186 struct ide_tape_obj *tape = file->private_data;
1187 ide_drive_t *drive = tape->drive;
1188 size_t done = 0;
1189 ssize_t ret = 0;
1190 int rc;
1191
1192
1193 if (tape->write_prot)
1194 return -EACCES;
1195
1196 ide_debug_log(IDE_DBG_FUNC, "count %Zd", count);
1197
1198
1199 rc = idetape_init_rw(drive, IDETAPE_DIR_WRITE);
1200 if (rc < 0)
1201 return rc;
1202
1203 while (done < count) {
1204 size_t todo;
1205
1206
1207 if (tape->valid == tape->buffer_size &&
1208 idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE,
1209 tape->buffer_size) <= 0)
1210 return rc;
1211
1212
1213 todo = min_t(size_t, count - done,
1214 tape->buffer_size - tape->valid);
1215 if (copy_from_user(tape->cur, buf + done, todo))
1216 ret = -EFAULT;
1217
1218 tape->cur += todo;
1219 tape->valid += todo;
1220 done += todo;
1221 }
1222
1223 return ret ? ret : done;
1224}
1225
1226static int idetape_write_filemark(ide_drive_t *drive)
1227{
1228 struct ide_tape_obj *tape = drive->driver_data;
1229 struct ide_atapi_pc pc;
1230
1231
1232 idetape_create_write_filemark_cmd(drive, &pc, 1);
1233 if (ide_queue_pc_tail(drive, tape->disk, &pc, NULL, 0)) {
1234 printk(KERN_ERR "ide-tape: Couldn't write a filemark\n");
1235 return -EIO;
1236 }
1237 return 0;
1238}
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count)
1254{
1255 idetape_tape_t *tape = drive->driver_data;
1256 struct gendisk *disk = tape->disk;
1257 struct ide_atapi_pc pc;
1258 int i, retval;
1259
1260 ide_debug_log(IDE_DBG_FUNC, "MTIOCTOP ioctl: mt_op: %d, mt_count: %d",
1261 mt_op, mt_count);
1262
1263 switch (mt_op) {
1264 case MTFSF:
1265 case MTFSFM:
1266 case MTBSF:
1267 case MTBSFM:
1268 if (!mt_count)
1269 return 0;
1270 return idetape_space_over_filemarks(drive, mt_op, mt_count);
1271 default:
1272 break;
1273 }
1274
1275 switch (mt_op) {
1276 case MTWEOF:
1277 if (tape->write_prot)
1278 return -EACCES;
1279 ide_tape_discard_merge_buffer(drive, 1);
1280 for (i = 0; i < mt_count; i++) {
1281 retval = idetape_write_filemark(drive);
1282 if (retval)
1283 return retval;
1284 }
1285 return 0;
1286 case MTREW:
1287 ide_tape_discard_merge_buffer(drive, 0);
1288 if (idetape_rewind_tape(drive))
1289 return -EIO;
1290 return 0;
1291 case MTLOAD:
1292 ide_tape_discard_merge_buffer(drive, 0);
1293 return ide_do_start_stop(drive, disk, IDETAPE_LU_LOAD_MASK);
1294 case MTUNLOAD:
1295 case MTOFFL:
1296
1297
1298
1299
1300 if (tape->door_locked) {
1301 if (!ide_set_media_lock(drive, disk, 0))
1302 tape->door_locked = DOOR_UNLOCKED;
1303 }
1304 ide_tape_discard_merge_buffer(drive, 0);
1305 retval = ide_do_start_stop(drive, disk, !IDETAPE_LU_LOAD_MASK);
1306 if (!retval)
1307 clear_bit(ilog2(IDE_AFLAG_MEDIUM_PRESENT),
1308 &drive->atapi_flags);
1309 return retval;
1310 case MTNOP:
1311 ide_tape_discard_merge_buffer(drive, 0);
1312 return idetape_flush_tape_buffers(drive);
1313 case MTRETEN:
1314 ide_tape_discard_merge_buffer(drive, 0);
1315 return ide_do_start_stop(drive, disk,
1316 IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK);
1317 case MTEOM:
1318 idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD);
1319 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
1320 case MTERASE:
1321 (void)idetape_rewind_tape(drive);
1322 idetape_create_erase_cmd(&pc);
1323 return ide_queue_pc_tail(drive, disk, &pc, NULL, 0);
1324 case MTSETBLK:
1325 if (mt_count) {
1326 if (mt_count < tape->blk_size ||
1327 mt_count % tape->blk_size)
1328 return -EIO;
1329 tape->user_bs_factor = mt_count / tape->blk_size;
1330 clear_bit(ilog2(IDE_AFLAG_DETECT_BS),
1331 &drive->atapi_flags);
1332 } else
1333 set_bit(ilog2(IDE_AFLAG_DETECT_BS),
1334 &drive->atapi_flags);
1335 return 0;
1336 case MTSEEK:
1337 ide_tape_discard_merge_buffer(drive, 0);
1338 return idetape_position_tape(drive,
1339 mt_count * tape->user_bs_factor, tape->partition, 0);
1340 case MTSETPART:
1341 ide_tape_discard_merge_buffer(drive, 0);
1342 return idetape_position_tape(drive, 0, mt_count, 0);
1343 case MTFSR:
1344 case MTBSR:
1345 case MTLOCK:
1346 retval = ide_set_media_lock(drive, disk, 1);
1347 if (retval)
1348 return retval;
1349 tape->door_locked = DOOR_EXPLICITLY_LOCKED;
1350 return 0;
1351 case MTUNLOCK:
1352 retval = ide_set_media_lock(drive, disk, 0);
1353 if (retval)
1354 return retval;
1355 tape->door_locked = DOOR_UNLOCKED;
1356 return 0;
1357 default:
1358 printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n",
1359 mt_op);
1360 return -EIO;
1361 }
1362}
1363
1364
1365
1366
1367
1368
1369static long do_idetape_chrdev_ioctl(struct file *file,
1370 unsigned int cmd, unsigned long arg)
1371{
1372 struct ide_tape_obj *tape = file->private_data;
1373 ide_drive_t *drive = tape->drive;
1374 struct mtop mtop;
1375 struct mtget mtget;
1376 struct mtpos mtpos;
1377 int block_offset = 0, position = tape->first_frame;
1378 void __user *argp = (void __user *)arg;
1379
1380 ide_debug_log(IDE_DBG_FUNC, "cmd: 0x%x", cmd);
1381
1382 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
1383 ide_tape_flush_merge_buffer(drive);
1384 idetape_flush_tape_buffers(drive);
1385 }
1386 if (cmd == MTIOCGET || cmd == MTIOCPOS) {
1387 block_offset = tape->valid /
1388 (tape->blk_size * tape->user_bs_factor);
1389 position = ide_tape_read_position(drive);
1390 if (position < 0)
1391 return -EIO;
1392 }
1393 switch (cmd) {
1394 case MTIOCTOP:
1395 if (copy_from_user(&mtop, argp, sizeof(struct mtop)))
1396 return -EFAULT;
1397 return idetape_mtioctop(drive, mtop.mt_op, mtop.mt_count);
1398 case MTIOCGET:
1399 memset(&mtget, 0, sizeof(struct mtget));
1400 mtget.mt_type = MT_ISSCSI2;
1401 mtget.mt_blkno = position / tape->user_bs_factor - block_offset;
1402 mtget.mt_dsreg =
1403 ((tape->blk_size * tape->user_bs_factor)
1404 << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK;
1405
1406 if (tape->drv_write_prot)
1407 mtget.mt_gstat |= GMT_WR_PROT(0xffffffff);
1408
1409 if (copy_to_user(argp, &mtget, sizeof(struct mtget)))
1410 return -EFAULT;
1411 return 0;
1412 case MTIOCPOS:
1413 mtpos.mt_blkno = position / tape->user_bs_factor - block_offset;
1414 if (copy_to_user(argp, &mtpos, sizeof(struct mtpos)))
1415 return -EFAULT;
1416 return 0;
1417 default:
1418 if (tape->chrdev_dir == IDETAPE_DIR_READ)
1419 ide_tape_discard_merge_buffer(drive, 1);
1420 return idetape_blkdev_ioctl(drive, cmd, arg);
1421 }
1422}
1423
1424static long idetape_chrdev_ioctl(struct file *file,
1425 unsigned int cmd, unsigned long arg)
1426{
1427 long ret;
1428 mutex_lock(&ide_tape_mutex);
1429 ret = do_idetape_chrdev_ioctl(file, cmd, arg);
1430 mutex_unlock(&ide_tape_mutex);
1431 return ret;
1432}
1433
1434
1435
1436
1437
1438static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive)
1439{
1440 idetape_tape_t *tape = drive->driver_data;
1441 struct ide_atapi_pc pc;
1442 u8 buf[12];
1443
1444 idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR);
1445 if (ide_queue_pc_tail(drive, tape->disk, &pc, buf, pc.req_xfer)) {
1446 printk(KERN_ERR "ide-tape: Can't get block descriptor\n");
1447 if (tape->blk_size == 0) {
1448 printk(KERN_WARNING "ide-tape: Cannot deal with zero "
1449 "block size, assuming 32k\n");
1450 tape->blk_size = 32768;
1451 }
1452 return;
1453 }
1454 tape->blk_size = (buf[4 + 5] << 16) +
1455 (buf[4 + 6] << 8) +
1456 buf[4 + 7];
1457 tape->drv_write_prot = (buf[2] & 0x80) >> 7;
1458
1459 ide_debug_log(IDE_DBG_FUNC, "blk_size: %d, write_prot: %d",
1460 tape->blk_size, tape->drv_write_prot);
1461}
1462
1463static int idetape_chrdev_open(struct inode *inode, struct file *filp)
1464{
1465 unsigned int minor = iminor(inode), i = minor & ~0xc0;
1466 ide_drive_t *drive;
1467 idetape_tape_t *tape;
1468 int retval;
1469
1470 if (i >= MAX_HWIFS * MAX_DRIVES)
1471 return -ENXIO;
1472
1473 mutex_lock(&idetape_chrdev_mutex);
1474
1475 tape = ide_tape_get(NULL, true, i);
1476 if (!tape) {
1477 mutex_unlock(&idetape_chrdev_mutex);
1478 return -ENXIO;
1479 }
1480
1481 drive = tape->drive;
1482 filp->private_data = tape;
1483
1484 ide_debug_log(IDE_DBG_FUNC, "enter");
1485
1486
1487
1488
1489
1490
1491 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1492
1493
1494 if (test_and_set_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags)) {
1495 retval = -EBUSY;
1496 goto out_put_tape;
1497 }
1498
1499 retval = idetape_wait_ready(drive, 60 * HZ);
1500 if (retval) {
1501 clear_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags);
1502 printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name);
1503 goto out_put_tape;
1504 }
1505
1506 ide_tape_read_position(drive);
1507 if (!test_bit(ilog2(IDE_AFLAG_ADDRESS_VALID), &drive->atapi_flags))
1508 (void)idetape_rewind_tape(drive);
1509
1510
1511 ide_tape_get_bsize_from_bdesc(drive);
1512
1513
1514 if ((filp->f_flags & O_ACCMODE) == O_RDONLY)
1515 tape->write_prot = 1;
1516 else
1517 tape->write_prot = tape->drv_write_prot;
1518
1519
1520 if (tape->write_prot) {
1521 if ((filp->f_flags & O_ACCMODE) == O_WRONLY ||
1522 (filp->f_flags & O_ACCMODE) == O_RDWR) {
1523 clear_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags);
1524 retval = -EROFS;
1525 goto out_put_tape;
1526 }
1527 }
1528
1529
1530 if (tape->chrdev_dir == IDETAPE_DIR_NONE) {
1531 if (!ide_set_media_lock(drive, tape->disk, 1)) {
1532 if (tape->door_locked != DOOR_EXPLICITLY_LOCKED)
1533 tape->door_locked = DOOR_LOCKED;
1534 }
1535 }
1536 mutex_unlock(&idetape_chrdev_mutex);
1537
1538 return 0;
1539
1540out_put_tape:
1541 ide_tape_put(tape);
1542
1543 mutex_unlock(&idetape_chrdev_mutex);
1544
1545 return retval;
1546}
1547
1548static void idetape_write_release(ide_drive_t *drive, unsigned int minor)
1549{
1550 idetape_tape_t *tape = drive->driver_data;
1551
1552 ide_tape_flush_merge_buffer(drive);
1553 tape->buf = kmalloc(tape->buffer_size, GFP_KERNEL);
1554 if (tape->buf != NULL) {
1555 idetape_pad_zeros(drive, tape->blk_size *
1556 (tape->user_bs_factor - 1));
1557 kfree(tape->buf);
1558 tape->buf = NULL;
1559 }
1560 idetape_write_filemark(drive);
1561 idetape_flush_tape_buffers(drive);
1562 idetape_flush_tape_buffers(drive);
1563}
1564
1565static int idetape_chrdev_release(struct inode *inode, struct file *filp)
1566{
1567 struct ide_tape_obj *tape = filp->private_data;
1568 ide_drive_t *drive = tape->drive;
1569 unsigned int minor = iminor(inode);
1570
1571 mutex_lock(&idetape_chrdev_mutex);
1572
1573 tape = drive->driver_data;
1574
1575 ide_debug_log(IDE_DBG_FUNC, "enter");
1576
1577 if (tape->chrdev_dir == IDETAPE_DIR_WRITE)
1578 idetape_write_release(drive, minor);
1579 if (tape->chrdev_dir == IDETAPE_DIR_READ) {
1580 if (minor < 128)
1581 ide_tape_discard_merge_buffer(drive, 1);
1582 }
1583
1584 if (minor < 128 && test_bit(ilog2(IDE_AFLAG_MEDIUM_PRESENT),
1585 &drive->atapi_flags))
1586 (void) idetape_rewind_tape(drive);
1587
1588 if (tape->chrdev_dir == IDETAPE_DIR_NONE) {
1589 if (tape->door_locked == DOOR_LOCKED) {
1590 if (!ide_set_media_lock(drive, tape->disk, 0))
1591 tape->door_locked = DOOR_UNLOCKED;
1592 }
1593 }
1594 clear_bit(ilog2(IDE_AFLAG_BUSY), &drive->atapi_flags);
1595 ide_tape_put(tape);
1596
1597 mutex_unlock(&idetape_chrdev_mutex);
1598
1599 return 0;
1600}
1601
1602static void idetape_get_inquiry_results(ide_drive_t *drive)
1603{
1604 idetape_tape_t *tape = drive->driver_data;
1605 struct ide_atapi_pc pc;
1606 u8 pc_buf[256];
1607 char fw_rev[4], vendor_id[8], product_id[16];
1608
1609 idetape_create_inquiry_cmd(&pc);
1610 if (ide_queue_pc_tail(drive, tape->disk, &pc, pc_buf, pc.req_xfer)) {
1611 printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n",
1612 tape->name);
1613 return;
1614 }
1615 memcpy(vendor_id, &pc_buf[8], 8);
1616 memcpy(product_id, &pc_buf[16], 16);
1617 memcpy(fw_rev, &pc_buf[32], 4);
1618
1619 ide_fixstring(vendor_id, 8, 0);
1620 ide_fixstring(product_id, 16, 0);
1621 ide_fixstring(fw_rev, 4, 0);
1622
1623 printk(KERN_INFO "ide-tape: %s <-> %s: %.8s %.16s rev %.4s\n",
1624 drive->name, tape->name, vendor_id, product_id, fw_rev);
1625}
1626
1627
1628
1629
1630
1631static void idetape_get_mode_sense_results(ide_drive_t *drive)
1632{
1633 idetape_tape_t *tape = drive->driver_data;
1634 struct ide_atapi_pc pc;
1635 u8 buf[24], *caps;
1636 u8 speed, max_speed;
1637
1638 idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE);
1639 if (ide_queue_pc_tail(drive, tape->disk, &pc, buf, pc.req_xfer)) {
1640 printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming"
1641 " some default values\n");
1642 tape->blk_size = 512;
1643 put_unaligned(52, (u16 *)&tape->caps[12]);
1644 put_unaligned(540, (u16 *)&tape->caps[14]);
1645 put_unaligned(6*52, (u16 *)&tape->caps[16]);
1646 return;
1647 }
1648 caps = buf + 4 + buf[3];
1649
1650
1651 speed = be16_to_cpup((__be16 *)&caps[14]);
1652 max_speed = be16_to_cpup((__be16 *)&caps[8]);
1653
1654 *(u16 *)&caps[8] = max_speed;
1655 *(u16 *)&caps[12] = be16_to_cpup((__be16 *)&caps[12]);
1656 *(u16 *)&caps[14] = speed;
1657 *(u16 *)&caps[16] = be16_to_cpup((__be16 *)&caps[16]);
1658
1659 if (!speed) {
1660 printk(KERN_INFO "ide-tape: %s: invalid tape speed "
1661 "(assuming 650KB/sec)\n", drive->name);
1662 *(u16 *)&caps[14] = 650;
1663 }
1664 if (!max_speed) {
1665 printk(KERN_INFO "ide-tape: %s: invalid max_speed "
1666 "(assuming 650KB/sec)\n", drive->name);
1667 *(u16 *)&caps[8] = 650;
1668 }
1669
1670 memcpy(&tape->caps, caps, 20);
1671
1672
1673 if ((caps[6] & 1) == 0)
1674 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
1675
1676 if (caps[7] & 0x02)
1677 tape->blk_size = 512;
1678 else if (caps[7] & 0x04)
1679 tape->blk_size = 1024;
1680}
1681
1682#ifdef CONFIG_IDE_PROC_FS
1683#define ide_tape_devset_get(name, field) \
1684static int get_##name(ide_drive_t *drive) \
1685{ \
1686 idetape_tape_t *tape = drive->driver_data; \
1687 return tape->field; \
1688}
1689
1690#define ide_tape_devset_set(name, field) \
1691static int set_##name(ide_drive_t *drive, int arg) \
1692{ \
1693 idetape_tape_t *tape = drive->driver_data; \
1694 tape->field = arg; \
1695 return 0; \
1696}
1697
1698#define ide_tape_devset_rw_field(_name, _field) \
1699ide_tape_devset_get(_name, _field) \
1700ide_tape_devset_set(_name, _field) \
1701IDE_DEVSET(_name, DS_SYNC, get_##_name, set_##_name)
1702
1703#define ide_tape_devset_r_field(_name, _field) \
1704ide_tape_devset_get(_name, _field) \
1705IDE_DEVSET(_name, 0, get_##_name, NULL)
1706
1707static int mulf_tdsc(ide_drive_t *drive) { return 1000; }
1708static int divf_tdsc(ide_drive_t *drive) { return HZ; }
1709static int divf_buffer(ide_drive_t *drive) { return 2; }
1710static int divf_buffer_size(ide_drive_t *drive) { return 1024; }
1711
1712ide_devset_rw_flag(dsc_overlap, IDE_DFLAG_DSC_OVERLAP);
1713
1714ide_tape_devset_rw_field(tdsc, best_dsc_rw_freq);
1715
1716ide_tape_devset_r_field(avg_speed, avg_speed);
1717ide_tape_devset_r_field(speed, caps[14]);
1718ide_tape_devset_r_field(buffer, caps[16]);
1719ide_tape_devset_r_field(buffer_size, buffer_size);
1720
1721static const struct ide_proc_devset idetape_settings[] = {
1722 __IDE_PROC_DEVSET(avg_speed, 0, 0xffff, NULL, NULL),
1723 __IDE_PROC_DEVSET(buffer, 0, 0xffff, NULL, divf_buffer),
1724 __IDE_PROC_DEVSET(buffer_size, 0, 0xffff, NULL, divf_buffer_size),
1725 __IDE_PROC_DEVSET(dsc_overlap, 0, 1, NULL, NULL),
1726 __IDE_PROC_DEVSET(speed, 0, 0xffff, NULL, NULL),
1727 __IDE_PROC_DEVSET(tdsc, IDETAPE_DSC_RW_MIN, IDETAPE_DSC_RW_MAX,
1728 mulf_tdsc, divf_tdsc),
1729 { NULL },
1730};
1731#endif
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor)
1745{
1746 unsigned long t;
1747 int speed;
1748 int buffer_size;
1749 u16 *ctl = (u16 *)&tape->caps[12];
1750
1751 ide_debug_log(IDE_DBG_FUNC, "minor: %d", minor);
1752
1753 drive->pc_callback = ide_tape_callback;
1754
1755 drive->dev_flags |= IDE_DFLAG_DSC_OVERLAP;
1756
1757 if (drive->hwif->host_flags & IDE_HFLAG_NO_DSC) {
1758 printk(KERN_INFO "ide-tape: %s: disabling DSC overlap\n",
1759 tape->name);
1760 drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
1761 }
1762
1763
1764 if (strstr((char *)&drive->id[ATA_ID_PROD], "Seagate STT3401"))
1765 drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
1766
1767 tape->minor = minor;
1768 tape->name[0] = 'h';
1769 tape->name[1] = 't';
1770 tape->name[2] = '0' + minor;
1771 tape->chrdev_dir = IDETAPE_DIR_NONE;
1772
1773 idetape_get_inquiry_results(drive);
1774 idetape_get_mode_sense_results(drive);
1775 ide_tape_get_bsize_from_bdesc(drive);
1776 tape->user_bs_factor = 1;
1777 tape->buffer_size = *ctl * tape->blk_size;
1778 while (tape->buffer_size > 0xffff) {
1779 printk(KERN_NOTICE "ide-tape: decreasing stage size\n");
1780 *ctl /= 2;
1781 tape->buffer_size = *ctl * tape->blk_size;
1782 }
1783 buffer_size = tape->buffer_size;
1784
1785
1786 speed = max(*(u16 *)&tape->caps[14], *(u16 *)&tape->caps[8]);
1787
1788 t = (IDETAPE_FIFO_THRESHOLD * tape->buffer_size * HZ) / (speed * 1000);
1789
1790
1791
1792
1793
1794 tape->best_dsc_rw_freq = clamp_t(unsigned long, t, IDETAPE_DSC_RW_MIN,
1795 IDETAPE_DSC_RW_MAX);
1796 printk(KERN_INFO "ide-tape: %s <-> %s: %dKBps, %d*%dkB buffer, "
1797 "%lums tDSC%s\n",
1798 drive->name, tape->name, *(u16 *)&tape->caps[14],
1799 (*(u16 *)&tape->caps[16] * 512) / tape->buffer_size,
1800 tape->buffer_size / 1024,
1801 tape->best_dsc_rw_freq * 1000 / HZ,
1802 (drive->dev_flags & IDE_DFLAG_USING_DMA) ? ", DMA" : "");
1803
1804 ide_proc_register_driver(drive, tape->driver);
1805}
1806
1807static void ide_tape_remove(ide_drive_t *drive)
1808{
1809 idetape_tape_t *tape = drive->driver_data;
1810
1811 ide_proc_unregister_driver(drive, tape->driver);
1812 device_del(&tape->dev);
1813 ide_unregister_region(tape->disk);
1814
1815 mutex_lock(&idetape_ref_mutex);
1816 put_device(&tape->dev);
1817 mutex_unlock(&idetape_ref_mutex);
1818}
1819
1820static void ide_tape_release(struct device *dev)
1821{
1822 struct ide_tape_obj *tape = to_ide_drv(dev, ide_tape_obj);
1823 ide_drive_t *drive = tape->drive;
1824 struct gendisk *g = tape->disk;
1825
1826 BUG_ON(tape->valid);
1827
1828 drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
1829 drive->driver_data = NULL;
1830 device_destroy(idetape_sysfs_class, MKDEV(IDETAPE_MAJOR, tape->minor));
1831 device_destroy(idetape_sysfs_class,
1832 MKDEV(IDETAPE_MAJOR, tape->minor + 128));
1833 idetape_devs[tape->minor] = NULL;
1834 g->private_data = NULL;
1835 put_disk(g);
1836 kfree(tape);
1837}
1838
1839#ifdef CONFIG_IDE_PROC_FS
1840static int idetape_name_proc_show(struct seq_file *m, void *v)
1841{
1842 ide_drive_t *drive = (ide_drive_t *) m->private;
1843 idetape_tape_t *tape = drive->driver_data;
1844
1845 seq_printf(m, "%s\n", tape->name);
1846 return 0;
1847}
1848
1849static int idetape_name_proc_open(struct inode *inode, struct file *file)
1850{
1851 return single_open(file, idetape_name_proc_show, PDE(inode)->data);
1852}
1853
1854static const struct file_operations idetape_name_proc_fops = {
1855 .owner = THIS_MODULE,
1856 .open = idetape_name_proc_open,
1857 .read = seq_read,
1858 .llseek = seq_lseek,
1859 .release = single_release,
1860};
1861
1862static ide_proc_entry_t idetape_proc[] = {
1863 { "capacity", S_IFREG|S_IRUGO, &ide_capacity_proc_fops },
1864 { "name", S_IFREG|S_IRUGO, &idetape_name_proc_fops },
1865 {}
1866};
1867
1868static ide_proc_entry_t *ide_tape_proc_entries(ide_drive_t *drive)
1869{
1870 return idetape_proc;
1871}
1872
1873static const struct ide_proc_devset *ide_tape_proc_devsets(ide_drive_t *drive)
1874{
1875 return idetape_settings;
1876}
1877#endif
1878
1879static int ide_tape_probe(ide_drive_t *);
1880
1881static struct ide_driver idetape_driver = {
1882 .gen_driver = {
1883 .owner = THIS_MODULE,
1884 .name = "ide-tape",
1885 .bus = &ide_bus_type,
1886 },
1887 .probe = ide_tape_probe,
1888 .remove = ide_tape_remove,
1889 .version = IDETAPE_VERSION,
1890 .do_request = idetape_do_request,
1891#ifdef CONFIG_IDE_PROC_FS
1892 .proc_entries = ide_tape_proc_entries,
1893 .proc_devsets = ide_tape_proc_devsets,
1894#endif
1895};
1896
1897
1898static const struct file_operations idetape_fops = {
1899 .owner = THIS_MODULE,
1900 .read = idetape_chrdev_read,
1901 .write = idetape_chrdev_write,
1902 .unlocked_ioctl = idetape_chrdev_ioctl,
1903 .open = idetape_chrdev_open,
1904 .release = idetape_chrdev_release,
1905 .llseek = noop_llseek,
1906};
1907
1908static int idetape_open(struct block_device *bdev, fmode_t mode)
1909{
1910 struct ide_tape_obj *tape;
1911
1912 mutex_lock(&ide_tape_mutex);
1913 tape = ide_tape_get(bdev->bd_disk, false, 0);
1914 mutex_unlock(&ide_tape_mutex);
1915
1916 if (!tape)
1917 return -ENXIO;
1918
1919 return 0;
1920}
1921
1922static int idetape_release(struct gendisk *disk, fmode_t mode)
1923{
1924 struct ide_tape_obj *tape = ide_drv_g(disk, ide_tape_obj);
1925
1926 mutex_lock(&ide_tape_mutex);
1927 ide_tape_put(tape);
1928 mutex_unlock(&ide_tape_mutex);
1929
1930 return 0;
1931}
1932
1933static int idetape_ioctl(struct block_device *bdev, fmode_t mode,
1934 unsigned int cmd, unsigned long arg)
1935{
1936 struct ide_tape_obj *tape = ide_drv_g(bdev->bd_disk, ide_tape_obj);
1937 ide_drive_t *drive = tape->drive;
1938 int err;
1939
1940 mutex_lock(&ide_tape_mutex);
1941 err = generic_ide_ioctl(drive, bdev, cmd, arg);
1942 if (err == -EINVAL)
1943 err = idetape_blkdev_ioctl(drive, cmd, arg);
1944 mutex_unlock(&ide_tape_mutex);
1945
1946 return err;
1947}
1948
1949static const struct block_device_operations idetape_block_ops = {
1950 .owner = THIS_MODULE,
1951 .open = idetape_open,
1952 .release = idetape_release,
1953 .ioctl = idetape_ioctl,
1954};
1955
1956static int ide_tape_probe(ide_drive_t *drive)
1957{
1958 idetape_tape_t *tape;
1959 struct gendisk *g;
1960 int minor;
1961
1962 ide_debug_log(IDE_DBG_FUNC, "enter");
1963
1964 if (!strstr(DRV_NAME, drive->driver_req))
1965 goto failed;
1966
1967 if (drive->media != ide_tape)
1968 goto failed;
1969
1970 if ((drive->dev_flags & IDE_DFLAG_ID_READ) &&
1971 ide_check_atapi_device(drive, DRV_NAME) == 0) {
1972 printk(KERN_ERR "ide-tape: %s: not supported by this version of"
1973 " the driver\n", drive->name);
1974 goto failed;
1975 }
1976 tape = kzalloc(sizeof(idetape_tape_t), GFP_KERNEL);
1977 if (tape == NULL) {
1978 printk(KERN_ERR "ide-tape: %s: Can't allocate a tape struct\n",
1979 drive->name);
1980 goto failed;
1981 }
1982
1983 g = alloc_disk(1 << PARTN_BITS);
1984 if (!g)
1985 goto out_free_tape;
1986
1987 ide_init_disk(g, drive);
1988
1989 tape->dev.parent = &drive->gendev;
1990 tape->dev.release = ide_tape_release;
1991 dev_set_name(&tape->dev, dev_name(&drive->gendev));
1992
1993 if (device_register(&tape->dev))
1994 goto out_free_disk;
1995
1996 tape->drive = drive;
1997 tape->driver = &idetape_driver;
1998 tape->disk = g;
1999
2000 g->private_data = &tape->driver;
2001
2002 drive->driver_data = tape;
2003
2004 mutex_lock(&idetape_ref_mutex);
2005 for (minor = 0; idetape_devs[minor]; minor++)
2006 ;
2007 idetape_devs[minor] = tape;
2008 mutex_unlock(&idetape_ref_mutex);
2009
2010 idetape_setup(drive, tape, minor);
2011
2012 device_create(idetape_sysfs_class, &drive->gendev,
2013 MKDEV(IDETAPE_MAJOR, minor), NULL, "%s", tape->name);
2014 device_create(idetape_sysfs_class, &drive->gendev,
2015 MKDEV(IDETAPE_MAJOR, minor + 128), NULL,
2016 "n%s", tape->name);
2017
2018 g->fops = &idetape_block_ops;
2019 ide_register_region(g);
2020
2021 return 0;
2022
2023out_free_disk:
2024 put_disk(g);
2025out_free_tape:
2026 kfree(tape);
2027failed:
2028 return -ENODEV;
2029}
2030
2031static void __exit idetape_exit(void)
2032{
2033 driver_unregister(&idetape_driver.gen_driver);
2034 class_destroy(idetape_sysfs_class);
2035 unregister_chrdev(IDETAPE_MAJOR, "ht");
2036}
2037
2038static int __init idetape_init(void)
2039{
2040 int error = 1;
2041 idetape_sysfs_class = class_create(THIS_MODULE, "ide_tape");
2042 if (IS_ERR(idetape_sysfs_class)) {
2043 idetape_sysfs_class = NULL;
2044 printk(KERN_ERR "Unable to create sysfs class for ide tapes\n");
2045 error = -EBUSY;
2046 goto out;
2047 }
2048
2049 if (register_chrdev(IDETAPE_MAJOR, "ht", &idetape_fops)) {
2050 printk(KERN_ERR "ide-tape: Failed to register chrdev"
2051 " interface\n");
2052 error = -EBUSY;
2053 goto out_free_class;
2054 }
2055
2056 error = driver_register(&idetape_driver.gen_driver);
2057 if (error)
2058 goto out_free_driver;
2059
2060 return 0;
2061
2062out_free_driver:
2063 driver_unregister(&idetape_driver.gen_driver);
2064out_free_class:
2065 class_destroy(idetape_sysfs_class);
2066out:
2067 return error;
2068}
2069
2070MODULE_ALIAS("ide:*m-tape*");
2071module_init(idetape_init);
2072module_exit(idetape_exit);
2073MODULE_ALIAS_CHARDEV_MAJOR(IDETAPE_MAJOR);
2074MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver");
2075MODULE_LICENSE("GPL");
2076