ide-tape.c revision d6e2955a6b82d2312b5ff885ce13c8ab54d59d96
1/* 2 * IDE ATAPI streaming tape driver. 3 * 4 * Copyright (C) 1995-1999 Gadi Oxman <gadio@netvision.net.il> 5 * Copyright (C) 2003-2005 Bartlomiej Zolnierkiewicz 6 * 7 * This driver was constructed as a student project in the software laboratory 8 * of the faculty of electrical engineering in the Technion - Israel's 9 * Institute Of Technology, with the guide of Avner Lottem and Dr. Ilana David. 10 * 11 * It is hereby placed under the terms of the GNU general public license. 12 * (See linux/COPYING). 13 * 14 * For a historical changelog see 15 * Documentation/ide/ChangeLog.ide-tape.1995-2002 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/slab.h> 35#include <linux/pci.h> 36#include <linux/ide.h> 37#include <linux/smp_lock.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 50enum { 51 /* output errors only */ 52 DBG_ERR = (1 << 0), 53 /* output all sense key/asc */ 54 DBG_SENSE = (1 << 1), 55 /* info regarding all chrdev-related procedures */ 56 DBG_CHRDEV = (1 << 2), 57 /* all remaining procedures */ 58 DBG_PROCS = (1 << 3), 59}; 60 61/* define to see debug info */ 62#define IDETAPE_DEBUG_LOG 0 63 64#if IDETAPE_DEBUG_LOG 65#define debug_log(lvl, fmt, args...) \ 66{ \ 67 if (tape->debug_mask & lvl) \ 68 printk(KERN_INFO "ide-tape: " fmt, ## args); \ 69} 70#else 71#define debug_log(lvl, fmt, args...) do {} while (0) 72#endif 73 74/**************************** Tunable parameters *****************************/ 75/* 76 * After each failed packet command we issue a request sense command and retry 77 * the packet command IDETAPE_MAX_PC_RETRIES times. 78 * 79 * Setting IDETAPE_MAX_PC_RETRIES to 0 will disable retries. 80 */ 81#define IDETAPE_MAX_PC_RETRIES 3 82 83/* 84 * The following parameter is used to select the point in the internal tape fifo 85 * in which we will start to refill the buffer. Decreasing the following 86 * parameter will improve the system's latency and interactive response, while 87 * using a high value might improve system throughput. 88 */ 89#define IDETAPE_FIFO_THRESHOLD 2 90 91/* 92 * DSC polling parameters. 93 * 94 * Polling for DSC (a single bit in the status register) is a very important 95 * function in ide-tape. There are two cases in which we poll for DSC: 96 * 97 * 1. Before a read/write packet command, to ensure that we can transfer data 98 * from/to the tape's data buffers, without causing an actual media access. 99 * In case the tape is not ready yet, we take out our request from the device 100 * request queue, so that ide.c could service requests from the other device 101 * on the same interface in the meantime. 102 * 103 * 2. After the successful initialization of a "media access packet command", 104 * which is a command that can take a long time to complete (the interval can 105 * range from several seconds to even an hour). Again, we postpone our request 106 * in the middle to free the bus for the other device. The polling frequency 107 * here should be lower than the read/write frequency since those media access 108 * commands are slow. We start from a "fast" frequency - IDETAPE_DSC_MA_FAST 109 * (1 second), and if we don't receive DSC after IDETAPE_DSC_MA_THRESHOLD 110 * (5 min), we switch it to a lower frequency - IDETAPE_DSC_MA_SLOW (1 min). 111 * 112 * We also set a timeout for the timer, in case something goes wrong. The 113 * timeout should be longer then the maximum execution time of a tape operation. 114 */ 115 116/* DSC timings. */ 117#define IDETAPE_DSC_RW_MIN 5*HZ/100 /* 50 msec */ 118#define IDETAPE_DSC_RW_MAX 40*HZ/100 /* 400 msec */ 119#define IDETAPE_DSC_RW_TIMEOUT 2*60*HZ /* 2 minutes */ 120#define IDETAPE_DSC_MA_FAST 2*HZ /* 2 seconds */ 121#define IDETAPE_DSC_MA_THRESHOLD 5*60*HZ /* 5 minutes */ 122#define IDETAPE_DSC_MA_SLOW 30*HZ /* 30 seconds */ 123#define IDETAPE_DSC_MA_TIMEOUT 2*60*60*HZ /* 2 hours */ 124 125/*************************** End of tunable parameters ***********************/ 126 127/* tape directions */ 128enum { 129 IDETAPE_DIR_NONE = (1 << 0), 130 IDETAPE_DIR_READ = (1 << 1), 131 IDETAPE_DIR_WRITE = (1 << 2), 132}; 133 134struct idetape_bh { 135 u32 b_size; 136 atomic_t b_count; 137 struct idetape_bh *b_reqnext; 138 char *b_data; 139}; 140 141/* Tape door status */ 142#define DOOR_UNLOCKED 0 143#define DOOR_LOCKED 1 144#define DOOR_EXPLICITLY_LOCKED 2 145 146/* Some defines for the SPACE command */ 147#define IDETAPE_SPACE_OVER_FILEMARK 1 148#define IDETAPE_SPACE_TO_EOD 3 149 150/* Some defines for the LOAD UNLOAD command */ 151#define IDETAPE_LU_LOAD_MASK 1 152#define IDETAPE_LU_RETENSION_MASK 2 153#define IDETAPE_LU_EOT_MASK 4 154 155/* Error codes returned in rq->errors to the higher part of the driver. */ 156#define IDETAPE_ERROR_GENERAL 101 157#define IDETAPE_ERROR_FILEMARK 102 158#define IDETAPE_ERROR_EOD 103 159 160/* Structures related to the SELECT SENSE / MODE SENSE packet commands. */ 161#define IDETAPE_BLOCK_DESCRIPTOR 0 162#define IDETAPE_CAPABILITIES_PAGE 0x2a 163 164/* 165 * Most of our global data which we need to save even as we leave the driver due 166 * to an interrupt or a timer event is stored in the struct defined below. 167 */ 168typedef struct ide_tape_obj { 169 ide_drive_t *drive; 170 ide_driver_t *driver; 171 struct gendisk *disk; 172 struct kref kref; 173 174 /* 175 * pc points to the current processed packet command. 176 * 177 * failed_pc points to the last failed packet command, or contains 178 * NULL if we do not need to retry any packet command. This is 179 * required since an additional packet command is needed before the 180 * retry, to get detailed information on what went wrong. 181 */ 182 /* Current packet command */ 183 struct ide_atapi_pc *pc; 184 /* Last failed packet command */ 185 struct ide_atapi_pc *failed_pc; 186 /* used by REQ_IDETAPE_{READ,WRITE} requests */ 187 struct ide_atapi_pc queued_pc; 188 189 struct ide_atapi_pc request_sense_pc; 190 struct request request_sense_rq; 191 192 /* 193 * DSC polling variables. 194 * 195 * While polling for DSC we use postponed_rq to postpone the current 196 * request so that ide.c will be able to service pending requests on the 197 * other device. Note that at most we will have only one DSC (usually 198 * data transfer) request in the device request queue. 199 */ 200 struct request *postponed_rq; 201 /* The time in which we started polling for DSC */ 202 unsigned long dsc_polling_start; 203 /* Timer used to poll for dsc */ 204 struct timer_list dsc_timer; 205 /* Read/Write dsc polling frequency */ 206 unsigned long best_dsc_rw_freq; 207 unsigned long dsc_poll_freq; 208 unsigned long dsc_timeout; 209 210 /* Read position information */ 211 u8 partition; 212 /* Current block */ 213 unsigned int first_frame; 214 215 /* Last error information */ 216 u8 sense_key, asc, ascq; 217 218 /* Character device operation */ 219 unsigned int minor; 220 /* device name */ 221 char name[4]; 222 /* Current character device data transfer direction */ 223 u8 chrdev_dir; 224 225 /* tape block size, usually 512 or 1024 bytes */ 226 unsigned short blk_size; 227 int user_bs_factor; 228 229 /* Copy of the tape's Capabilities and Mechanical Page */ 230 u8 caps[20]; 231 232 /* 233 * Active data transfer request parameters. 234 * 235 * At most, there is only one ide-tape originated data transfer request 236 * in the device request queue. This allows ide.c to easily service 237 * requests from the other device when we postpone our active request. 238 */ 239 240 /* Data buffer size chosen based on the tape's recommendation */ 241 int buffer_size; 242 /* merge buffer */ 243 struct idetape_bh *merge_bh; 244 /* size of the merge buffer */ 245 int merge_bh_size; 246 /* pointer to current buffer head within the merge buffer */ 247 struct idetape_bh *bh; 248 char *b_data; 249 int b_count; 250 251 int pages_per_buffer; 252 /* Wasted space in each stage */ 253 int excess_bh_size; 254 255 /* protects the ide-tape queue */ 256 spinlock_t lock; 257 258 /* Measures average tape speed */ 259 unsigned long avg_time; 260 int avg_size; 261 int avg_speed; 262 263 /* the door is currently locked */ 264 int door_locked; 265 /* the tape hardware is write protected */ 266 char drv_write_prot; 267 /* the tape is write protected (hardware or opened as read-only) */ 268 char write_prot; 269 270 u32 debug_mask; 271} idetape_tape_t; 272 273static DEFINE_MUTEX(idetape_ref_mutex); 274 275static struct class *idetape_sysfs_class; 276 277#define to_ide_tape(obj) container_of(obj, struct ide_tape_obj, kref) 278 279#define ide_tape_g(disk) \ 280 container_of((disk)->private_data, struct ide_tape_obj, driver) 281 282static void ide_tape_release(struct kref *); 283 284static struct ide_tape_obj *ide_tape_get(struct gendisk *disk) 285{ 286 struct ide_tape_obj *tape = NULL; 287 288 mutex_lock(&idetape_ref_mutex); 289 tape = ide_tape_g(disk); 290 if (tape) { 291 if (ide_device_get(tape->drive)) 292 tape = NULL; 293 else 294 kref_get(&tape->kref); 295 } 296 mutex_unlock(&idetape_ref_mutex); 297 return tape; 298} 299 300static void ide_tape_put(struct ide_tape_obj *tape) 301{ 302 ide_drive_t *drive = tape->drive; 303 304 mutex_lock(&idetape_ref_mutex); 305 kref_put(&tape->kref, ide_tape_release); 306 ide_device_put(drive); 307 mutex_unlock(&idetape_ref_mutex); 308} 309 310/* 311 * The variables below are used for the character device interface. Additional 312 * state variables are defined in our ide_drive_t structure. 313 */ 314static struct ide_tape_obj *idetape_devs[MAX_HWIFS * MAX_DRIVES]; 315 316#define ide_tape_f(file) ((file)->private_data) 317 318static struct ide_tape_obj *ide_tape_chrdev_get(unsigned int i) 319{ 320 struct ide_tape_obj *tape = NULL; 321 322 mutex_lock(&idetape_ref_mutex); 323 tape = idetape_devs[i]; 324 if (tape) 325 kref_get(&tape->kref); 326 mutex_unlock(&idetape_ref_mutex); 327 return tape; 328} 329 330static void idetape_input_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, 331 unsigned int bcount) 332{ 333 struct idetape_bh *bh = pc->bh; 334 int count; 335 336 while (bcount) { 337 if (bh == NULL) { 338 printk(KERN_ERR "ide-tape: bh == NULL in " 339 "idetape_input_buffers\n"); 340 ide_pad_transfer(drive, 0, bcount); 341 return; 342 } 343 count = min( 344 (unsigned int)(bh->b_size - atomic_read(&bh->b_count)), 345 bcount); 346 drive->hwif->tp_ops->input_data(drive, NULL, bh->b_data + 347 atomic_read(&bh->b_count), count); 348 bcount -= count; 349 atomic_add(count, &bh->b_count); 350 if (atomic_read(&bh->b_count) == bh->b_size) { 351 bh = bh->b_reqnext; 352 if (bh) 353 atomic_set(&bh->b_count, 0); 354 } 355 } 356 pc->bh = bh; 357} 358 359static void idetape_output_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, 360 unsigned int bcount) 361{ 362 struct idetape_bh *bh = pc->bh; 363 int count; 364 365 while (bcount) { 366 if (bh == NULL) { 367 printk(KERN_ERR "ide-tape: bh == NULL in %s\n", 368 __func__); 369 return; 370 } 371 count = min((unsigned int)pc->b_count, (unsigned int)bcount); 372 drive->hwif->tp_ops->output_data(drive, NULL, pc->b_data, count); 373 bcount -= count; 374 pc->b_data += count; 375 pc->b_count -= count; 376 if (!pc->b_count) { 377 bh = bh->b_reqnext; 378 pc->bh = bh; 379 if (bh) { 380 pc->b_data = bh->b_data; 381 pc->b_count = atomic_read(&bh->b_count); 382 } 383 } 384 } 385} 386 387static void idetape_update_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc) 388{ 389 struct idetape_bh *bh = pc->bh; 390 int count; 391 unsigned int bcount = pc->xferred; 392 393 if (pc->flags & PC_FLAG_WRITING) 394 return; 395 while (bcount) { 396 if (bh == NULL) { 397 printk(KERN_ERR "ide-tape: bh == NULL in %s\n", 398 __func__); 399 return; 400 } 401 count = min((unsigned int)bh->b_size, (unsigned int)bcount); 402 atomic_set(&bh->b_count, count); 403 if (atomic_read(&bh->b_count) == bh->b_size) 404 bh = bh->b_reqnext; 405 bcount -= count; 406 } 407 pc->bh = bh; 408} 409 410/* 411 * called on each failed packet command retry to analyze the request sense. We 412 * currently do not utilize this information. 413 */ 414static void idetape_analyze_error(ide_drive_t *drive, u8 *sense) 415{ 416 idetape_tape_t *tape = drive->driver_data; 417 struct ide_atapi_pc *pc = tape->failed_pc; 418 419 tape->sense_key = sense[2] & 0xF; 420 tape->asc = sense[12]; 421 tape->ascq = sense[13]; 422 423 debug_log(DBG_ERR, "pc = %x, sense key = %x, asc = %x, ascq = %x\n", 424 pc->c[0], tape->sense_key, tape->asc, tape->ascq); 425 426 /* Correct pc->xferred by asking the tape. */ 427 if (pc->flags & PC_FLAG_DMA_ERROR) { 428 pc->xferred = pc->req_xfer - 429 tape->blk_size * 430 get_unaligned_be32(&sense[3]); 431 idetape_update_buffers(drive, pc); 432 } 433 434 /* 435 * If error was the result of a zero-length read or write command, 436 * with sense key=5, asc=0x22, ascq=0, let it slide. Some drives 437 * (i.e. Seagate STT3401A Travan) don't support 0-length read/writes. 438 */ 439 if ((pc->c[0] == READ_6 || pc->c[0] == WRITE_6) 440 /* length == 0 */ 441 && pc->c[4] == 0 && pc->c[3] == 0 && pc->c[2] == 0) { 442 if (tape->sense_key == 5) { 443 /* don't report an error, everything's ok */ 444 pc->error = 0; 445 /* don't retry read/write */ 446 pc->flags |= PC_FLAG_ABORT; 447 } 448 } 449 if (pc->c[0] == READ_6 && (sense[2] & 0x80)) { 450 pc->error = IDETAPE_ERROR_FILEMARK; 451 pc->flags |= PC_FLAG_ABORT; 452 } 453 if (pc->c[0] == WRITE_6) { 454 if ((sense[2] & 0x40) || (tape->sense_key == 0xd 455 && tape->asc == 0x0 && tape->ascq == 0x2)) { 456 pc->error = IDETAPE_ERROR_EOD; 457 pc->flags |= PC_FLAG_ABORT; 458 } 459 } 460 if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) { 461 if (tape->sense_key == 8) { 462 pc->error = IDETAPE_ERROR_EOD; 463 pc->flags |= PC_FLAG_ABORT; 464 } 465 if (!(pc->flags & PC_FLAG_ABORT) && 466 pc->xferred) 467 pc->retries = IDETAPE_MAX_PC_RETRIES + 1; 468 } 469} 470 471/* Free data buffers completely. */ 472static void ide_tape_kfree_buffer(idetape_tape_t *tape) 473{ 474 struct idetape_bh *prev_bh, *bh = tape->merge_bh; 475 476 while (bh) { 477 u32 size = bh->b_size; 478 479 while (size) { 480 unsigned int order = fls(size >> PAGE_SHIFT)-1; 481 482 if (bh->b_data) 483 free_pages((unsigned long)bh->b_data, order); 484 485 size &= (order-1); 486 bh->b_data += (1 << order) * PAGE_SIZE; 487 } 488 prev_bh = bh; 489 bh = bh->b_reqnext; 490 kfree(prev_bh); 491 } 492} 493 494static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects) 495{ 496 struct request *rq = HWGROUP(drive)->rq; 497 idetape_tape_t *tape = drive->driver_data; 498 unsigned long flags; 499 int error; 500 501 debug_log(DBG_PROCS, "Enter %s\n", __func__); 502 503 switch (uptodate) { 504 case 0: error = IDETAPE_ERROR_GENERAL; break; 505 case 1: error = 0; break; 506 default: error = uptodate; 507 } 508 rq->errors = error; 509 if (error) 510 tape->failed_pc = NULL; 511 512 if (!blk_special_request(rq)) { 513 ide_end_request(drive, uptodate, nr_sects); 514 return 0; 515 } 516 517 spin_lock_irqsave(&tape->lock, flags); 518 519 ide_end_drive_cmd(drive, 0, 0); 520 521 spin_unlock_irqrestore(&tape->lock, flags); 522 return 0; 523} 524 525static void ide_tape_callback(ide_drive_t *drive) 526{ 527 idetape_tape_t *tape = drive->driver_data; 528 struct ide_atapi_pc *pc = tape->pc; 529 int uptodate = pc->error ? 0 : 1; 530 531 debug_log(DBG_PROCS, "Enter %s\n", __func__); 532 533 if (tape->failed_pc == pc) 534 tape->failed_pc = NULL; 535 536 if (pc->c[0] == REQUEST_SENSE) { 537 if (uptodate) 538 idetape_analyze_error(drive, pc->buf); 539 else 540 printk(KERN_ERR "ide-tape: Error in REQUEST SENSE " 541 "itself - Aborting request!\n"); 542 } else if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) { 543 struct request *rq = drive->hwif->hwgroup->rq; 544 int blocks = pc->xferred / tape->blk_size; 545 546 tape->avg_size += blocks * tape->blk_size; 547 548 if (time_after_eq(jiffies, tape->avg_time + HZ)) { 549 tape->avg_speed = tape->avg_size * HZ / 550 (jiffies - tape->avg_time) / 1024; 551 tape->avg_size = 0; 552 tape->avg_time = jiffies; 553 } 554 555 tape->first_frame += blocks; 556 rq->current_nr_sectors -= blocks; 557 558 if (pc->error) 559 uptodate = pc->error; 560 } else if (pc->c[0] == READ_POSITION && uptodate) { 561 u8 *readpos = tape->pc->buf; 562 563 debug_log(DBG_SENSE, "BOP - %s\n", 564 (readpos[0] & 0x80) ? "Yes" : "No"); 565 debug_log(DBG_SENSE, "EOP - %s\n", 566 (readpos[0] & 0x40) ? "Yes" : "No"); 567 568 if (readpos[0] & 0x4) { 569 printk(KERN_INFO "ide-tape: Block location is unknown" 570 "to the tape\n"); 571 clear_bit(IDE_AFLAG_ADDRESS_VALID, &drive->atapi_flags); 572 uptodate = 0; 573 } else { 574 debug_log(DBG_SENSE, "Block Location - %u\n", 575 be32_to_cpup((__be32 *)&readpos[4])); 576 577 tape->partition = readpos[1]; 578 tape->first_frame = be32_to_cpup((__be32 *)&readpos[4]); 579 set_bit(IDE_AFLAG_ADDRESS_VALID, &drive->atapi_flags); 580 } 581 } 582 583 idetape_end_request(drive, uptodate, 0); 584} 585 586static void idetape_create_request_sense_cmd(struct ide_atapi_pc *pc) 587{ 588 ide_init_pc(pc); 589 pc->c[0] = REQUEST_SENSE; 590 pc->c[4] = 20; 591 pc->req_xfer = 20; 592} 593 594/* 595 * idetape_retry_pc is called when an error was detected during the 596 * last packet command. We queue a request sense packet command in 597 * the head of the request list. 598 */ 599static void idetape_retry_pc(ide_drive_t *drive) 600{ 601 struct ide_tape_obj *tape = drive->driver_data; 602 struct request *rq = &tape->request_sense_rq; 603 struct ide_atapi_pc *pc = &tape->request_sense_pc; 604 605 (void)ide_read_error(drive); 606 idetape_create_request_sense_cmd(pc); 607 set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags); 608 ide_queue_pc_head(drive, tape->disk, pc, rq); 609} 610 611/* 612 * Postpone the current request so that ide.c will be able to service requests 613 * from another device on the same hwgroup while we are polling for DSC. 614 */ 615static void idetape_postpone_request(ide_drive_t *drive) 616{ 617 idetape_tape_t *tape = drive->driver_data; 618 619 debug_log(DBG_PROCS, "Enter %s\n", __func__); 620 621 tape->postponed_rq = HWGROUP(drive)->rq; 622 ide_stall_queue(drive, tape->dsc_poll_freq); 623} 624 625static void ide_tape_handle_dsc(ide_drive_t *drive) 626{ 627 idetape_tape_t *tape = drive->driver_data; 628 629 /* Media access command */ 630 tape->dsc_polling_start = jiffies; 631 tape->dsc_poll_freq = IDETAPE_DSC_MA_FAST; 632 tape->dsc_timeout = jiffies + IDETAPE_DSC_MA_TIMEOUT; 633 /* Allow ide.c to handle other requests */ 634 idetape_postpone_request(drive); 635} 636 637static int ide_tape_io_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, 638 unsigned int bcount, int write) 639{ 640 if (write) 641 idetape_output_buffers(drive, pc, bcount); 642 else 643 idetape_input_buffers(drive, pc, bcount); 644 645 return bcount; 646} 647 648/* 649 * This is the usual interrupt handler which will be called during a packet 650 * command. We will transfer some of the data (as requested by the drive) and 651 * will re-point interrupt handler to us. When data transfer is finished, we 652 * will act according to the algorithm described before 653 * idetape_issue_pc. 654 */ 655static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 656{ 657 idetape_tape_t *tape = drive->driver_data; 658 659 return ide_pc_intr(drive, tape->pc, idetape_pc_intr, WAIT_TAPE_CMD, 660 NULL, idetape_update_buffers, idetape_retry_pc, 661 ide_tape_handle_dsc, ide_tape_io_buffers); 662} 663 664/* 665 * Packet Command Interface 666 * 667 * The current Packet Command is available in tape->pc, and will not change 668 * until we finish handling it. Each packet command is associated with a 669 * callback function that will be called when the command is finished. 670 * 671 * The handling will be done in three stages: 672 * 673 * 1. idetape_issue_pc will send the packet command to the drive, and will set 674 * the interrupt handler to idetape_pc_intr. 675 * 676 * 2. On each interrupt, idetape_pc_intr will be called. This step will be 677 * repeated until the device signals us that no more interrupts will be issued. 678 * 679 * 3. ATAPI Tape media access commands have immediate status with a delayed 680 * process. In case of a successful initiation of a media access packet command, 681 * the DSC bit will be set when the actual execution of the command is finished. 682 * Since the tape drive will not issue an interrupt, we have to poll for this 683 * event. In this case, we define the request as "low priority request" by 684 * setting rq_status to IDETAPE_RQ_POSTPONED, set a timer to poll for DSC and 685 * exit the driver. 686 * 687 * ide.c will then give higher priority to requests which originate from the 688 * other device, until will change rq_status to RQ_ACTIVE. 689 * 690 * 4. When the packet command is finished, it will be checked for errors. 691 * 692 * 5. In case an error was found, we queue a request sense packet command in 693 * front of the request queue and retry the operation up to 694 * IDETAPE_MAX_PC_RETRIES times. 695 * 696 * 6. In case no error was found, or we decided to give up and not to retry 697 * again, the callback function will be called and then we will handle the next 698 * request. 699 */ 700static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive) 701{ 702 idetape_tape_t *tape = drive->driver_data; 703 704 return ide_transfer_pc(drive, tape->pc, idetape_pc_intr, 705 WAIT_TAPE_CMD, NULL); 706} 707 708static ide_startstop_t idetape_issue_pc(ide_drive_t *drive, 709 struct ide_atapi_pc *pc) 710{ 711 idetape_tape_t *tape = drive->driver_data; 712 713 if (tape->pc->c[0] == REQUEST_SENSE && 714 pc->c[0] == REQUEST_SENSE) { 715 printk(KERN_ERR "ide-tape: possible ide-tape.c bug - " 716 "Two request sense in serial were issued\n"); 717 } 718 719 if (tape->failed_pc == NULL && pc->c[0] != REQUEST_SENSE) 720 tape->failed_pc = pc; 721 /* Set the current packet command */ 722 tape->pc = pc; 723 724 if (pc->retries > IDETAPE_MAX_PC_RETRIES || 725 (pc->flags & PC_FLAG_ABORT)) { 726 /* 727 * We will "abort" retrying a packet command in case legitimate 728 * error code was received (crossing a filemark, or end of the 729 * media, for example). 730 */ 731 if (!(pc->flags & PC_FLAG_ABORT)) { 732 if (!(pc->c[0] == TEST_UNIT_READY && 733 tape->sense_key == 2 && tape->asc == 4 && 734 (tape->ascq == 1 || tape->ascq == 8))) { 735 printk(KERN_ERR "ide-tape: %s: I/O error, " 736 "pc = %2x, key = %2x, " 737 "asc = %2x, ascq = %2x\n", 738 tape->name, pc->c[0], 739 tape->sense_key, tape->asc, 740 tape->ascq); 741 } 742 /* Giving up */ 743 pc->error = IDETAPE_ERROR_GENERAL; 744 } 745 tape->failed_pc = NULL; 746 drive->pc_callback(drive); 747 return ide_stopped; 748 } 749 debug_log(DBG_SENSE, "Retry #%d, cmd = %02X\n", pc->retries, pc->c[0]); 750 751 pc->retries++; 752 753 return ide_issue_pc(drive, pc, idetape_transfer_pc, 754 WAIT_TAPE_CMD, NULL); 755} 756 757/* A mode sense command is used to "sense" tape parameters. */ 758static void idetape_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code) 759{ 760 ide_init_pc(pc); 761 pc->c[0] = MODE_SENSE; 762 if (page_code != IDETAPE_BLOCK_DESCRIPTOR) 763 /* DBD = 1 - Don't return block descriptors */ 764 pc->c[1] = 8; 765 pc->c[2] = page_code; 766 /* 767 * Changed pc->c[3] to 0 (255 will at best return unused info). 768 * 769 * For SCSI this byte is defined as subpage instead of high byte 770 * of length and some IDE drives seem to interpret it this way 771 * and return an error when 255 is used. 772 */ 773 pc->c[3] = 0; 774 /* We will just discard data in that case */ 775 pc->c[4] = 255; 776 if (page_code == IDETAPE_BLOCK_DESCRIPTOR) 777 pc->req_xfer = 12; 778 else if (page_code == IDETAPE_CAPABILITIES_PAGE) 779 pc->req_xfer = 24; 780 else 781 pc->req_xfer = 50; 782} 783 784static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive) 785{ 786 ide_hwif_t *hwif = drive->hwif; 787 idetape_tape_t *tape = drive->driver_data; 788 struct ide_atapi_pc *pc = tape->pc; 789 u8 stat; 790 791 stat = hwif->tp_ops->read_status(hwif); 792 793 if (stat & ATA_DSC) { 794 if (stat & ATA_ERR) { 795 /* Error detected */ 796 if (pc->c[0] != TEST_UNIT_READY) 797 printk(KERN_ERR "ide-tape: %s: I/O error, ", 798 tape->name); 799 /* Retry operation */ 800 idetape_retry_pc(drive); 801 return ide_stopped; 802 } 803 pc->error = 0; 804 } else { 805 pc->error = IDETAPE_ERROR_GENERAL; 806 tape->failed_pc = NULL; 807 } 808 drive->pc_callback(drive); 809 return ide_stopped; 810} 811 812static void ide_tape_create_rw_cmd(idetape_tape_t *tape, 813 struct ide_atapi_pc *pc, struct request *rq, 814 u8 opcode) 815{ 816 struct idetape_bh *bh = (struct idetape_bh *)rq->special; 817 unsigned int length = rq->current_nr_sectors; 818 819 ide_init_pc(pc); 820 put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); 821 pc->c[1] = 1; 822 pc->bh = bh; 823 pc->buf = NULL; 824 pc->buf_size = length * tape->blk_size; 825 pc->req_xfer = pc->buf_size; 826 if (pc->req_xfer == tape->buffer_size) 827 pc->flags |= PC_FLAG_DMA_OK; 828 829 if (opcode == READ_6) { 830 pc->c[0] = READ_6; 831 atomic_set(&bh->b_count, 0); 832 } else if (opcode == WRITE_6) { 833 pc->c[0] = WRITE_6; 834 pc->flags |= PC_FLAG_WRITING; 835 pc->b_data = bh->b_data; 836 pc->b_count = atomic_read(&bh->b_count); 837 } 838 839 memcpy(rq->cmd, pc->c, 12); 840} 841 842static ide_startstop_t idetape_do_request(ide_drive_t *drive, 843 struct request *rq, sector_t block) 844{ 845 ide_hwif_t *hwif = drive->hwif; 846 idetape_tape_t *tape = drive->driver_data; 847 struct ide_atapi_pc *pc = NULL; 848 struct request *postponed_rq = tape->postponed_rq; 849 u8 stat; 850 851 debug_log(DBG_SENSE, "sector: %llu, nr_sectors: %lu," 852 " current_nr_sectors: %u\n", 853 (unsigned long long)rq->sector, rq->nr_sectors, 854 rq->current_nr_sectors); 855 856 if (!blk_special_request(rq)) { 857 /* We do not support buffer cache originated requests. */ 858 printk(KERN_NOTICE "ide-tape: %s: Unsupported request in " 859 "request queue (%d)\n", drive->name, rq->cmd_type); 860 ide_end_request(drive, 0, 0); 861 return ide_stopped; 862 } 863 864 /* Retry a failed packet command */ 865 if (tape->failed_pc && tape->pc->c[0] == REQUEST_SENSE) { 866 pc = tape->failed_pc; 867 goto out; 868 } 869 870 if (postponed_rq != NULL) 871 if (rq != postponed_rq) { 872 printk(KERN_ERR "ide-tape: ide-tape.c bug - " 873 "Two DSC requests were queued\n"); 874 idetape_end_request(drive, 0, 0); 875 return ide_stopped; 876 } 877 878 tape->postponed_rq = NULL; 879 880 /* 881 * If the tape is still busy, postpone our request and service 882 * the other device meanwhile. 883 */ 884 stat = hwif->tp_ops->read_status(hwif); 885 886 if (!drive->dsc_overlap && !(rq->cmd[13] & REQ_IDETAPE_PC2)) 887 set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags); 888 889 if (drive->post_reset == 1) { 890 set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags); 891 drive->post_reset = 0; 892 } 893 894 if (!test_and_clear_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags) && 895 (stat & ATA_DSC) == 0) { 896 if (postponed_rq == NULL) { 897 tape->dsc_polling_start = jiffies; 898 tape->dsc_poll_freq = tape->best_dsc_rw_freq; 899 tape->dsc_timeout = jiffies + IDETAPE_DSC_RW_TIMEOUT; 900 } else if (time_after(jiffies, tape->dsc_timeout)) { 901 printk(KERN_ERR "ide-tape: %s: DSC timeout\n", 902 tape->name); 903 if (rq->cmd[13] & REQ_IDETAPE_PC2) { 904 idetape_media_access_finished(drive); 905 return ide_stopped; 906 } else { 907 return ide_do_reset(drive); 908 } 909 } else if (time_after(jiffies, 910 tape->dsc_polling_start + 911 IDETAPE_DSC_MA_THRESHOLD)) 912 tape->dsc_poll_freq = IDETAPE_DSC_MA_SLOW; 913 idetape_postpone_request(drive); 914 return ide_stopped; 915 } 916 if (rq->cmd[13] & REQ_IDETAPE_READ) { 917 pc = &tape->queued_pc; 918 ide_tape_create_rw_cmd(tape, pc, rq, READ_6); 919 goto out; 920 } 921 if (rq->cmd[13] & REQ_IDETAPE_WRITE) { 922 pc = &tape->queued_pc; 923 ide_tape_create_rw_cmd(tape, pc, rq, WRITE_6); 924 goto out; 925 } 926 if (rq->cmd[13] & REQ_IDETAPE_PC1) { 927 pc = (struct ide_atapi_pc *) rq->buffer; 928 rq->cmd[13] &= ~(REQ_IDETAPE_PC1); 929 rq->cmd[13] |= REQ_IDETAPE_PC2; 930 goto out; 931 } 932 if (rq->cmd[13] & REQ_IDETAPE_PC2) { 933 idetape_media_access_finished(drive); 934 return ide_stopped; 935 } 936 BUG(); 937 938out: 939 return idetape_issue_pc(drive, pc); 940} 941 942/* 943 * The function below uses __get_free_pages to allocate a data buffer of size 944 * tape->buffer_size (or a bit more). We attempt to combine sequential pages as 945 * much as possible. 946 * 947 * It returns a pointer to the newly allocated buffer, or NULL in case of 948 * failure. 949 */ 950static struct idetape_bh *ide_tape_kmalloc_buffer(idetape_tape_t *tape, 951 int full, int clear) 952{ 953 struct idetape_bh *prev_bh, *bh, *merge_bh; 954 int pages = tape->pages_per_buffer; 955 unsigned int order, b_allocd; 956 char *b_data = NULL; 957 958 merge_bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL); 959 bh = merge_bh; 960 if (bh == NULL) 961 goto abort; 962 963 order = fls(pages) - 1; 964 bh->b_data = (char *) __get_free_pages(GFP_KERNEL, order); 965 if (!bh->b_data) 966 goto abort; 967 b_allocd = (1 << order) * PAGE_SIZE; 968 pages &= (order-1); 969 970 if (clear) 971 memset(bh->b_data, 0, b_allocd); 972 bh->b_reqnext = NULL; 973 bh->b_size = b_allocd; 974 atomic_set(&bh->b_count, full ? bh->b_size : 0); 975 976 while (pages) { 977 order = fls(pages) - 1; 978 b_data = (char *) __get_free_pages(GFP_KERNEL, order); 979 if (!b_data) 980 goto abort; 981 b_allocd = (1 << order) * PAGE_SIZE; 982 983 if (clear) 984 memset(b_data, 0, b_allocd); 985 986 /* newly allocated page frames below buffer header or ...*/ 987 if (bh->b_data == b_data + b_allocd) { 988 bh->b_size += b_allocd; 989 bh->b_data -= b_allocd; 990 if (full) 991 atomic_add(b_allocd, &bh->b_count); 992 continue; 993 } 994 /* they are above the header */ 995 if (b_data == bh->b_data + bh->b_size) { 996 bh->b_size += b_allocd; 997 if (full) 998 atomic_add(b_allocd, &bh->b_count); 999 continue; 1000 } 1001 prev_bh = bh; 1002 bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL); 1003 if (!bh) { 1004 free_pages((unsigned long) b_data, order); 1005 goto abort; 1006 } 1007 bh->b_reqnext = NULL; 1008 bh->b_data = b_data; 1009 bh->b_size = b_allocd; 1010 atomic_set(&bh->b_count, full ? bh->b_size : 0); 1011 prev_bh->b_reqnext = bh; 1012 1013 pages &= (order-1); 1014 } 1015 1016 bh->b_size -= tape->excess_bh_size; 1017 if (full) 1018 atomic_sub(tape->excess_bh_size, &bh->b_count); 1019 return merge_bh; 1020abort: 1021 ide_tape_kfree_buffer(tape); 1022 return NULL; 1023} 1024 1025static int idetape_copy_stage_from_user(idetape_tape_t *tape, 1026 const char __user *buf, int n) 1027{ 1028 struct idetape_bh *bh = tape->bh; 1029 int count; 1030 int ret = 0; 1031 1032 while (n) { 1033 if (bh == NULL) { 1034 printk(KERN_ERR "ide-tape: bh == NULL in %s\n", 1035 __func__); 1036 return 1; 1037 } 1038 count = min((unsigned int) 1039 (bh->b_size - atomic_read(&bh->b_count)), 1040 (unsigned int)n); 1041 if (copy_from_user(bh->b_data + atomic_read(&bh->b_count), buf, 1042 count)) 1043 ret = 1; 1044 n -= count; 1045 atomic_add(count, &bh->b_count); 1046 buf += count; 1047 if (atomic_read(&bh->b_count) == bh->b_size) { 1048 bh = bh->b_reqnext; 1049 if (bh) 1050 atomic_set(&bh->b_count, 0); 1051 } 1052 } 1053 tape->bh = bh; 1054 return ret; 1055} 1056 1057static int idetape_copy_stage_to_user(idetape_tape_t *tape, char __user *buf, 1058 int n) 1059{ 1060 struct idetape_bh *bh = tape->bh; 1061 int count; 1062 int ret = 0; 1063 1064 while (n) { 1065 if (bh == NULL) { 1066 printk(KERN_ERR "ide-tape: bh == NULL in %s\n", 1067 __func__); 1068 return 1; 1069 } 1070 count = min(tape->b_count, n); 1071 if (copy_to_user(buf, tape->b_data, count)) 1072 ret = 1; 1073 n -= count; 1074 tape->b_data += count; 1075 tape->b_count -= count; 1076 buf += count; 1077 if (!tape->b_count) { 1078 bh = bh->b_reqnext; 1079 tape->bh = bh; 1080 if (bh) { 1081 tape->b_data = bh->b_data; 1082 tape->b_count = atomic_read(&bh->b_count); 1083 } 1084 } 1085 } 1086 return ret; 1087} 1088 1089static void idetape_init_merge_buffer(idetape_tape_t *tape) 1090{ 1091 struct idetape_bh *bh = tape->merge_bh; 1092 tape->bh = tape->merge_bh; 1093 1094 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) 1095 atomic_set(&bh->b_count, 0); 1096 else { 1097 tape->b_data = bh->b_data; 1098 tape->b_count = atomic_read(&bh->b_count); 1099 } 1100} 1101 1102/* 1103 * Write a filemark if write_filemark=1. Flush the device buffers without 1104 * writing a filemark otherwise. 1105 */ 1106static void idetape_create_write_filemark_cmd(ide_drive_t *drive, 1107 struct ide_atapi_pc *pc, int write_filemark) 1108{ 1109 ide_init_pc(pc); 1110 pc->c[0] = WRITE_FILEMARKS; 1111 pc->c[4] = write_filemark; 1112 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1113} 1114 1115static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout) 1116{ 1117 idetape_tape_t *tape = drive->driver_data; 1118 struct gendisk *disk = tape->disk; 1119 int load_attempted = 0; 1120 1121 /* Wait for the tape to become ready */ 1122 set_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags); 1123 timeout += jiffies; 1124 while (time_before(jiffies, timeout)) { 1125 if (ide_do_test_unit_ready(drive, disk) == 0) 1126 return 0; 1127 if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2) 1128 || (tape->asc == 0x3A)) { 1129 /* no media */ 1130 if (load_attempted) 1131 return -ENOMEDIUM; 1132 ide_do_start_stop(drive, disk, IDETAPE_LU_LOAD_MASK); 1133 load_attempted = 1; 1134 /* not about to be ready */ 1135 } else if (!(tape->sense_key == 2 && tape->asc == 4 && 1136 (tape->ascq == 1 || tape->ascq == 8))) 1137 return -EIO; 1138 msleep(100); 1139 } 1140 return -EIO; 1141} 1142 1143static int idetape_flush_tape_buffers(ide_drive_t *drive) 1144{ 1145 struct ide_tape_obj *tape = drive->driver_data; 1146 struct ide_atapi_pc pc; 1147 int rc; 1148 1149 idetape_create_write_filemark_cmd(drive, &pc, 0); 1150 rc = ide_queue_pc_tail(drive, tape->disk, &pc); 1151 if (rc) 1152 return rc; 1153 idetape_wait_ready(drive, 60 * 5 * HZ); 1154 return 0; 1155} 1156 1157static void idetape_create_read_position_cmd(struct ide_atapi_pc *pc) 1158{ 1159 ide_init_pc(pc); 1160 pc->c[0] = READ_POSITION; 1161 pc->req_xfer = 20; 1162} 1163 1164static int idetape_read_position(ide_drive_t *drive) 1165{ 1166 idetape_tape_t *tape = drive->driver_data; 1167 struct ide_atapi_pc pc; 1168 int position; 1169 1170 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1171 1172 idetape_create_read_position_cmd(&pc); 1173 if (ide_queue_pc_tail(drive, tape->disk, &pc)) 1174 return -1; 1175 position = tape->first_frame; 1176 return position; 1177} 1178 1179static void idetape_create_locate_cmd(ide_drive_t *drive, 1180 struct ide_atapi_pc *pc, 1181 unsigned int block, u8 partition, int skip) 1182{ 1183 ide_init_pc(pc); 1184 pc->c[0] = POSITION_TO_ELEMENT; 1185 pc->c[1] = 2; 1186 put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[3]); 1187 pc->c[8] = partition; 1188 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1189} 1190 1191static void __ide_tape_discard_merge_buffer(ide_drive_t *drive) 1192{ 1193 idetape_tape_t *tape = drive->driver_data; 1194 1195 if (tape->chrdev_dir != IDETAPE_DIR_READ) 1196 return; 1197 1198 clear_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags); 1199 tape->merge_bh_size = 0; 1200 if (tape->merge_bh != NULL) { 1201 ide_tape_kfree_buffer(tape); 1202 tape->merge_bh = NULL; 1203 } 1204 1205 tape->chrdev_dir = IDETAPE_DIR_NONE; 1206} 1207 1208/* 1209 * Position the tape to the requested block using the LOCATE packet command. 1210 * A READ POSITION command is then issued to check where we are positioned. Like 1211 * all higher level operations, we queue the commands at the tail of the request 1212 * queue and wait for their completion. 1213 */ 1214static int idetape_position_tape(ide_drive_t *drive, unsigned int block, 1215 u8 partition, int skip) 1216{ 1217 idetape_tape_t *tape = drive->driver_data; 1218 struct gendisk *disk = tape->disk; 1219 int retval; 1220 struct ide_atapi_pc pc; 1221 1222 if (tape->chrdev_dir == IDETAPE_DIR_READ) 1223 __ide_tape_discard_merge_buffer(drive); 1224 idetape_wait_ready(drive, 60 * 5 * HZ); 1225 idetape_create_locate_cmd(drive, &pc, block, partition, skip); 1226 retval = ide_queue_pc_tail(drive, disk, &pc); 1227 if (retval) 1228 return (retval); 1229 1230 idetape_create_read_position_cmd(&pc); 1231 return ide_queue_pc_tail(drive, disk, &pc); 1232} 1233 1234static void ide_tape_discard_merge_buffer(ide_drive_t *drive, 1235 int restore_position) 1236{ 1237 idetape_tape_t *tape = drive->driver_data; 1238 int seek, position; 1239 1240 __ide_tape_discard_merge_buffer(drive); 1241 if (restore_position) { 1242 position = idetape_read_position(drive); 1243 seek = position > 0 ? position : 0; 1244 if (idetape_position_tape(drive, seek, 0, 0)) { 1245 printk(KERN_INFO "ide-tape: %s: position_tape failed in" 1246 " %s\n", tape->name, __func__); 1247 return; 1248 } 1249 } 1250} 1251 1252/* 1253 * Generate a read/write request for the block device interface and wait for it 1254 * to be serviced. 1255 */ 1256static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int blocks, 1257 struct idetape_bh *bh) 1258{ 1259 idetape_tape_t *tape = drive->driver_data; 1260 struct request *rq; 1261 int ret, errors; 1262 1263 debug_log(DBG_SENSE, "%s: cmd=%d\n", __func__, cmd); 1264 1265 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 1266 rq->cmd_type = REQ_TYPE_SPECIAL; 1267 rq->cmd[13] = cmd; 1268 rq->rq_disk = tape->disk; 1269 rq->special = (void *)bh; 1270 rq->sector = tape->first_frame; 1271 rq->nr_sectors = blocks; 1272 rq->current_nr_sectors = blocks; 1273 blk_execute_rq(drive->queue, tape->disk, rq, 0); 1274 1275 errors = rq->errors; 1276 ret = tape->blk_size * (blocks - rq->current_nr_sectors); 1277 blk_put_request(rq); 1278 1279 if ((cmd & (REQ_IDETAPE_READ | REQ_IDETAPE_WRITE)) == 0) 1280 return 0; 1281 1282 if (tape->merge_bh) 1283 idetape_init_merge_buffer(tape); 1284 if (errors == IDETAPE_ERROR_GENERAL) 1285 return -EIO; 1286 return ret; 1287} 1288 1289static void idetape_create_inquiry_cmd(struct ide_atapi_pc *pc) 1290{ 1291 ide_init_pc(pc); 1292 pc->c[0] = INQUIRY; 1293 pc->c[4] = 254; 1294 pc->req_xfer = 254; 1295} 1296 1297static void idetape_create_rewind_cmd(ide_drive_t *drive, 1298 struct ide_atapi_pc *pc) 1299{ 1300 ide_init_pc(pc); 1301 pc->c[0] = REZERO_UNIT; 1302 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1303} 1304 1305static void idetape_create_erase_cmd(struct ide_atapi_pc *pc) 1306{ 1307 ide_init_pc(pc); 1308 pc->c[0] = ERASE; 1309 pc->c[1] = 1; 1310 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1311} 1312 1313static void idetape_create_space_cmd(struct ide_atapi_pc *pc, int count, u8 cmd) 1314{ 1315 ide_init_pc(pc); 1316 pc->c[0] = SPACE; 1317 put_unaligned(cpu_to_be32(count), (unsigned int *) &pc->c[1]); 1318 pc->c[1] = cmd; 1319 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1320} 1321 1322/* Queue up a character device originated write request. */ 1323static int idetape_add_chrdev_write_request(ide_drive_t *drive, int blocks) 1324{ 1325 idetape_tape_t *tape = drive->driver_data; 1326 1327 debug_log(DBG_CHRDEV, "Enter %s\n", __func__); 1328 1329 return idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, 1330 blocks, tape->merge_bh); 1331} 1332 1333static void ide_tape_flush_merge_buffer(ide_drive_t *drive) 1334{ 1335 idetape_tape_t *tape = drive->driver_data; 1336 int blocks, min; 1337 struct idetape_bh *bh; 1338 1339 if (tape->chrdev_dir != IDETAPE_DIR_WRITE) { 1340 printk(KERN_ERR "ide-tape: bug: Trying to empty merge buffer" 1341 " but we are not writing.\n"); 1342 return; 1343 } 1344 if (tape->merge_bh_size > tape->buffer_size) { 1345 printk(KERN_ERR "ide-tape: bug: merge_buffer too big\n"); 1346 tape->merge_bh_size = tape->buffer_size; 1347 } 1348 if (tape->merge_bh_size) { 1349 blocks = tape->merge_bh_size / tape->blk_size; 1350 if (tape->merge_bh_size % tape->blk_size) { 1351 unsigned int i; 1352 1353 blocks++; 1354 i = tape->blk_size - tape->merge_bh_size % 1355 tape->blk_size; 1356 bh = tape->bh->b_reqnext; 1357 while (bh) { 1358 atomic_set(&bh->b_count, 0); 1359 bh = bh->b_reqnext; 1360 } 1361 bh = tape->bh; 1362 while (i) { 1363 if (bh == NULL) { 1364 printk(KERN_INFO "ide-tape: bug," 1365 " bh NULL\n"); 1366 break; 1367 } 1368 min = min(i, (unsigned int)(bh->b_size - 1369 atomic_read(&bh->b_count))); 1370 memset(bh->b_data + atomic_read(&bh->b_count), 1371 0, min); 1372 atomic_add(min, &bh->b_count); 1373 i -= min; 1374 bh = bh->b_reqnext; 1375 } 1376 } 1377 (void) idetape_add_chrdev_write_request(drive, blocks); 1378 tape->merge_bh_size = 0; 1379 } 1380 if (tape->merge_bh != NULL) { 1381 ide_tape_kfree_buffer(tape); 1382 tape->merge_bh = NULL; 1383 } 1384 tape->chrdev_dir = IDETAPE_DIR_NONE; 1385} 1386 1387static int idetape_init_read(ide_drive_t *drive) 1388{ 1389 idetape_tape_t *tape = drive->driver_data; 1390 int bytes_read; 1391 1392 /* Initialize read operation */ 1393 if (tape->chrdev_dir != IDETAPE_DIR_READ) { 1394 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) { 1395 ide_tape_flush_merge_buffer(drive); 1396 idetape_flush_tape_buffers(drive); 1397 } 1398 if (tape->merge_bh || tape->merge_bh_size) { 1399 printk(KERN_ERR "ide-tape: merge_bh_size should be" 1400 " 0 now\n"); 1401 tape->merge_bh_size = 0; 1402 } 1403 tape->merge_bh = ide_tape_kmalloc_buffer(tape, 0, 0); 1404 if (!tape->merge_bh) 1405 return -ENOMEM; 1406 tape->chrdev_dir = IDETAPE_DIR_READ; 1407 1408 /* 1409 * Issue a read 0 command to ensure that DSC handshake is 1410 * switched from completion mode to buffer available mode. 1411 * No point in issuing this if DSC overlap isn't supported, some 1412 * drives (Seagate STT3401A) will return an error. 1413 */ 1414 if (drive->dsc_overlap) { 1415 bytes_read = idetape_queue_rw_tail(drive, 1416 REQ_IDETAPE_READ, 0, 1417 tape->merge_bh); 1418 if (bytes_read < 0) { 1419 ide_tape_kfree_buffer(tape); 1420 tape->merge_bh = NULL; 1421 tape->chrdev_dir = IDETAPE_DIR_NONE; 1422 return bytes_read; 1423 } 1424 } 1425 } 1426 1427 return 0; 1428} 1429 1430/* called from idetape_chrdev_read() to service a chrdev read request. */ 1431static int idetape_add_chrdev_read_request(ide_drive_t *drive, int blocks) 1432{ 1433 idetape_tape_t *tape = drive->driver_data; 1434 1435 debug_log(DBG_PROCS, "Enter %s, %d blocks\n", __func__, blocks); 1436 1437 /* If we are at a filemark, return a read length of 0 */ 1438 if (test_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags)) 1439 return 0; 1440 1441 idetape_init_read(drive); 1442 1443 return idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, blocks, 1444 tape->merge_bh); 1445} 1446 1447static void idetape_pad_zeros(ide_drive_t *drive, int bcount) 1448{ 1449 idetape_tape_t *tape = drive->driver_data; 1450 struct idetape_bh *bh; 1451 int blocks; 1452 1453 while (bcount) { 1454 unsigned int count; 1455 1456 bh = tape->merge_bh; 1457 count = min(tape->buffer_size, bcount); 1458 bcount -= count; 1459 blocks = count / tape->blk_size; 1460 while (count) { 1461 atomic_set(&bh->b_count, 1462 min(count, (unsigned int)bh->b_size)); 1463 memset(bh->b_data, 0, atomic_read(&bh->b_count)); 1464 count -= atomic_read(&bh->b_count); 1465 bh = bh->b_reqnext; 1466 } 1467 idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, blocks, 1468 tape->merge_bh); 1469 } 1470} 1471 1472/* 1473 * Rewinds the tape to the Beginning Of the current Partition (BOP). We 1474 * currently support only one partition. 1475 */ 1476static int idetape_rewind_tape(ide_drive_t *drive) 1477{ 1478 struct ide_tape_obj *tape = drive->driver_data; 1479 struct gendisk *disk = tape->disk; 1480 int retval; 1481 struct ide_atapi_pc pc; 1482 1483 debug_log(DBG_SENSE, "Enter %s\n", __func__); 1484 1485 idetape_create_rewind_cmd(drive, &pc); 1486 retval = ide_queue_pc_tail(drive, disk, &pc); 1487 if (retval) 1488 return retval; 1489 1490 idetape_create_read_position_cmd(&pc); 1491 retval = ide_queue_pc_tail(drive, disk, &pc); 1492 if (retval) 1493 return retval; 1494 return 0; 1495} 1496 1497/* mtio.h compatible commands should be issued to the chrdev interface. */ 1498static int idetape_blkdev_ioctl(ide_drive_t *drive, unsigned int cmd, 1499 unsigned long arg) 1500{ 1501 idetape_tape_t *tape = drive->driver_data; 1502 void __user *argp = (void __user *)arg; 1503 1504 struct idetape_config { 1505 int dsc_rw_frequency; 1506 int dsc_media_access_frequency; 1507 int nr_stages; 1508 } config; 1509 1510 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1511 1512 switch (cmd) { 1513 case 0x0340: 1514 if (copy_from_user(&config, argp, sizeof(config))) 1515 return -EFAULT; 1516 tape->best_dsc_rw_freq = config.dsc_rw_frequency; 1517 break; 1518 case 0x0350: 1519 config.dsc_rw_frequency = (int) tape->best_dsc_rw_freq; 1520 config.nr_stages = 1; 1521 if (copy_to_user(argp, &config, sizeof(config))) 1522 return -EFAULT; 1523 break; 1524 default: 1525 return -EIO; 1526 } 1527 return 0; 1528} 1529 1530static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op, 1531 int mt_count) 1532{ 1533 idetape_tape_t *tape = drive->driver_data; 1534 struct gendisk *disk = tape->disk; 1535 struct ide_atapi_pc pc; 1536 int retval, count = 0; 1537 int sprev = !!(tape->caps[4] & 0x20); 1538 1539 if (mt_count == 0) 1540 return 0; 1541 if (MTBSF == mt_op || MTBSFM == mt_op) { 1542 if (!sprev) 1543 return -EIO; 1544 mt_count = -mt_count; 1545 } 1546 1547 if (tape->chrdev_dir == IDETAPE_DIR_READ) { 1548 tape->merge_bh_size = 0; 1549 if (test_and_clear_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags)) 1550 ++count; 1551 ide_tape_discard_merge_buffer(drive, 0); 1552 } 1553 1554 switch (mt_op) { 1555 case MTFSF: 1556 case MTBSF: 1557 idetape_create_space_cmd(&pc, mt_count - count, 1558 IDETAPE_SPACE_OVER_FILEMARK); 1559 return ide_queue_pc_tail(drive, disk, &pc); 1560 case MTFSFM: 1561 case MTBSFM: 1562 if (!sprev) 1563 return -EIO; 1564 retval = idetape_space_over_filemarks(drive, MTFSF, 1565 mt_count - count); 1566 if (retval) 1567 return retval; 1568 count = (MTBSFM == mt_op ? 1 : -1); 1569 return idetape_space_over_filemarks(drive, MTFSF, count); 1570 default: 1571 printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n", 1572 mt_op); 1573 return -EIO; 1574 } 1575} 1576 1577/* 1578 * Our character device read / write functions. 1579 * 1580 * The tape is optimized to maximize throughput when it is transferring an 1581 * integral number of the "continuous transfer limit", which is a parameter of 1582 * the specific tape (26kB on my particular tape, 32kB for Onstream). 1583 * 1584 * As of version 1.3 of the driver, the character device provides an abstract 1585 * continuous view of the media - any mix of block sizes (even 1 byte) on the 1586 * same backup/restore procedure is supported. The driver will internally 1587 * convert the requests to the recommended transfer unit, so that an unmatch 1588 * between the user's block size to the recommended size will only result in a 1589 * (slightly) increased driver overhead, but will no longer hit performance. 1590 * This is not applicable to Onstream. 1591 */ 1592static ssize_t idetape_chrdev_read(struct file *file, char __user *buf, 1593 size_t count, loff_t *ppos) 1594{ 1595 struct ide_tape_obj *tape = ide_tape_f(file); 1596 ide_drive_t *drive = tape->drive; 1597 ssize_t bytes_read, temp, actually_read = 0, rc; 1598 ssize_t ret = 0; 1599 u16 ctl = *(u16 *)&tape->caps[12]; 1600 1601 debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count); 1602 1603 if (tape->chrdev_dir != IDETAPE_DIR_READ) { 1604 if (test_bit(IDE_AFLAG_DETECT_BS, &drive->atapi_flags)) 1605 if (count > tape->blk_size && 1606 (count % tape->blk_size) == 0) 1607 tape->user_bs_factor = count / tape->blk_size; 1608 } 1609 rc = idetape_init_read(drive); 1610 if (rc < 0) 1611 return rc; 1612 if (count == 0) 1613 return (0); 1614 if (tape->merge_bh_size) { 1615 actually_read = min((unsigned int)(tape->merge_bh_size), 1616 (unsigned int)count); 1617 if (idetape_copy_stage_to_user(tape, buf, actually_read)) 1618 ret = -EFAULT; 1619 buf += actually_read; 1620 tape->merge_bh_size -= actually_read; 1621 count -= actually_read; 1622 } 1623 while (count >= tape->buffer_size) { 1624 bytes_read = idetape_add_chrdev_read_request(drive, ctl); 1625 if (bytes_read <= 0) 1626 goto finish; 1627 if (idetape_copy_stage_to_user(tape, buf, bytes_read)) 1628 ret = -EFAULT; 1629 buf += bytes_read; 1630 count -= bytes_read; 1631 actually_read += bytes_read; 1632 } 1633 if (count) { 1634 bytes_read = idetape_add_chrdev_read_request(drive, ctl); 1635 if (bytes_read <= 0) 1636 goto finish; 1637 temp = min((unsigned long)count, (unsigned long)bytes_read); 1638 if (idetape_copy_stage_to_user(tape, buf, temp)) 1639 ret = -EFAULT; 1640 actually_read += temp; 1641 tape->merge_bh_size = bytes_read-temp; 1642 } 1643finish: 1644 if (!actually_read && test_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags)) { 1645 debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name); 1646 1647 idetape_space_over_filemarks(drive, MTFSF, 1); 1648 return 0; 1649 } 1650 1651 return ret ? ret : actually_read; 1652} 1653 1654static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf, 1655 size_t count, loff_t *ppos) 1656{ 1657 struct ide_tape_obj *tape = ide_tape_f(file); 1658 ide_drive_t *drive = tape->drive; 1659 ssize_t actually_written = 0; 1660 ssize_t ret = 0; 1661 u16 ctl = *(u16 *)&tape->caps[12]; 1662 1663 /* The drive is write protected. */ 1664 if (tape->write_prot) 1665 return -EACCES; 1666 1667 debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count); 1668 1669 /* Initialize write operation */ 1670 if (tape->chrdev_dir != IDETAPE_DIR_WRITE) { 1671 if (tape->chrdev_dir == IDETAPE_DIR_READ) 1672 ide_tape_discard_merge_buffer(drive, 1); 1673 if (tape->merge_bh || tape->merge_bh_size) { 1674 printk(KERN_ERR "ide-tape: merge_bh_size " 1675 "should be 0 now\n"); 1676 tape->merge_bh_size = 0; 1677 } 1678 tape->merge_bh = ide_tape_kmalloc_buffer(tape, 0, 0); 1679 if (!tape->merge_bh) 1680 return -ENOMEM; 1681 tape->chrdev_dir = IDETAPE_DIR_WRITE; 1682 idetape_init_merge_buffer(tape); 1683 1684 /* 1685 * Issue a write 0 command to ensure that DSC handshake is 1686 * switched from completion mode to buffer available mode. No 1687 * point in issuing this if DSC overlap isn't supported, some 1688 * drives (Seagate STT3401A) will return an error. 1689 */ 1690 if (drive->dsc_overlap) { 1691 ssize_t retval = idetape_queue_rw_tail(drive, 1692 REQ_IDETAPE_WRITE, 0, 1693 tape->merge_bh); 1694 if (retval < 0) { 1695 ide_tape_kfree_buffer(tape); 1696 tape->merge_bh = NULL; 1697 tape->chrdev_dir = IDETAPE_DIR_NONE; 1698 return retval; 1699 } 1700 } 1701 } 1702 if (count == 0) 1703 return (0); 1704 if (tape->merge_bh_size) { 1705 if (tape->merge_bh_size >= tape->buffer_size) { 1706 printk(KERN_ERR "ide-tape: bug: merge buf too big\n"); 1707 tape->merge_bh_size = 0; 1708 } 1709 actually_written = min((unsigned int) 1710 (tape->buffer_size - tape->merge_bh_size), 1711 (unsigned int)count); 1712 if (idetape_copy_stage_from_user(tape, buf, actually_written)) 1713 ret = -EFAULT; 1714 buf += actually_written; 1715 tape->merge_bh_size += actually_written; 1716 count -= actually_written; 1717 1718 if (tape->merge_bh_size == tape->buffer_size) { 1719 ssize_t retval; 1720 tape->merge_bh_size = 0; 1721 retval = idetape_add_chrdev_write_request(drive, ctl); 1722 if (retval <= 0) 1723 return (retval); 1724 } 1725 } 1726 while (count >= tape->buffer_size) { 1727 ssize_t retval; 1728 if (idetape_copy_stage_from_user(tape, buf, tape->buffer_size)) 1729 ret = -EFAULT; 1730 buf += tape->buffer_size; 1731 count -= tape->buffer_size; 1732 retval = idetape_add_chrdev_write_request(drive, ctl); 1733 actually_written += tape->buffer_size; 1734 if (retval <= 0) 1735 return (retval); 1736 } 1737 if (count) { 1738 actually_written += count; 1739 if (idetape_copy_stage_from_user(tape, buf, count)) 1740 ret = -EFAULT; 1741 tape->merge_bh_size += count; 1742 } 1743 return ret ? ret : actually_written; 1744} 1745 1746static int idetape_write_filemark(ide_drive_t *drive) 1747{ 1748 struct ide_tape_obj *tape = drive->driver_data; 1749 struct ide_atapi_pc pc; 1750 1751 /* Write a filemark */ 1752 idetape_create_write_filemark_cmd(drive, &pc, 1); 1753 if (ide_queue_pc_tail(drive, tape->disk, &pc)) { 1754 printk(KERN_ERR "ide-tape: Couldn't write a filemark\n"); 1755 return -EIO; 1756 } 1757 return 0; 1758} 1759 1760/* 1761 * Called from idetape_chrdev_ioctl when the general mtio MTIOCTOP ioctl is 1762 * requested. 1763 * 1764 * Note: MTBSF and MTBSFM are not supported when the tape doesn't support 1765 * spacing over filemarks in the reverse direction. In this case, MTFSFM is also 1766 * usually not supported. 1767 * 1768 * The following commands are currently not supported: 1769 * 1770 * MTFSS, MTBSS, MTWSM, MTSETDENSITY, MTSETDRVBUFFER, MT_ST_BOOLEANS, 1771 * MT_ST_WRITE_THRESHOLD. 1772 */ 1773static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count) 1774{ 1775 idetape_tape_t *tape = drive->driver_data; 1776 struct gendisk *disk = tape->disk; 1777 struct ide_atapi_pc pc; 1778 int i, retval; 1779 1780 debug_log(DBG_ERR, "Handling MTIOCTOP ioctl: mt_op=%d, mt_count=%d\n", 1781 mt_op, mt_count); 1782 1783 switch (mt_op) { 1784 case MTFSF: 1785 case MTFSFM: 1786 case MTBSF: 1787 case MTBSFM: 1788 if (!mt_count) 1789 return 0; 1790 return idetape_space_over_filemarks(drive, mt_op, mt_count); 1791 default: 1792 break; 1793 } 1794 1795 switch (mt_op) { 1796 case MTWEOF: 1797 if (tape->write_prot) 1798 return -EACCES; 1799 ide_tape_discard_merge_buffer(drive, 1); 1800 for (i = 0; i < mt_count; i++) { 1801 retval = idetape_write_filemark(drive); 1802 if (retval) 1803 return retval; 1804 } 1805 return 0; 1806 case MTREW: 1807 ide_tape_discard_merge_buffer(drive, 0); 1808 if (idetape_rewind_tape(drive)) 1809 return -EIO; 1810 return 0; 1811 case MTLOAD: 1812 ide_tape_discard_merge_buffer(drive, 0); 1813 return ide_do_start_stop(drive, disk, IDETAPE_LU_LOAD_MASK); 1814 case MTUNLOAD: 1815 case MTOFFL: 1816 /* 1817 * If door is locked, attempt to unlock before 1818 * attempting to eject. 1819 */ 1820 if (tape->door_locked) { 1821 if (!ide_set_media_lock(drive, disk, 0)) 1822 tape->door_locked = DOOR_UNLOCKED; 1823 } 1824 ide_tape_discard_merge_buffer(drive, 0); 1825 retval = ide_do_start_stop(drive, disk, !IDETAPE_LU_LOAD_MASK); 1826 if (!retval) 1827 clear_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags); 1828 return retval; 1829 case MTNOP: 1830 ide_tape_discard_merge_buffer(drive, 0); 1831 return idetape_flush_tape_buffers(drive); 1832 case MTRETEN: 1833 ide_tape_discard_merge_buffer(drive, 0); 1834 return ide_do_start_stop(drive, disk, 1835 IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK); 1836 case MTEOM: 1837 idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD); 1838 return ide_queue_pc_tail(drive, disk, &pc); 1839 case MTERASE: 1840 (void)idetape_rewind_tape(drive); 1841 idetape_create_erase_cmd(&pc); 1842 return ide_queue_pc_tail(drive, disk, &pc); 1843 case MTSETBLK: 1844 if (mt_count) { 1845 if (mt_count < tape->blk_size || 1846 mt_count % tape->blk_size) 1847 return -EIO; 1848 tape->user_bs_factor = mt_count / tape->blk_size; 1849 clear_bit(IDE_AFLAG_DETECT_BS, &drive->atapi_flags); 1850 } else 1851 set_bit(IDE_AFLAG_DETECT_BS, &drive->atapi_flags); 1852 return 0; 1853 case MTSEEK: 1854 ide_tape_discard_merge_buffer(drive, 0); 1855 return idetape_position_tape(drive, 1856 mt_count * tape->user_bs_factor, tape->partition, 0); 1857 case MTSETPART: 1858 ide_tape_discard_merge_buffer(drive, 0); 1859 return idetape_position_tape(drive, 0, mt_count, 0); 1860 case MTFSR: 1861 case MTBSR: 1862 case MTLOCK: 1863 retval = ide_set_media_lock(drive, disk, 1); 1864 if (retval) 1865 return retval; 1866 tape->door_locked = DOOR_EXPLICITLY_LOCKED; 1867 return 0; 1868 case MTUNLOCK: 1869 retval = ide_set_media_lock(drive, disk, 0); 1870 if (retval) 1871 return retval; 1872 tape->door_locked = DOOR_UNLOCKED; 1873 return 0; 1874 default: 1875 printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n", 1876 mt_op); 1877 return -EIO; 1878 } 1879} 1880 1881/* 1882 * Our character device ioctls. General mtio.h magnetic io commands are 1883 * supported here, and not in the corresponding block interface. Our own 1884 * ide-tape ioctls are supported on both interfaces. 1885 */ 1886static int idetape_chrdev_ioctl(struct inode *inode, struct file *file, 1887 unsigned int cmd, unsigned long arg) 1888{ 1889 struct ide_tape_obj *tape = ide_tape_f(file); 1890 ide_drive_t *drive = tape->drive; 1891 struct mtop mtop; 1892 struct mtget mtget; 1893 struct mtpos mtpos; 1894 int block_offset = 0, position = tape->first_frame; 1895 void __user *argp = (void __user *)arg; 1896 1897 debug_log(DBG_CHRDEV, "Enter %s, cmd=%u\n", __func__, cmd); 1898 1899 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) { 1900 ide_tape_flush_merge_buffer(drive); 1901 idetape_flush_tape_buffers(drive); 1902 } 1903 if (cmd == MTIOCGET || cmd == MTIOCPOS) { 1904 block_offset = tape->merge_bh_size / 1905 (tape->blk_size * tape->user_bs_factor); 1906 position = idetape_read_position(drive); 1907 if (position < 0) 1908 return -EIO; 1909 } 1910 switch (cmd) { 1911 case MTIOCTOP: 1912 if (copy_from_user(&mtop, argp, sizeof(struct mtop))) 1913 return -EFAULT; 1914 return idetape_mtioctop(drive, mtop.mt_op, mtop.mt_count); 1915 case MTIOCGET: 1916 memset(&mtget, 0, sizeof(struct mtget)); 1917 mtget.mt_type = MT_ISSCSI2; 1918 mtget.mt_blkno = position / tape->user_bs_factor - block_offset; 1919 mtget.mt_dsreg = 1920 ((tape->blk_size * tape->user_bs_factor) 1921 << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK; 1922 1923 if (tape->drv_write_prot) 1924 mtget.mt_gstat |= GMT_WR_PROT(0xffffffff); 1925 1926 if (copy_to_user(argp, &mtget, sizeof(struct mtget))) 1927 return -EFAULT; 1928 return 0; 1929 case MTIOCPOS: 1930 mtpos.mt_blkno = position / tape->user_bs_factor - block_offset; 1931 if (copy_to_user(argp, &mtpos, sizeof(struct mtpos))) 1932 return -EFAULT; 1933 return 0; 1934 default: 1935 if (tape->chrdev_dir == IDETAPE_DIR_READ) 1936 ide_tape_discard_merge_buffer(drive, 1); 1937 return idetape_blkdev_ioctl(drive, cmd, arg); 1938 } 1939} 1940 1941/* 1942 * Do a mode sense page 0 with block descriptor and if it succeeds set the tape 1943 * block size with the reported value. 1944 */ 1945static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive) 1946{ 1947 idetape_tape_t *tape = drive->driver_data; 1948 struct ide_atapi_pc pc; 1949 1950 idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR); 1951 if (ide_queue_pc_tail(drive, tape->disk, &pc)) { 1952 printk(KERN_ERR "ide-tape: Can't get block descriptor\n"); 1953 if (tape->blk_size == 0) { 1954 printk(KERN_WARNING "ide-tape: Cannot deal with zero " 1955 "block size, assuming 32k\n"); 1956 tape->blk_size = 32768; 1957 } 1958 return; 1959 } 1960 tape->blk_size = (pc.buf[4 + 5] << 16) + 1961 (pc.buf[4 + 6] << 8) + 1962 pc.buf[4 + 7]; 1963 tape->drv_write_prot = (pc.buf[2] & 0x80) >> 7; 1964} 1965 1966static int idetape_chrdev_open(struct inode *inode, struct file *filp) 1967{ 1968 unsigned int minor = iminor(inode), i = minor & ~0xc0; 1969 ide_drive_t *drive; 1970 idetape_tape_t *tape; 1971 int retval; 1972 1973 if (i >= MAX_HWIFS * MAX_DRIVES) 1974 return -ENXIO; 1975 1976 lock_kernel(); 1977 tape = ide_tape_chrdev_get(i); 1978 if (!tape) { 1979 unlock_kernel(); 1980 return -ENXIO; 1981 } 1982 1983 debug_log(DBG_CHRDEV, "Enter %s\n", __func__); 1984 1985 /* 1986 * We really want to do nonseekable_open(inode, filp); here, but some 1987 * versions of tar incorrectly call lseek on tapes and bail out if that 1988 * fails. So we disallow pread() and pwrite(), but permit lseeks. 1989 */ 1990 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE); 1991 1992 drive = tape->drive; 1993 1994 filp->private_data = tape; 1995 1996 if (test_and_set_bit(IDE_AFLAG_BUSY, &drive->atapi_flags)) { 1997 retval = -EBUSY; 1998 goto out_put_tape; 1999 } 2000 2001 retval = idetape_wait_ready(drive, 60 * HZ); 2002 if (retval) { 2003 clear_bit(IDE_AFLAG_BUSY, &drive->atapi_flags); 2004 printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name); 2005 goto out_put_tape; 2006 } 2007 2008 idetape_read_position(drive); 2009 if (!test_bit(IDE_AFLAG_ADDRESS_VALID, &drive->atapi_flags)) 2010 (void)idetape_rewind_tape(drive); 2011 2012 /* Read block size and write protect status from drive. */ 2013 ide_tape_get_bsize_from_bdesc(drive); 2014 2015 /* Set write protect flag if device is opened as read-only. */ 2016 if ((filp->f_flags & O_ACCMODE) == O_RDONLY) 2017 tape->write_prot = 1; 2018 else 2019 tape->write_prot = tape->drv_write_prot; 2020 2021 /* Make sure drive isn't write protected if user wants to write. */ 2022 if (tape->write_prot) { 2023 if ((filp->f_flags & O_ACCMODE) == O_WRONLY || 2024 (filp->f_flags & O_ACCMODE) == O_RDWR) { 2025 clear_bit(IDE_AFLAG_BUSY, &drive->atapi_flags); 2026 retval = -EROFS; 2027 goto out_put_tape; 2028 } 2029 } 2030 2031 /* Lock the tape drive door so user can't eject. */ 2032 if (tape->chrdev_dir == IDETAPE_DIR_NONE) { 2033 if (!ide_set_media_lock(drive, tape->disk, 1)) { 2034 if (tape->door_locked != DOOR_EXPLICITLY_LOCKED) 2035 tape->door_locked = DOOR_LOCKED; 2036 } 2037 } 2038 unlock_kernel(); 2039 return 0; 2040 2041out_put_tape: 2042 ide_tape_put(tape); 2043 unlock_kernel(); 2044 return retval; 2045} 2046 2047static void idetape_write_release(ide_drive_t *drive, unsigned int minor) 2048{ 2049 idetape_tape_t *tape = drive->driver_data; 2050 2051 ide_tape_flush_merge_buffer(drive); 2052 tape->merge_bh = ide_tape_kmalloc_buffer(tape, 1, 0); 2053 if (tape->merge_bh != NULL) { 2054 idetape_pad_zeros(drive, tape->blk_size * 2055 (tape->user_bs_factor - 1)); 2056 ide_tape_kfree_buffer(tape); 2057 tape->merge_bh = NULL; 2058 } 2059 idetape_write_filemark(drive); 2060 idetape_flush_tape_buffers(drive); 2061 idetape_flush_tape_buffers(drive); 2062} 2063 2064static int idetape_chrdev_release(struct inode *inode, struct file *filp) 2065{ 2066 struct ide_tape_obj *tape = ide_tape_f(filp); 2067 ide_drive_t *drive = tape->drive; 2068 unsigned int minor = iminor(inode); 2069 2070 lock_kernel(); 2071 tape = drive->driver_data; 2072 2073 debug_log(DBG_CHRDEV, "Enter %s\n", __func__); 2074 2075 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) 2076 idetape_write_release(drive, minor); 2077 if (tape->chrdev_dir == IDETAPE_DIR_READ) { 2078 if (minor < 128) 2079 ide_tape_discard_merge_buffer(drive, 1); 2080 } 2081 2082 if (minor < 128 && test_bit(IDE_AFLAG_MEDIUM_PRESENT, &drive->atapi_flags)) 2083 (void) idetape_rewind_tape(drive); 2084 if (tape->chrdev_dir == IDETAPE_DIR_NONE) { 2085 if (tape->door_locked == DOOR_LOCKED) { 2086 if (!ide_set_media_lock(drive, tape->disk, 0)) 2087 tape->door_locked = DOOR_UNLOCKED; 2088 } 2089 } 2090 clear_bit(IDE_AFLAG_BUSY, &drive->atapi_flags); 2091 ide_tape_put(tape); 2092 unlock_kernel(); 2093 return 0; 2094} 2095 2096static void idetape_get_inquiry_results(ide_drive_t *drive) 2097{ 2098 idetape_tape_t *tape = drive->driver_data; 2099 struct ide_atapi_pc pc; 2100 char fw_rev[4], vendor_id[8], product_id[16]; 2101 2102 idetape_create_inquiry_cmd(&pc); 2103 if (ide_queue_pc_tail(drive, tape->disk, &pc)) { 2104 printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n", 2105 tape->name); 2106 return; 2107 } 2108 memcpy(vendor_id, &pc.buf[8], 8); 2109 memcpy(product_id, &pc.buf[16], 16); 2110 memcpy(fw_rev, &pc.buf[32], 4); 2111 2112 ide_fixstring(vendor_id, 8, 0); 2113 ide_fixstring(product_id, 16, 0); 2114 ide_fixstring(fw_rev, 4, 0); 2115 2116 printk(KERN_INFO "ide-tape: %s <-> %s: %.8s %.16s rev %.4s\n", 2117 drive->name, tape->name, vendor_id, product_id, fw_rev); 2118} 2119 2120/* 2121 * Ask the tape about its various parameters. In particular, we will adjust our 2122 * data transfer buffer size to the recommended value as returned by the tape. 2123 */ 2124static void idetape_get_mode_sense_results(ide_drive_t *drive) 2125{ 2126 idetape_tape_t *tape = drive->driver_data; 2127 struct ide_atapi_pc pc; 2128 u8 *caps; 2129 u8 speed, max_speed; 2130 2131 idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE); 2132 if (ide_queue_pc_tail(drive, tape->disk, &pc)) { 2133 printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming" 2134 " some default values\n"); 2135 tape->blk_size = 512; 2136 put_unaligned(52, (u16 *)&tape->caps[12]); 2137 put_unaligned(540, (u16 *)&tape->caps[14]); 2138 put_unaligned(6*52, (u16 *)&tape->caps[16]); 2139 return; 2140 } 2141 caps = pc.buf + 4 + pc.buf[3]; 2142 2143 /* convert to host order and save for later use */ 2144 speed = be16_to_cpup((__be16 *)&caps[14]); 2145 max_speed = be16_to_cpup((__be16 *)&caps[8]); 2146 2147 *(u16 *)&caps[8] = max_speed; 2148 *(u16 *)&caps[12] = be16_to_cpup((__be16 *)&caps[12]); 2149 *(u16 *)&caps[14] = speed; 2150 *(u16 *)&caps[16] = be16_to_cpup((__be16 *)&caps[16]); 2151 2152 if (!speed) { 2153 printk(KERN_INFO "ide-tape: %s: invalid tape speed " 2154 "(assuming 650KB/sec)\n", drive->name); 2155 *(u16 *)&caps[14] = 650; 2156 } 2157 if (!max_speed) { 2158 printk(KERN_INFO "ide-tape: %s: invalid max_speed " 2159 "(assuming 650KB/sec)\n", drive->name); 2160 *(u16 *)&caps[8] = 650; 2161 } 2162 2163 memcpy(&tape->caps, caps, 20); 2164 2165 /* device lacks locking support according to capabilities page */ 2166 if ((caps[6] & 1) == 0) 2167 drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK; 2168 2169 if (caps[7] & 0x02) 2170 tape->blk_size = 512; 2171 else if (caps[7] & 0x04) 2172 tape->blk_size = 1024; 2173} 2174 2175#ifdef CONFIG_IDE_PROC_FS 2176#define ide_tape_devset_get(name, field) \ 2177static int get_##name(ide_drive_t *drive) \ 2178{ \ 2179 idetape_tape_t *tape = drive->driver_data; \ 2180 return tape->field; \ 2181} 2182 2183#define ide_tape_devset_set(name, field) \ 2184static int set_##name(ide_drive_t *drive, int arg) \ 2185{ \ 2186 idetape_tape_t *tape = drive->driver_data; \ 2187 tape->field = arg; \ 2188 return 0; \ 2189} 2190 2191#define ide_tape_devset_rw(_name, _min, _max, _field, _mulf, _divf) \ 2192ide_tape_devset_get(_name, _field) \ 2193ide_tape_devset_set(_name, _field) \ 2194__IDE_DEVSET(_name, S_RW, _min, _max, get_##_name, set_##_name, _mulf, _divf) 2195 2196#define ide_tape_devset_r(_name, _min, _max, _field, _mulf, _divf) \ 2197ide_tape_devset_get(_name, _field) \ 2198__IDE_DEVSET(_name, S_READ, _min, _max, get_##_name, NULL, _mulf, _divf) 2199 2200static int mulf_tdsc(ide_drive_t *drive) { return 1000; } 2201static int divf_tdsc(ide_drive_t *drive) { return HZ; } 2202static int divf_buffer(ide_drive_t *drive) { return 2; } 2203static int divf_buffer_size(ide_drive_t *drive) { return 1024; } 2204 2205ide_devset_rw(dsc_overlap, 0, 1, dsc_overlap); 2206 2207ide_tape_devset_rw(debug_mask, 0, 0xffff, debug_mask, NULL, NULL); 2208ide_tape_devset_rw(tdsc, IDETAPE_DSC_RW_MIN, IDETAPE_DSC_RW_MAX, 2209 best_dsc_rw_freq, mulf_tdsc, divf_tdsc); 2210 2211ide_tape_devset_r(avg_speed, 0, 0xffff, avg_speed, NULL, NULL); 2212ide_tape_devset_r(speed, 0, 0xffff, caps[14], NULL, NULL); 2213ide_tape_devset_r(buffer, 0, 0xffff, caps[16], NULL, divf_buffer); 2214ide_tape_devset_r(buffer_size, 0, 0xffff, buffer_size, NULL, divf_buffer_size); 2215 2216static const struct ide_devset *idetape_settings[] = { 2217 &ide_devset_avg_speed, 2218 &ide_devset_buffer, 2219 &ide_devset_buffer_size, 2220 &ide_devset_debug_mask, 2221 &ide_devset_dsc_overlap, 2222 &ide_devset_speed, 2223 &ide_devset_tdsc, 2224 NULL 2225}; 2226#endif 2227 2228/* 2229 * The function below is called to: 2230 * 2231 * 1. Initialize our various state variables. 2232 * 2. Ask the tape for its capabilities. 2233 * 3. Allocate a buffer which will be used for data transfer. The buffer size 2234 * is chosen based on the recommendation which we received in step 2. 2235 * 2236 * Note that at this point ide.c already assigned us an irq, so that we can 2237 * queue requests here and wait for their completion. 2238 */ 2239static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor) 2240{ 2241 unsigned long t; 2242 int speed; 2243 int buffer_size; 2244 u8 gcw[2]; 2245 u16 *ctl = (u16 *)&tape->caps[12]; 2246 2247 drive->pc_callback = ide_tape_callback; 2248 2249 spin_lock_init(&tape->lock); 2250 drive->dsc_overlap = 1; 2251 if (drive->hwif->host_flags & IDE_HFLAG_NO_DSC) { 2252 printk(KERN_INFO "ide-tape: %s: disabling DSC overlap\n", 2253 tape->name); 2254 drive->dsc_overlap = 0; 2255 } 2256 /* Seagate Travan drives do not support DSC overlap. */ 2257 if (strstr((char *)&drive->id[ATA_ID_PROD], "Seagate STT3401")) 2258 drive->dsc_overlap = 0; 2259 tape->minor = minor; 2260 tape->name[0] = 'h'; 2261 tape->name[1] = 't'; 2262 tape->name[2] = '0' + minor; 2263 tape->chrdev_dir = IDETAPE_DIR_NONE; 2264 2265 *((u16 *)&gcw) = drive->id[ATA_ID_CONFIG]; 2266 2267 /* Command packet DRQ type */ 2268 if (((gcw[0] & 0x60) >> 5) == 1) 2269 set_bit(IDE_AFLAG_DRQ_INTERRUPT, &drive->atapi_flags); 2270 2271 idetape_get_inquiry_results(drive); 2272 idetape_get_mode_sense_results(drive); 2273 ide_tape_get_bsize_from_bdesc(drive); 2274 tape->user_bs_factor = 1; 2275 tape->buffer_size = *ctl * tape->blk_size; 2276 while (tape->buffer_size > 0xffff) { 2277 printk(KERN_NOTICE "ide-tape: decreasing stage size\n"); 2278 *ctl /= 2; 2279 tape->buffer_size = *ctl * tape->blk_size; 2280 } 2281 buffer_size = tape->buffer_size; 2282 tape->pages_per_buffer = buffer_size / PAGE_SIZE; 2283 if (buffer_size % PAGE_SIZE) { 2284 tape->pages_per_buffer++; 2285 tape->excess_bh_size = PAGE_SIZE - buffer_size % PAGE_SIZE; 2286 } 2287 2288 /* select the "best" DSC read/write polling freq */ 2289 speed = max(*(u16 *)&tape->caps[14], *(u16 *)&tape->caps[8]); 2290 2291 t = (IDETAPE_FIFO_THRESHOLD * tape->buffer_size * HZ) / (speed * 1000); 2292 2293 /* 2294 * Ensure that the number we got makes sense; limit it within 2295 * IDETAPE_DSC_RW_MIN and IDETAPE_DSC_RW_MAX. 2296 */ 2297 tape->best_dsc_rw_freq = clamp_t(unsigned long, t, IDETAPE_DSC_RW_MIN, 2298 IDETAPE_DSC_RW_MAX); 2299 printk(KERN_INFO "ide-tape: %s <-> %s: %dKBps, %d*%dkB buffer, " 2300 "%lums tDSC%s\n", 2301 drive->name, tape->name, *(u16 *)&tape->caps[14], 2302 (*(u16 *)&tape->caps[16] * 512) / tape->buffer_size, 2303 tape->buffer_size / 1024, 2304 tape->best_dsc_rw_freq * 1000 / HZ, 2305 drive->using_dma ? ", DMA":""); 2306 2307 ide_proc_register_driver(drive, tape->driver); 2308} 2309 2310static void ide_tape_remove(ide_drive_t *drive) 2311{ 2312 idetape_tape_t *tape = drive->driver_data; 2313 2314 ide_proc_unregister_driver(drive, tape->driver); 2315 2316 ide_unregister_region(tape->disk); 2317 2318 ide_tape_put(tape); 2319} 2320 2321static void ide_tape_release(struct kref *kref) 2322{ 2323 struct ide_tape_obj *tape = to_ide_tape(kref); 2324 ide_drive_t *drive = tape->drive; 2325 struct gendisk *g = tape->disk; 2326 2327 BUG_ON(tape->merge_bh_size); 2328 2329 drive->dsc_overlap = 0; 2330 drive->driver_data = NULL; 2331 device_destroy(idetape_sysfs_class, MKDEV(IDETAPE_MAJOR, tape->minor)); 2332 device_destroy(idetape_sysfs_class, 2333 MKDEV(IDETAPE_MAJOR, tape->minor + 128)); 2334 idetape_devs[tape->minor] = NULL; 2335 g->private_data = NULL; 2336 put_disk(g); 2337 kfree(tape); 2338} 2339 2340#ifdef CONFIG_IDE_PROC_FS 2341static int proc_idetape_read_name 2342 (char *page, char **start, off_t off, int count, int *eof, void *data) 2343{ 2344 ide_drive_t *drive = (ide_drive_t *) data; 2345 idetape_tape_t *tape = drive->driver_data; 2346 char *out = page; 2347 int len; 2348 2349 len = sprintf(out, "%s\n", tape->name); 2350 PROC_IDE_READ_RETURN(page, start, off, count, eof, len); 2351} 2352 2353static ide_proc_entry_t idetape_proc[] = { 2354 { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL }, 2355 { "name", S_IFREG|S_IRUGO, proc_idetape_read_name, NULL }, 2356 { NULL, 0, NULL, NULL } 2357}; 2358#endif 2359 2360static int ide_tape_probe(ide_drive_t *); 2361 2362static ide_driver_t idetape_driver = { 2363 .gen_driver = { 2364 .owner = THIS_MODULE, 2365 .name = "ide-tape", 2366 .bus = &ide_bus_type, 2367 }, 2368 .probe = ide_tape_probe, 2369 .remove = ide_tape_remove, 2370 .version = IDETAPE_VERSION, 2371 .media = ide_tape, 2372 .do_request = idetape_do_request, 2373 .end_request = idetape_end_request, 2374 .error = __ide_error, 2375#ifdef CONFIG_IDE_PROC_FS 2376 .proc = idetape_proc, 2377 .settings = idetape_settings, 2378#endif 2379}; 2380 2381/* Our character device supporting functions, passed to register_chrdev. */ 2382static const struct file_operations idetape_fops = { 2383 .owner = THIS_MODULE, 2384 .read = idetape_chrdev_read, 2385 .write = idetape_chrdev_write, 2386 .ioctl = idetape_chrdev_ioctl, 2387 .open = idetape_chrdev_open, 2388 .release = idetape_chrdev_release, 2389}; 2390 2391static int idetape_open(struct inode *inode, struct file *filp) 2392{ 2393 struct gendisk *disk = inode->i_bdev->bd_disk; 2394 struct ide_tape_obj *tape; 2395 2396 tape = ide_tape_get(disk); 2397 if (!tape) 2398 return -ENXIO; 2399 2400 return 0; 2401} 2402 2403static int idetape_release(struct inode *inode, struct file *filp) 2404{ 2405 struct gendisk *disk = inode->i_bdev->bd_disk; 2406 struct ide_tape_obj *tape = ide_tape_g(disk); 2407 2408 ide_tape_put(tape); 2409 2410 return 0; 2411} 2412 2413static int idetape_ioctl(struct inode *inode, struct file *file, 2414 unsigned int cmd, unsigned long arg) 2415{ 2416 struct block_device *bdev = inode->i_bdev; 2417 struct ide_tape_obj *tape = ide_tape_g(bdev->bd_disk); 2418 ide_drive_t *drive = tape->drive; 2419 int err = generic_ide_ioctl(drive, file, bdev, cmd, arg); 2420 if (err == -EINVAL) 2421 err = idetape_blkdev_ioctl(drive, cmd, arg); 2422 return err; 2423} 2424 2425static struct block_device_operations idetape_block_ops = { 2426 .owner = THIS_MODULE, 2427 .open = idetape_open, 2428 .release = idetape_release, 2429 .ioctl = idetape_ioctl, 2430}; 2431 2432static int ide_tape_probe(ide_drive_t *drive) 2433{ 2434 idetape_tape_t *tape; 2435 struct gendisk *g; 2436 int minor; 2437 2438 if (!strstr("ide-tape", drive->driver_req)) 2439 goto failed; 2440 2441 if (drive->media != ide_tape) 2442 goto failed; 2443 2444 if (drive->id_read == 1 && !ide_check_atapi_device(drive, DRV_NAME)) { 2445 printk(KERN_ERR "ide-tape: %s: not supported by this version of" 2446 " the driver\n", drive->name); 2447 goto failed; 2448 } 2449 tape = kzalloc(sizeof(idetape_tape_t), GFP_KERNEL); 2450 if (tape == NULL) { 2451 printk(KERN_ERR "ide-tape: %s: Can't allocate a tape struct\n", 2452 drive->name); 2453 goto failed; 2454 } 2455 2456 g = alloc_disk(1 << PARTN_BITS); 2457 if (!g) 2458 goto out_free_tape; 2459 2460 ide_init_disk(g, drive); 2461 2462 kref_init(&tape->kref); 2463 2464 tape->drive = drive; 2465 tape->driver = &idetape_driver; 2466 tape->disk = g; 2467 2468 g->private_data = &tape->driver; 2469 2470 drive->driver_data = tape; 2471 2472 mutex_lock(&idetape_ref_mutex); 2473 for (minor = 0; idetape_devs[minor]; minor++) 2474 ; 2475 idetape_devs[minor] = tape; 2476 mutex_unlock(&idetape_ref_mutex); 2477 2478 idetape_setup(drive, tape, minor); 2479 2480 device_create_drvdata(idetape_sysfs_class, &drive->gendev, 2481 MKDEV(IDETAPE_MAJOR, minor), NULL, 2482 "%s", tape->name); 2483 device_create_drvdata(idetape_sysfs_class, &drive->gendev, 2484 MKDEV(IDETAPE_MAJOR, minor + 128), NULL, 2485 "n%s", tape->name); 2486 2487 g->fops = &idetape_block_ops; 2488 ide_register_region(g); 2489 2490 return 0; 2491 2492out_free_tape: 2493 kfree(tape); 2494failed: 2495 return -ENODEV; 2496} 2497 2498static void __exit idetape_exit(void) 2499{ 2500 driver_unregister(&idetape_driver.gen_driver); 2501 class_destroy(idetape_sysfs_class); 2502 unregister_chrdev(IDETAPE_MAJOR, "ht"); 2503} 2504 2505static int __init idetape_init(void) 2506{ 2507 int error = 1; 2508 idetape_sysfs_class = class_create(THIS_MODULE, "ide_tape"); 2509 if (IS_ERR(idetape_sysfs_class)) { 2510 idetape_sysfs_class = NULL; 2511 printk(KERN_ERR "Unable to create sysfs class for ide tapes\n"); 2512 error = -EBUSY; 2513 goto out; 2514 } 2515 2516 if (register_chrdev(IDETAPE_MAJOR, "ht", &idetape_fops)) { 2517 printk(KERN_ERR "ide-tape: Failed to register chrdev" 2518 " interface\n"); 2519 error = -EBUSY; 2520 goto out_free_class; 2521 } 2522 2523 error = driver_register(&idetape_driver.gen_driver); 2524 if (error) 2525 goto out_free_driver; 2526 2527 return 0; 2528 2529out_free_driver: 2530 driver_unregister(&idetape_driver.gen_driver); 2531out_free_class: 2532 class_destroy(idetape_sysfs_class); 2533out: 2534 return error; 2535} 2536 2537MODULE_ALIAS("ide:*m-tape*"); 2538module_init(idetape_init); 2539module_exit(idetape_exit); 2540MODULE_ALIAS_CHARDEV_MAJOR(IDETAPE_MAJOR); 2541MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver"); 2542MODULE_LICENSE("GPL"); 2543