ide-tape.c revision 9798630a75c2c13849aeefcc1ba0559a701b5d95
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 IDETAPE_VERSION "1.20" 19 20#include <linux/module.h> 21#include <linux/types.h> 22#include <linux/string.h> 23#include <linux/kernel.h> 24#include <linux/delay.h> 25#include <linux/timer.h> 26#include <linux/mm.h> 27#include <linux/interrupt.h> 28#include <linux/jiffies.h> 29#include <linux/major.h> 30#include <linux/errno.h> 31#include <linux/genhd.h> 32#include <linux/slab.h> 33#include <linux/pci.h> 34#include <linux/ide.h> 35#include <linux/smp_lock.h> 36#include <linux/completion.h> 37#include <linux/bitops.h> 38#include <linux/mutex.h> 39#include <scsi/scsi.h> 40 41#include <asm/byteorder.h> 42#include <linux/irq.h> 43#include <linux/uaccess.h> 44#include <linux/io.h> 45#include <asm/unaligned.h> 46#include <linux/mtio.h> 47 48enum { 49 /* output errors only */ 50 DBG_ERR = (1 << 0), 51 /* output all sense key/asc */ 52 DBG_SENSE = (1 << 1), 53 /* info regarding all chrdev-related procedures */ 54 DBG_CHRDEV = (1 << 2), 55 /* all remaining procedures */ 56 DBG_PROCS = (1 << 3), 57 /* buffer alloc info (pc_stack & rq_stack) */ 58 DBG_PCRQ_STACK = (1 << 4), 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 * With each packet command, we allocate a buffer of IDETAPE_PC_BUFFER_SIZE 85 * bytes. This is used for several packet commands (Not for READ/WRITE commands) 86 */ 87#define IDETAPE_PC_BUFFER_SIZE 256 88 89/* 90 * In various places in the driver, we need to allocate storage 91 * for packet commands and requests, which will remain valid while 92 * we leave the driver to wait for an interrupt or a timeout event. 93 */ 94#define IDETAPE_PC_STACK (10 + IDETAPE_MAX_PC_RETRIES) 95 96/* 97 * Some drives (for example, Seagate STT3401A Travan) require a very long 98 * timeout, because they don't return an interrupt or clear their busy bit 99 * until after the command completes (even retension commands). 100 */ 101#define IDETAPE_WAIT_CMD (900*HZ) 102 103/* 104 * The following parameter is used to select the point in the internal tape fifo 105 * in which we will start to refill the buffer. Decreasing the following 106 * parameter will improve the system's latency and interactive response, while 107 * using a high value might improve system throughput. 108 */ 109#define IDETAPE_FIFO_THRESHOLD 2 110 111/* 112 * DSC polling parameters. 113 * 114 * Polling for DSC (a single bit in the status register) is a very important 115 * function in ide-tape. There are two cases in which we poll for DSC: 116 * 117 * 1. Before a read/write packet command, to ensure that we can transfer data 118 * from/to the tape's data buffers, without causing an actual media access. 119 * In case the tape is not ready yet, we take out our request from the device 120 * request queue, so that ide.c could service requests from the other device 121 * on the same interface in the meantime. 122 * 123 * 2. After the successful initialization of a "media access packet command", 124 * which is a command that can take a long time to complete (the interval can 125 * range from several seconds to even an hour). Again, we postpone our request 126 * in the middle to free the bus for the other device. The polling frequency 127 * here should be lower than the read/write frequency since those media access 128 * commands are slow. We start from a "fast" frequency - IDETAPE_DSC_MA_FAST 129 * (1 second), and if we don't receive DSC after IDETAPE_DSC_MA_THRESHOLD 130 * (5 min), we switch it to a lower frequency - IDETAPE_DSC_MA_SLOW (1 min). 131 * 132 * We also set a timeout for the timer, in case something goes wrong. The 133 * timeout should be longer then the maximum execution time of a tape operation. 134 */ 135 136/* DSC timings. */ 137#define IDETAPE_DSC_RW_MIN 5*HZ/100 /* 50 msec */ 138#define IDETAPE_DSC_RW_MAX 40*HZ/100 /* 400 msec */ 139#define IDETAPE_DSC_RW_TIMEOUT 2*60*HZ /* 2 minutes */ 140#define IDETAPE_DSC_MA_FAST 2*HZ /* 2 seconds */ 141#define IDETAPE_DSC_MA_THRESHOLD 5*60*HZ /* 5 minutes */ 142#define IDETAPE_DSC_MA_SLOW 30*HZ /* 30 seconds */ 143#define IDETAPE_DSC_MA_TIMEOUT 2*60*60*HZ /* 2 hours */ 144 145/*************************** End of tunable parameters ***********************/ 146 147/* Read/Write error simulation */ 148#define SIMULATE_ERRORS 0 149 150/* tape directions */ 151enum { 152 IDETAPE_DIR_NONE = (1 << 0), 153 IDETAPE_DIR_READ = (1 << 1), 154 IDETAPE_DIR_WRITE = (1 << 2), 155}; 156 157struct idetape_bh { 158 u32 b_size; 159 atomic_t b_count; 160 struct idetape_bh *b_reqnext; 161 char *b_data; 162}; 163 164/* Tape door status */ 165#define DOOR_UNLOCKED 0 166#define DOOR_LOCKED 1 167#define DOOR_EXPLICITLY_LOCKED 2 168 169/* Some defines for the SPACE command */ 170#define IDETAPE_SPACE_OVER_FILEMARK 1 171#define IDETAPE_SPACE_TO_EOD 3 172 173/* Some defines for the LOAD UNLOAD command */ 174#define IDETAPE_LU_LOAD_MASK 1 175#define IDETAPE_LU_RETENSION_MASK 2 176#define IDETAPE_LU_EOT_MASK 4 177 178/* 179 * Special requests for our block device strategy routine. 180 * 181 * In order to service a character device command, we add special requests to 182 * the tail of our block device request queue and wait for their completion. 183 */ 184 185enum { 186 REQ_IDETAPE_PC1 = (1 << 0), /* packet command (first stage) */ 187 REQ_IDETAPE_PC2 = (1 << 1), /* packet command (second stage) */ 188 REQ_IDETAPE_READ = (1 << 2), 189 REQ_IDETAPE_WRITE = (1 << 3), 190}; 191 192/* Error codes returned in rq->errors to the higher part of the driver. */ 193#define IDETAPE_ERROR_GENERAL 101 194#define IDETAPE_ERROR_FILEMARK 102 195#define IDETAPE_ERROR_EOD 103 196 197/* Structures related to the SELECT SENSE / MODE SENSE packet commands. */ 198#define IDETAPE_BLOCK_DESCRIPTOR 0 199#define IDETAPE_CAPABILITIES_PAGE 0x2a 200 201/* Tape flag bits values. */ 202enum { 203 IDETAPE_FLAG_IGNORE_DSC = (1 << 0), 204 /* 0 When the tape position is unknown */ 205 IDETAPE_FLAG_ADDRESS_VALID = (1 << 1), 206 /* Device already opened */ 207 IDETAPE_FLAG_BUSY = (1 << 2), 208 /* Attempt to auto-detect the current user block size */ 209 IDETAPE_FLAG_DETECT_BS = (1 << 3), 210 /* Currently on a filemark */ 211 IDETAPE_FLAG_FILEMARK = (1 << 4), 212 /* DRQ interrupt device */ 213 IDETAPE_FLAG_DRQ_INTERRUPT = (1 << 5), 214 /* 0 = no tape is loaded, so we don't rewind after ejecting */ 215 IDETAPE_FLAG_MEDIUM_PRESENT = (1 << 6), 216}; 217 218/* A pipeline stage. */ 219typedef struct idetape_stage_s { 220 struct request rq; /* The corresponding request */ 221 struct idetape_bh *bh; /* The data buffers */ 222 struct idetape_stage_s *next; /* Pointer to the next stage */ 223} idetape_stage_t; 224 225/* 226 * Most of our global data which we need to save even as we leave the driver due 227 * to an interrupt or a timer event is stored in the struct defined below. 228 */ 229typedef struct ide_tape_obj { 230 ide_drive_t *drive; 231 ide_driver_t *driver; 232 struct gendisk *disk; 233 struct kref kref; 234 235 /* 236 * Since a typical character device operation requires more 237 * than one packet command, we provide here enough memory 238 * for the maximum of interconnected packet commands. 239 * The packet commands are stored in the circular array pc_stack. 240 * pc_stack_index points to the last used entry, and warps around 241 * to the start when we get to the last array entry. 242 * 243 * pc points to the current processed packet command. 244 * 245 * failed_pc points to the last failed packet command, or contains 246 * NULL if we do not need to retry any packet command. This is 247 * required since an additional packet command is needed before the 248 * retry, to get detailed information on what went wrong. 249 */ 250 /* Current packet command */ 251 struct ide_atapi_pc *pc; 252 /* Last failed packet command */ 253 struct ide_atapi_pc *failed_pc; 254 /* Packet command stack */ 255 struct ide_atapi_pc pc_stack[IDETAPE_PC_STACK]; 256 /* Next free packet command storage space */ 257 int pc_stack_index; 258 struct request rq_stack[IDETAPE_PC_STACK]; 259 /* We implement a circular array */ 260 int rq_stack_index; 261 262 /* 263 * DSC polling variables. 264 * 265 * While polling for DSC we use postponed_rq to postpone the current 266 * request so that ide.c will be able to service pending requests on the 267 * other device. Note that at most we will have only one DSC (usually 268 * data transfer) request in the device request queue. 269 */ 270 struct request *postponed_rq; 271 /* The time in which we started polling for DSC */ 272 unsigned long dsc_polling_start; 273 /* Timer used to poll for dsc */ 274 struct timer_list dsc_timer; 275 /* Read/Write dsc polling frequency */ 276 unsigned long best_dsc_rw_freq; 277 unsigned long dsc_poll_freq; 278 unsigned long dsc_timeout; 279 280 /* Read position information */ 281 u8 partition; 282 /* Current block */ 283 unsigned int first_frame; 284 285 /* Last error information */ 286 u8 sense_key, asc, ascq; 287 288 /* Character device operation */ 289 unsigned int minor; 290 /* device name */ 291 char name[4]; 292 /* Current character device data transfer direction */ 293 u8 chrdev_dir; 294 295 /* tape block size, usually 512 or 1024 bytes */ 296 unsigned short blk_size; 297 int user_bs_factor; 298 299 /* Copy of the tape's Capabilities and Mechanical Page */ 300 u8 caps[20]; 301 302 /* 303 * Active data transfer request parameters. 304 * 305 * At most, there is only one ide-tape originated data transfer request 306 * in the device request queue. This allows ide.c to easily service 307 * requests from the other device when we postpone our active request. 308 */ 309 310 /* Data buffer size chosen based on the tape's recommendation */ 311 int buffer_size; 312 idetape_stage_t *merge_stage; 313 int merge_stage_size; 314 struct idetape_bh *bh; 315 char *b_data; 316 int b_count; 317 318 int pages_per_buffer; 319 /* Wasted space in each stage */ 320 int excess_bh_size; 321 322 /* Status/Action flags: long for set_bit */ 323 unsigned long flags; 324 /* protects the ide-tape queue */ 325 spinlock_t lock; 326 327 /* Measures average tape speed */ 328 unsigned long avg_time; 329 int avg_size; 330 int avg_speed; 331 332 /* the door is currently locked */ 333 int door_locked; 334 /* the tape hardware is write protected */ 335 char drv_write_prot; 336 /* the tape is write protected (hardware or opened as read-only) */ 337 char write_prot; 338 339 u32 debug_mask; 340} idetape_tape_t; 341 342static DEFINE_MUTEX(idetape_ref_mutex); 343 344static struct class *idetape_sysfs_class; 345 346#define to_ide_tape(obj) container_of(obj, struct ide_tape_obj, kref) 347 348#define ide_tape_g(disk) \ 349 container_of((disk)->private_data, struct ide_tape_obj, driver) 350 351static struct ide_tape_obj *ide_tape_get(struct gendisk *disk) 352{ 353 struct ide_tape_obj *tape = NULL; 354 355 mutex_lock(&idetape_ref_mutex); 356 tape = ide_tape_g(disk); 357 if (tape) 358 kref_get(&tape->kref); 359 mutex_unlock(&idetape_ref_mutex); 360 return tape; 361} 362 363static void ide_tape_release(struct kref *); 364 365static void ide_tape_put(struct ide_tape_obj *tape) 366{ 367 mutex_lock(&idetape_ref_mutex); 368 kref_put(&tape->kref, ide_tape_release); 369 mutex_unlock(&idetape_ref_mutex); 370} 371 372/* 373 * The variables below are used for the character device interface. Additional 374 * state variables are defined in our ide_drive_t structure. 375 */ 376static struct ide_tape_obj *idetape_devs[MAX_HWIFS * MAX_DRIVES]; 377 378#define ide_tape_f(file) ((file)->private_data) 379 380static struct ide_tape_obj *ide_tape_chrdev_get(unsigned int i) 381{ 382 struct ide_tape_obj *tape = NULL; 383 384 mutex_lock(&idetape_ref_mutex); 385 tape = idetape_devs[i]; 386 if (tape) 387 kref_get(&tape->kref); 388 mutex_unlock(&idetape_ref_mutex); 389 return tape; 390} 391 392static void idetape_input_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, 393 unsigned int bcount) 394{ 395 struct idetape_bh *bh = pc->bh; 396 int count; 397 398 while (bcount) { 399 if (bh == NULL) { 400 printk(KERN_ERR "ide-tape: bh == NULL in " 401 "idetape_input_buffers\n"); 402 ide_atapi_discard_data(drive, bcount); 403 return; 404 } 405 count = min( 406 (unsigned int)(bh->b_size - atomic_read(&bh->b_count)), 407 bcount); 408 HWIF(drive)->atapi_input_bytes(drive, bh->b_data + 409 atomic_read(&bh->b_count), count); 410 bcount -= count; 411 atomic_add(count, &bh->b_count); 412 if (atomic_read(&bh->b_count) == bh->b_size) { 413 bh = bh->b_reqnext; 414 if (bh) 415 atomic_set(&bh->b_count, 0); 416 } 417 } 418 pc->bh = bh; 419} 420 421static void idetape_output_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, 422 unsigned int bcount) 423{ 424 struct idetape_bh *bh = pc->bh; 425 int count; 426 427 while (bcount) { 428 if (bh == NULL) { 429 printk(KERN_ERR "ide-tape: bh == NULL in %s\n", 430 __func__); 431 return; 432 } 433 count = min((unsigned int)pc->b_count, (unsigned int)bcount); 434 HWIF(drive)->atapi_output_bytes(drive, pc->b_data, count); 435 bcount -= count; 436 pc->b_data += count; 437 pc->b_count -= count; 438 if (!pc->b_count) { 439 bh = bh->b_reqnext; 440 pc->bh = bh; 441 if (bh) { 442 pc->b_data = bh->b_data; 443 pc->b_count = atomic_read(&bh->b_count); 444 } 445 } 446 } 447} 448 449static void idetape_update_buffers(struct ide_atapi_pc *pc) 450{ 451 struct idetape_bh *bh = pc->bh; 452 int count; 453 unsigned int bcount = pc->xferred; 454 455 if (pc->flags & PC_FLAG_WRITING) 456 return; 457 while (bcount) { 458 if (bh == NULL) { 459 printk(KERN_ERR "ide-tape: bh == NULL in %s\n", 460 __func__); 461 return; 462 } 463 count = min((unsigned int)bh->b_size, (unsigned int)bcount); 464 atomic_set(&bh->b_count, count); 465 if (atomic_read(&bh->b_count) == bh->b_size) 466 bh = bh->b_reqnext; 467 bcount -= count; 468 } 469 pc->bh = bh; 470} 471 472/* 473 * idetape_next_pc_storage returns a pointer to a place in which we can 474 * safely store a packet command, even though we intend to leave the 475 * driver. A storage space for a maximum of IDETAPE_PC_STACK packet 476 * commands is allocated at initialization time. 477 */ 478static struct ide_atapi_pc *idetape_next_pc_storage(ide_drive_t *drive) 479{ 480 idetape_tape_t *tape = drive->driver_data; 481 482 debug_log(DBG_PCRQ_STACK, "pc_stack_index=%d\n", tape->pc_stack_index); 483 484 if (tape->pc_stack_index == IDETAPE_PC_STACK) 485 tape->pc_stack_index = 0; 486 return (&tape->pc_stack[tape->pc_stack_index++]); 487} 488 489/* 490 * idetape_next_rq_storage is used along with idetape_next_pc_storage. 491 * Since we queue packet commands in the request queue, we need to 492 * allocate a request, along with the allocation of a packet command. 493 */ 494 495/************************************************************** 496 * * 497 * This should get fixed to use kmalloc(.., GFP_ATOMIC) * 498 * followed later on by kfree(). -ml * 499 * * 500 **************************************************************/ 501 502static struct request *idetape_next_rq_storage(ide_drive_t *drive) 503{ 504 idetape_tape_t *tape = drive->driver_data; 505 506 debug_log(DBG_PCRQ_STACK, "rq_stack_index=%d\n", tape->rq_stack_index); 507 508 if (tape->rq_stack_index == IDETAPE_PC_STACK) 509 tape->rq_stack_index = 0; 510 return (&tape->rq_stack[tape->rq_stack_index++]); 511} 512 513static void idetape_init_pc(struct ide_atapi_pc *pc) 514{ 515 memset(pc->c, 0, 12); 516 pc->retries = 0; 517 pc->flags = 0; 518 pc->req_xfer = 0; 519 pc->buf = pc->pc_buf; 520 pc->buf_size = IDETAPE_PC_BUFFER_SIZE; 521 pc->bh = NULL; 522 pc->b_data = NULL; 523} 524 525/* 526 * called on each failed packet command retry to analyze the request sense. We 527 * currently do not utilize this information. 528 */ 529static void idetape_analyze_error(ide_drive_t *drive, u8 *sense) 530{ 531 idetape_tape_t *tape = drive->driver_data; 532 struct ide_atapi_pc *pc = tape->failed_pc; 533 534 tape->sense_key = sense[2] & 0xF; 535 tape->asc = sense[12]; 536 tape->ascq = sense[13]; 537 538 debug_log(DBG_ERR, "pc = %x, sense key = %x, asc = %x, ascq = %x\n", 539 pc->c[0], tape->sense_key, tape->asc, tape->ascq); 540 541 /* Correct pc->xferred by asking the tape. */ 542 if (pc->flags & PC_FLAG_DMA_ERROR) { 543 pc->xferred = pc->req_xfer - 544 tape->blk_size * 545 be32_to_cpu(get_unaligned((u32 *)&sense[3])); 546 idetape_update_buffers(pc); 547 } 548 549 /* 550 * If error was the result of a zero-length read or write command, 551 * with sense key=5, asc=0x22, ascq=0, let it slide. Some drives 552 * (i.e. Seagate STT3401A Travan) don't support 0-length read/writes. 553 */ 554 if ((pc->c[0] == READ_6 || pc->c[0] == WRITE_6) 555 /* length == 0 */ 556 && pc->c[4] == 0 && pc->c[3] == 0 && pc->c[2] == 0) { 557 if (tape->sense_key == 5) { 558 /* don't report an error, everything's ok */ 559 pc->error = 0; 560 /* don't retry read/write */ 561 pc->flags |= PC_FLAG_ABORT; 562 } 563 } 564 if (pc->c[0] == READ_6 && (sense[2] & 0x80)) { 565 pc->error = IDETAPE_ERROR_FILEMARK; 566 pc->flags |= PC_FLAG_ABORT; 567 } 568 if (pc->c[0] == WRITE_6) { 569 if ((sense[2] & 0x40) || (tape->sense_key == 0xd 570 && tape->asc == 0x0 && tape->ascq == 0x2)) { 571 pc->error = IDETAPE_ERROR_EOD; 572 pc->flags |= PC_FLAG_ABORT; 573 } 574 } 575 if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) { 576 if (tape->sense_key == 8) { 577 pc->error = IDETAPE_ERROR_EOD; 578 pc->flags |= PC_FLAG_ABORT; 579 } 580 if (!(pc->flags & PC_FLAG_ABORT) && 581 pc->xferred) 582 pc->retries = IDETAPE_MAX_PC_RETRIES + 1; 583 } 584} 585 586/* Free data buffers completely. */ 587static void ide_tape_kfree_buffer(idetape_stage_t *stage) 588{ 589 struct idetape_bh *prev_bh, *bh = stage->bh; 590 591 while (bh) { 592 u32 size = bh->b_size; 593 594 while (size) { 595 unsigned int order = fls(size >> PAGE_SHIFT)-1; 596 597 if (bh->b_data) 598 free_pages((unsigned long)bh->b_data, order); 599 600 size &= (order-1); 601 bh->b_data += (1 << order) * PAGE_SIZE; 602 } 603 prev_bh = bh; 604 bh = bh->b_reqnext; 605 kfree(prev_bh); 606 } 607 kfree(stage); 608} 609 610static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects) 611{ 612 struct request *rq = HWGROUP(drive)->rq; 613 idetape_tape_t *tape = drive->driver_data; 614 unsigned long flags; 615 int error; 616 617 debug_log(DBG_PROCS, "Enter %s\n", __func__); 618 619 switch (uptodate) { 620 case 0: error = IDETAPE_ERROR_GENERAL; break; 621 case 1: error = 0; break; 622 default: error = uptodate; 623 } 624 rq->errors = error; 625 if (error) 626 tape->failed_pc = NULL; 627 628 if (!blk_special_request(rq)) { 629 ide_end_request(drive, uptodate, nr_sects); 630 return 0; 631 } 632 633 spin_lock_irqsave(&tape->lock, flags); 634 635 ide_end_drive_cmd(drive, 0, 0); 636 637 spin_unlock_irqrestore(&tape->lock, flags); 638 return 0; 639} 640 641static ide_startstop_t idetape_request_sense_callback(ide_drive_t *drive) 642{ 643 idetape_tape_t *tape = drive->driver_data; 644 645 debug_log(DBG_PROCS, "Enter %s\n", __func__); 646 647 if (!tape->pc->error) { 648 idetape_analyze_error(drive, tape->pc->buf); 649 idetape_end_request(drive, 1, 0); 650 } else { 651 printk(KERN_ERR "ide-tape: Error in REQUEST SENSE itself - " 652 "Aborting request!\n"); 653 idetape_end_request(drive, 0, 0); 654 } 655 return ide_stopped; 656} 657 658static void idetape_create_request_sense_cmd(struct ide_atapi_pc *pc) 659{ 660 idetape_init_pc(pc); 661 pc->c[0] = REQUEST_SENSE; 662 pc->c[4] = 20; 663 pc->req_xfer = 20; 664 pc->idetape_callback = &idetape_request_sense_callback; 665} 666 667static void idetape_init_rq(struct request *rq, u8 cmd) 668{ 669 memset(rq, 0, sizeof(*rq)); 670 rq->cmd_type = REQ_TYPE_SPECIAL; 671 rq->cmd[0] = cmd; 672} 673 674/* 675 * Generate a new packet command request in front of the request queue, before 676 * the current request, so that it will be processed immediately, on the next 677 * pass through the driver. The function below is called from the request 678 * handling part of the driver (the "bottom" part). Safe storage for the request 679 * should be allocated with ide_tape_next_{pc,rq}_storage() prior to that. 680 * 681 * Memory for those requests is pre-allocated at initialization time, and is 682 * limited to IDETAPE_PC_STACK requests. We assume that we have enough space for 683 * the maximum possible number of inter-dependent packet commands. 684 * 685 * The higher level of the driver - The ioctl handler and the character device 686 * handling functions should queue request to the lower level part and wait for 687 * their completion using idetape_queue_pc_tail or idetape_queue_rw_tail. 688 */ 689static void idetape_queue_pc_head(ide_drive_t *drive, struct ide_atapi_pc *pc, 690 struct request *rq) 691{ 692 struct ide_tape_obj *tape = drive->driver_data; 693 694 idetape_init_rq(rq, REQ_IDETAPE_PC1); 695 rq->buffer = (char *) pc; 696 rq->rq_disk = tape->disk; 697 (void) ide_do_drive_cmd(drive, rq, ide_preempt); 698} 699 700/* 701 * idetape_retry_pc is called when an error was detected during the 702 * last packet command. We queue a request sense packet command in 703 * the head of the request list. 704 */ 705static ide_startstop_t idetape_retry_pc (ide_drive_t *drive) 706{ 707 idetape_tape_t *tape = drive->driver_data; 708 struct ide_atapi_pc *pc; 709 struct request *rq; 710 711 (void)ide_read_error(drive); 712 pc = idetape_next_pc_storage(drive); 713 rq = idetape_next_rq_storage(drive); 714 idetape_create_request_sense_cmd(pc); 715 set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags); 716 idetape_queue_pc_head(drive, pc, rq); 717 return ide_stopped; 718} 719 720/* 721 * Postpone the current request so that ide.c will be able to service requests 722 * from another device on the same hwgroup while we are polling for DSC. 723 */ 724static void idetape_postpone_request(ide_drive_t *drive) 725{ 726 idetape_tape_t *tape = drive->driver_data; 727 728 debug_log(DBG_PROCS, "Enter %s\n", __func__); 729 730 tape->postponed_rq = HWGROUP(drive)->rq; 731 ide_stall_queue(drive, tape->dsc_poll_freq); 732} 733 734typedef void idetape_io_buf(ide_drive_t *, struct ide_atapi_pc *, unsigned int); 735 736/* 737 * This is the usual interrupt handler which will be called during a packet 738 * command. We will transfer some of the data (as requested by the drive) and 739 * will re-point interrupt handler to us. When data transfer is finished, we 740 * will act according to the algorithm described before 741 * idetape_issue_pc. 742 */ 743static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 744{ 745 ide_hwif_t *hwif = drive->hwif; 746 idetape_tape_t *tape = drive->driver_data; 747 struct ide_atapi_pc *pc = tape->pc; 748 xfer_func_t *xferfunc; 749 idetape_io_buf *iobuf; 750 unsigned int temp; 751#if SIMULATE_ERRORS 752 static int error_sim_count; 753#endif 754 u16 bcount; 755 u8 stat, ireason; 756 757 debug_log(DBG_PROCS, "Enter %s - interrupt handler\n", __func__); 758 759 /* Clear the interrupt */ 760 stat = ide_read_status(drive); 761 762 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { 763 if (hwif->dma_ops->dma_end(drive) || (stat & ERR_STAT)) { 764 /* 765 * A DMA error is sometimes expected. For example, 766 * if the tape is crossing a filemark during a 767 * READ command, it will issue an irq and position 768 * itself before the filemark, so that only a partial 769 * data transfer will occur (which causes the DMA 770 * error). In that case, we will later ask the tape 771 * how much bytes of the original request were 772 * actually transferred (we can't receive that 773 * information from the DMA engine on most chipsets). 774 */ 775 776 /* 777 * On the contrary, a DMA error is never expected; 778 * it usually indicates a hardware error or abort. 779 * If the tape crosses a filemark during a READ 780 * command, it will issue an irq and position itself 781 * after the filemark (not before). Only a partial 782 * data transfer will occur, but no DMA error. 783 * (AS, 19 Apr 2001) 784 */ 785 pc->flags |= PC_FLAG_DMA_ERROR; 786 } else { 787 pc->xferred = pc->req_xfer; 788 idetape_update_buffers(pc); 789 } 790 debug_log(DBG_PROCS, "DMA finished\n"); 791 792 } 793 794 /* No more interrupts */ 795 if ((stat & DRQ_STAT) == 0) { 796 debug_log(DBG_SENSE, "Packet command completed, %d bytes" 797 " transferred\n", pc->xferred); 798 799 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS; 800 local_irq_enable(); 801 802#if SIMULATE_ERRORS 803 if ((pc->c[0] == WRITE_6 || pc->c[0] == READ_6) && 804 (++error_sim_count % 100) == 0) { 805 printk(KERN_INFO "ide-tape: %s: simulating error\n", 806 tape->name); 807 stat |= ERR_STAT; 808 } 809#endif 810 if ((stat & ERR_STAT) && pc->c[0] == REQUEST_SENSE) 811 stat &= ~ERR_STAT; 812 if ((stat & ERR_STAT) || (pc->flags & PC_FLAG_DMA_ERROR)) { 813 /* Error detected */ 814 debug_log(DBG_ERR, "%s: I/O error\n", tape->name); 815 816 if (pc->c[0] == REQUEST_SENSE) { 817 printk(KERN_ERR "ide-tape: I/O error in request" 818 " sense command\n"); 819 return ide_do_reset(drive); 820 } 821 debug_log(DBG_ERR, "[cmd %x]: check condition\n", 822 pc->c[0]); 823 824 /* Retry operation */ 825 return idetape_retry_pc(drive); 826 } 827 pc->error = 0; 828 if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && 829 (stat & SEEK_STAT) == 0) { 830 /* Media access command */ 831 tape->dsc_polling_start = jiffies; 832 tape->dsc_poll_freq = IDETAPE_DSC_MA_FAST; 833 tape->dsc_timeout = jiffies + IDETAPE_DSC_MA_TIMEOUT; 834 /* Allow ide.c to handle other requests */ 835 idetape_postpone_request(drive); 836 return ide_stopped; 837 } 838 if (tape->failed_pc == pc) 839 tape->failed_pc = NULL; 840 /* Command finished - Call the callback function */ 841 return pc->idetape_callback(drive); 842 } 843 844 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { 845 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS; 846 printk(KERN_ERR "ide-tape: The tape wants to issue more " 847 "interrupts in DMA mode\n"); 848 printk(KERN_ERR "ide-tape: DMA disabled, reverting to PIO\n"); 849 ide_dma_off(drive); 850 return ide_do_reset(drive); 851 } 852 /* Get the number of bytes to transfer on this interrupt. */ 853 bcount = (hwif->INB(hwif->io_ports.lbah_addr) << 8) | 854 hwif->INB(hwif->io_ports.lbam_addr); 855 856 ireason = hwif->INB(hwif->io_ports.nsect_addr); 857 858 if (ireason & CD) { 859 printk(KERN_ERR "ide-tape: CoD != 0 in %s\n", __func__); 860 return ide_do_reset(drive); 861 } 862 if (((ireason & IO) == IO) == !!(pc->flags & PC_FLAG_WRITING)) { 863 /* Hopefully, we will never get here */ 864 printk(KERN_ERR "ide-tape: We wanted to %s, ", 865 (ireason & IO) ? "Write" : "Read"); 866 printk(KERN_ERR "ide-tape: but the tape wants us to %s !\n", 867 (ireason & IO) ? "Read" : "Write"); 868 return ide_do_reset(drive); 869 } 870 if (!(pc->flags & PC_FLAG_WRITING)) { 871 /* Reading - Check that we have enough space */ 872 temp = pc->xferred + bcount; 873 if (temp > pc->req_xfer) { 874 if (temp > pc->buf_size) { 875 printk(KERN_ERR "ide-tape: The tape wants to " 876 "send us more data than expected " 877 "- discarding data\n"); 878 ide_atapi_discard_data(drive, bcount); 879 ide_set_handler(drive, &idetape_pc_intr, 880 IDETAPE_WAIT_CMD, NULL); 881 return ide_started; 882 } 883 debug_log(DBG_SENSE, "The tape wants to send us more " 884 "data than expected - allowing transfer\n"); 885 } 886 iobuf = &idetape_input_buffers; 887 xferfunc = hwif->atapi_input_bytes; 888 } else { 889 iobuf = &idetape_output_buffers; 890 xferfunc = hwif->atapi_output_bytes; 891 } 892 893 if (pc->bh) 894 iobuf(drive, pc, bcount); 895 else 896 xferfunc(drive, pc->cur_pos, bcount); 897 898 /* Update the current position */ 899 pc->xferred += bcount; 900 pc->cur_pos += bcount; 901 902 debug_log(DBG_SENSE, "[cmd %x] transferred %d bytes on that intr.\n", 903 pc->c[0], bcount); 904 905 /* And set the interrupt handler again */ 906 ide_set_handler(drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL); 907 return ide_started; 908} 909 910/* 911 * Packet Command Interface 912 * 913 * The current Packet Command is available in tape->pc, and will not change 914 * until we finish handling it. Each packet command is associated with a 915 * callback function that will be called when the command is finished. 916 * 917 * The handling will be done in three stages: 918 * 919 * 1. idetape_issue_pc will send the packet command to the drive, and will set 920 * the interrupt handler to idetape_pc_intr. 921 * 922 * 2. On each interrupt, idetape_pc_intr will be called. This step will be 923 * repeated until the device signals us that no more interrupts will be issued. 924 * 925 * 3. ATAPI Tape media access commands have immediate status with a delayed 926 * process. In case of a successful initiation of a media access packet command, 927 * the DSC bit will be set when the actual execution of the command is finished. 928 * Since the tape drive will not issue an interrupt, we have to poll for this 929 * event. In this case, we define the request as "low priority request" by 930 * setting rq_status to IDETAPE_RQ_POSTPONED, set a timer to poll for DSC and 931 * exit the driver. 932 * 933 * ide.c will then give higher priority to requests which originate from the 934 * other device, until will change rq_status to RQ_ACTIVE. 935 * 936 * 4. When the packet command is finished, it will be checked for errors. 937 * 938 * 5. In case an error was found, we queue a request sense packet command in 939 * front of the request queue and retry the operation up to 940 * IDETAPE_MAX_PC_RETRIES times. 941 * 942 * 6. In case no error was found, or we decided to give up and not to retry 943 * again, the callback function will be called and then we will handle the next 944 * request. 945 */ 946static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive) 947{ 948 ide_hwif_t *hwif = drive->hwif; 949 idetape_tape_t *tape = drive->driver_data; 950 struct ide_atapi_pc *pc = tape->pc; 951 int retries = 100; 952 ide_startstop_t startstop; 953 u8 ireason; 954 955 if (ide_wait_stat(&startstop, drive, DRQ_STAT, BUSY_STAT, WAIT_READY)) { 956 printk(KERN_ERR "ide-tape: Strange, packet command initiated " 957 "yet DRQ isn't asserted\n"); 958 return startstop; 959 } 960 ireason = hwif->INB(hwif->io_ports.nsect_addr); 961 while (retries-- && ((ireason & CD) == 0 || (ireason & IO))) { 962 printk(KERN_ERR "ide-tape: (IO,CoD != (0,1) while issuing " 963 "a packet command, retrying\n"); 964 udelay(100); 965 ireason = hwif->INB(hwif->io_ports.nsect_addr); 966 if (retries == 0) { 967 printk(KERN_ERR "ide-tape: (IO,CoD != (0,1) while " 968 "issuing a packet command, ignoring\n"); 969 ireason |= CD; 970 ireason &= ~IO; 971 } 972 } 973 if ((ireason & CD) == 0 || (ireason & IO)) { 974 printk(KERN_ERR "ide-tape: (IO,CoD) != (0,1) while issuing " 975 "a packet command\n"); 976 return ide_do_reset(drive); 977 } 978 /* Set the interrupt routine */ 979 ide_set_handler(drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL); 980#ifdef CONFIG_BLK_DEV_IDEDMA 981 /* Begin DMA, if necessary */ 982 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) 983 hwif->dma_ops->dma_start(drive); 984#endif 985 /* Send the actual packet */ 986 HWIF(drive)->atapi_output_bytes(drive, pc->c, 12); 987 return ide_started; 988} 989 990static ide_startstop_t idetape_issue_pc(ide_drive_t *drive, 991 struct ide_atapi_pc *pc) 992{ 993 ide_hwif_t *hwif = drive->hwif; 994 idetape_tape_t *tape = drive->driver_data; 995 int dma_ok = 0; 996 u16 bcount; 997 998 if (tape->pc->c[0] == REQUEST_SENSE && 999 pc->c[0] == REQUEST_SENSE) { 1000 printk(KERN_ERR "ide-tape: possible ide-tape.c bug - " 1001 "Two request sense in serial were issued\n"); 1002 } 1003 1004 if (tape->failed_pc == NULL && pc->c[0] != REQUEST_SENSE) 1005 tape->failed_pc = pc; 1006 /* Set the current packet command */ 1007 tape->pc = pc; 1008 1009 if (pc->retries > IDETAPE_MAX_PC_RETRIES || 1010 (pc->flags & PC_FLAG_ABORT)) { 1011 /* 1012 * We will "abort" retrying a packet command in case legitimate 1013 * error code was received (crossing a filemark, or end of the 1014 * media, for example). 1015 */ 1016 if (!(pc->flags & PC_FLAG_ABORT)) { 1017 if (!(pc->c[0] == TEST_UNIT_READY && 1018 tape->sense_key == 2 && tape->asc == 4 && 1019 (tape->ascq == 1 || tape->ascq == 8))) { 1020 printk(KERN_ERR "ide-tape: %s: I/O error, " 1021 "pc = %2x, key = %2x, " 1022 "asc = %2x, ascq = %2x\n", 1023 tape->name, pc->c[0], 1024 tape->sense_key, tape->asc, 1025 tape->ascq); 1026 } 1027 /* Giving up */ 1028 pc->error = IDETAPE_ERROR_GENERAL; 1029 } 1030 tape->failed_pc = NULL; 1031 return pc->idetape_callback(drive); 1032 } 1033 debug_log(DBG_SENSE, "Retry #%d, cmd = %02X\n", pc->retries, pc->c[0]); 1034 1035 pc->retries++; 1036 /* We haven't transferred any data yet */ 1037 pc->xferred = 0; 1038 pc->cur_pos = pc->buf; 1039 /* Request to transfer the entire buffer at once */ 1040 bcount = pc->req_xfer; 1041 1042 if (pc->flags & PC_FLAG_DMA_ERROR) { 1043 pc->flags &= ~PC_FLAG_DMA_ERROR; 1044 printk(KERN_WARNING "ide-tape: DMA disabled, " 1045 "reverting to PIO\n"); 1046 ide_dma_off(drive); 1047 } 1048 if ((pc->flags & PC_FLAG_DMA_RECOMMENDED) && drive->using_dma) 1049 dma_ok = !hwif->dma_ops->dma_setup(drive); 1050 1051 ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK | 1052 IDE_TFLAG_OUT_DEVICE, bcount, dma_ok); 1053 1054 if (dma_ok) 1055 /* Will begin DMA later */ 1056 pc->flags |= PC_FLAG_DMA_IN_PROGRESS; 1057 if (test_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags)) { 1058 ide_execute_command(drive, WIN_PACKETCMD, &idetape_transfer_pc, 1059 IDETAPE_WAIT_CMD, NULL); 1060 return ide_started; 1061 } else { 1062 hwif->OUTB(WIN_PACKETCMD, hwif->io_ports.command_addr); 1063 return idetape_transfer_pc(drive); 1064 } 1065} 1066 1067static ide_startstop_t idetape_pc_callback(ide_drive_t *drive) 1068{ 1069 idetape_tape_t *tape = drive->driver_data; 1070 1071 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1072 1073 idetape_end_request(drive, tape->pc->error ? 0 : 1, 0); 1074 return ide_stopped; 1075} 1076 1077/* A mode sense command is used to "sense" tape parameters. */ 1078static void idetape_create_mode_sense_cmd(struct ide_atapi_pc *pc, u8 page_code) 1079{ 1080 idetape_init_pc(pc); 1081 pc->c[0] = MODE_SENSE; 1082 if (page_code != IDETAPE_BLOCK_DESCRIPTOR) 1083 /* DBD = 1 - Don't return block descriptors */ 1084 pc->c[1] = 8; 1085 pc->c[2] = page_code; 1086 /* 1087 * Changed pc->c[3] to 0 (255 will at best return unused info). 1088 * 1089 * For SCSI this byte is defined as subpage instead of high byte 1090 * of length and some IDE drives seem to interpret it this way 1091 * and return an error when 255 is used. 1092 */ 1093 pc->c[3] = 0; 1094 /* We will just discard data in that case */ 1095 pc->c[4] = 255; 1096 if (page_code == IDETAPE_BLOCK_DESCRIPTOR) 1097 pc->req_xfer = 12; 1098 else if (page_code == IDETAPE_CAPABILITIES_PAGE) 1099 pc->req_xfer = 24; 1100 else 1101 pc->req_xfer = 50; 1102 pc->idetape_callback = &idetape_pc_callback; 1103} 1104 1105static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive) 1106{ 1107 idetape_tape_t *tape = drive->driver_data; 1108 struct ide_atapi_pc *pc = tape->pc; 1109 u8 stat; 1110 1111 stat = ide_read_status(drive); 1112 1113 if (stat & SEEK_STAT) { 1114 if (stat & ERR_STAT) { 1115 /* Error detected */ 1116 if (pc->c[0] != TEST_UNIT_READY) 1117 printk(KERN_ERR "ide-tape: %s: I/O error, ", 1118 tape->name); 1119 /* Retry operation */ 1120 return idetape_retry_pc(drive); 1121 } 1122 pc->error = 0; 1123 if (tape->failed_pc == pc) 1124 tape->failed_pc = NULL; 1125 } else { 1126 pc->error = IDETAPE_ERROR_GENERAL; 1127 tape->failed_pc = NULL; 1128 } 1129 return pc->idetape_callback(drive); 1130} 1131 1132static ide_startstop_t idetape_rw_callback(ide_drive_t *drive) 1133{ 1134 idetape_tape_t *tape = drive->driver_data; 1135 struct request *rq = HWGROUP(drive)->rq; 1136 int blocks = tape->pc->xferred / tape->blk_size; 1137 1138 tape->avg_size += blocks * tape->blk_size; 1139 1140 if (time_after_eq(jiffies, tape->avg_time + HZ)) { 1141 tape->avg_speed = tape->avg_size * HZ / 1142 (jiffies - tape->avg_time) / 1024; 1143 tape->avg_size = 0; 1144 tape->avg_time = jiffies; 1145 } 1146 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1147 1148 tape->first_frame += blocks; 1149 rq->current_nr_sectors -= blocks; 1150 1151 if (!tape->pc->error) 1152 idetape_end_request(drive, 1, 0); 1153 else 1154 idetape_end_request(drive, tape->pc->error, 0); 1155 return ide_stopped; 1156} 1157 1158static void idetape_create_read_cmd(idetape_tape_t *tape, 1159 struct ide_atapi_pc *pc, 1160 unsigned int length, struct idetape_bh *bh) 1161{ 1162 idetape_init_pc(pc); 1163 pc->c[0] = READ_6; 1164 put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); 1165 pc->c[1] = 1; 1166 pc->idetape_callback = &idetape_rw_callback; 1167 pc->bh = bh; 1168 atomic_set(&bh->b_count, 0); 1169 pc->buf = NULL; 1170 pc->buf_size = length * tape->blk_size; 1171 pc->req_xfer = pc->buf_size; 1172 if (pc->req_xfer == tape->buffer_size) 1173 pc->flags |= PC_FLAG_DMA_RECOMMENDED; 1174} 1175 1176static void idetape_create_write_cmd(idetape_tape_t *tape, 1177 struct ide_atapi_pc *pc, 1178 unsigned int length, struct idetape_bh *bh) 1179{ 1180 idetape_init_pc(pc); 1181 pc->c[0] = WRITE_6; 1182 put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); 1183 pc->c[1] = 1; 1184 pc->idetape_callback = &idetape_rw_callback; 1185 pc->flags |= PC_FLAG_WRITING; 1186 pc->bh = bh; 1187 pc->b_data = bh->b_data; 1188 pc->b_count = atomic_read(&bh->b_count); 1189 pc->buf = NULL; 1190 pc->buf_size = length * tape->blk_size; 1191 pc->req_xfer = pc->buf_size; 1192 if (pc->req_xfer == tape->buffer_size) 1193 pc->flags |= PC_FLAG_DMA_RECOMMENDED; 1194} 1195 1196static ide_startstop_t idetape_do_request(ide_drive_t *drive, 1197 struct request *rq, sector_t block) 1198{ 1199 idetape_tape_t *tape = drive->driver_data; 1200 struct ide_atapi_pc *pc = NULL; 1201 struct request *postponed_rq = tape->postponed_rq; 1202 u8 stat; 1203 1204 debug_log(DBG_SENSE, "sector: %ld, nr_sectors: %ld," 1205 " current_nr_sectors: %d\n", 1206 rq->sector, rq->nr_sectors, rq->current_nr_sectors); 1207 1208 if (!blk_special_request(rq)) { 1209 /* We do not support buffer cache originated requests. */ 1210 printk(KERN_NOTICE "ide-tape: %s: Unsupported request in " 1211 "request queue (%d)\n", drive->name, rq->cmd_type); 1212 ide_end_request(drive, 0, 0); 1213 return ide_stopped; 1214 } 1215 1216 /* Retry a failed packet command */ 1217 if (tape->failed_pc && tape->pc->c[0] == REQUEST_SENSE) 1218 return idetape_issue_pc(drive, tape->failed_pc); 1219 1220 if (postponed_rq != NULL) 1221 if (rq != postponed_rq) { 1222 printk(KERN_ERR "ide-tape: ide-tape.c bug - " 1223 "Two DSC requests were queued\n"); 1224 idetape_end_request(drive, 0, 0); 1225 return ide_stopped; 1226 } 1227 1228 tape->postponed_rq = NULL; 1229 1230 /* 1231 * If the tape is still busy, postpone our request and service 1232 * the other device meanwhile. 1233 */ 1234 stat = ide_read_status(drive); 1235 1236 if (!drive->dsc_overlap && !(rq->cmd[0] & REQ_IDETAPE_PC2)) 1237 set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags); 1238 1239 if (drive->post_reset == 1) { 1240 set_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags); 1241 drive->post_reset = 0; 1242 } 1243 1244 if (!test_and_clear_bit(IDETAPE_FLAG_IGNORE_DSC, &tape->flags) && 1245 (stat & SEEK_STAT) == 0) { 1246 if (postponed_rq == NULL) { 1247 tape->dsc_polling_start = jiffies; 1248 tape->dsc_poll_freq = tape->best_dsc_rw_freq; 1249 tape->dsc_timeout = jiffies + IDETAPE_DSC_RW_TIMEOUT; 1250 } else if (time_after(jiffies, tape->dsc_timeout)) { 1251 printk(KERN_ERR "ide-tape: %s: DSC timeout\n", 1252 tape->name); 1253 if (rq->cmd[0] & REQ_IDETAPE_PC2) { 1254 idetape_media_access_finished(drive); 1255 return ide_stopped; 1256 } else { 1257 return ide_do_reset(drive); 1258 } 1259 } else if (time_after(jiffies, 1260 tape->dsc_polling_start + 1261 IDETAPE_DSC_MA_THRESHOLD)) 1262 tape->dsc_poll_freq = IDETAPE_DSC_MA_SLOW; 1263 idetape_postpone_request(drive); 1264 return ide_stopped; 1265 } 1266 if (rq->cmd[0] & REQ_IDETAPE_READ) { 1267 pc = idetape_next_pc_storage(drive); 1268 idetape_create_read_cmd(tape, pc, rq->current_nr_sectors, 1269 (struct idetape_bh *)rq->special); 1270 goto out; 1271 } 1272 if (rq->cmd[0] & REQ_IDETAPE_WRITE) { 1273 pc = idetape_next_pc_storage(drive); 1274 idetape_create_write_cmd(tape, pc, rq->current_nr_sectors, 1275 (struct idetape_bh *)rq->special); 1276 goto out; 1277 } 1278 if (rq->cmd[0] & REQ_IDETAPE_PC1) { 1279 pc = (struct ide_atapi_pc *) rq->buffer; 1280 rq->cmd[0] &= ~(REQ_IDETAPE_PC1); 1281 rq->cmd[0] |= REQ_IDETAPE_PC2; 1282 goto out; 1283 } 1284 if (rq->cmd[0] & REQ_IDETAPE_PC2) { 1285 idetape_media_access_finished(drive); 1286 return ide_stopped; 1287 } 1288 BUG(); 1289out: 1290 return idetape_issue_pc(drive, pc); 1291} 1292 1293/* 1294 * The function below uses __get_free_pages to allocate a data buffer of size 1295 * tape->buffer_size (or a bit more). We attempt to combine sequential pages as 1296 * much as possible. 1297 * 1298 * It returns a pointer to the newly allocated buffer, or NULL in case of 1299 * failure. 1300 */ 1301static idetape_stage_t *ide_tape_kmalloc_buffer(idetape_tape_t *tape, int full, 1302 int clear) 1303{ 1304 idetape_stage_t *stage; 1305 struct idetape_bh *prev_bh, *bh; 1306 int pages = tape->pages_per_buffer; 1307 unsigned int order, b_allocd; 1308 char *b_data = NULL; 1309 1310 stage = kmalloc(sizeof(idetape_stage_t), GFP_KERNEL); 1311 if (!stage) 1312 return NULL; 1313 stage->next = NULL; 1314 1315 stage->bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL); 1316 bh = stage->bh; 1317 if (bh == NULL) 1318 goto abort; 1319 1320 order = fls(pages) - 1; 1321 bh->b_data = (char *) __get_free_pages(GFP_KERNEL, order); 1322 if (!bh->b_data) 1323 goto abort; 1324 b_allocd = (1 << order) * PAGE_SIZE; 1325 pages &= (order-1); 1326 1327 if (clear) 1328 memset(bh->b_data, 0, b_allocd); 1329 bh->b_reqnext = NULL; 1330 bh->b_size = b_allocd; 1331 atomic_set(&bh->b_count, full ? bh->b_size : 0); 1332 1333 while (pages) { 1334 order = fls(pages) - 1; 1335 b_data = (char *) __get_free_pages(GFP_KERNEL, order); 1336 if (!b_data) 1337 goto abort; 1338 b_allocd = (1 << order) * PAGE_SIZE; 1339 1340 if (clear) 1341 memset(b_data, 0, b_allocd); 1342 1343 /* newly allocated page frames below buffer header or ...*/ 1344 if (bh->b_data == b_data + b_allocd) { 1345 bh->b_size += b_allocd; 1346 bh->b_data -= b_allocd; 1347 if (full) 1348 atomic_add(b_allocd, &bh->b_count); 1349 continue; 1350 } 1351 /* they are above the header */ 1352 if (b_data == bh->b_data + bh->b_size) { 1353 bh->b_size += b_allocd; 1354 if (full) 1355 atomic_add(b_allocd, &bh->b_count); 1356 continue; 1357 } 1358 prev_bh = bh; 1359 bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL); 1360 if (!bh) { 1361 free_pages((unsigned long) b_data, order); 1362 goto abort; 1363 } 1364 bh->b_reqnext = NULL; 1365 bh->b_data = b_data; 1366 bh->b_size = b_allocd; 1367 atomic_set(&bh->b_count, full ? bh->b_size : 0); 1368 prev_bh->b_reqnext = bh; 1369 1370 pages &= (order-1); 1371 } 1372 1373 bh->b_size -= tape->excess_bh_size; 1374 if (full) 1375 atomic_sub(tape->excess_bh_size, &bh->b_count); 1376 return stage; 1377abort: 1378 ide_tape_kfree_buffer(stage); 1379 return NULL; 1380} 1381 1382static int idetape_copy_stage_from_user(idetape_tape_t *tape, 1383 const char __user *buf, int n) 1384{ 1385 struct idetape_bh *bh = tape->bh; 1386 int count; 1387 int ret = 0; 1388 1389 while (n) { 1390 if (bh == NULL) { 1391 printk(KERN_ERR "ide-tape: bh == NULL in %s\n", 1392 __func__); 1393 return 1; 1394 } 1395 count = min((unsigned int) 1396 (bh->b_size - atomic_read(&bh->b_count)), 1397 (unsigned int)n); 1398 if (copy_from_user(bh->b_data + atomic_read(&bh->b_count), buf, 1399 count)) 1400 ret = 1; 1401 n -= count; 1402 atomic_add(count, &bh->b_count); 1403 buf += count; 1404 if (atomic_read(&bh->b_count) == bh->b_size) { 1405 bh = bh->b_reqnext; 1406 if (bh) 1407 atomic_set(&bh->b_count, 0); 1408 } 1409 } 1410 tape->bh = bh; 1411 return ret; 1412} 1413 1414static int idetape_copy_stage_to_user(idetape_tape_t *tape, char __user *buf, 1415 int n) 1416{ 1417 struct idetape_bh *bh = tape->bh; 1418 int count; 1419 int ret = 0; 1420 1421 while (n) { 1422 if (bh == NULL) { 1423 printk(KERN_ERR "ide-tape: bh == NULL in %s\n", 1424 __func__); 1425 return 1; 1426 } 1427 count = min(tape->b_count, n); 1428 if (copy_to_user(buf, tape->b_data, count)) 1429 ret = 1; 1430 n -= count; 1431 tape->b_data += count; 1432 tape->b_count -= count; 1433 buf += count; 1434 if (!tape->b_count) { 1435 bh = bh->b_reqnext; 1436 tape->bh = bh; 1437 if (bh) { 1438 tape->b_data = bh->b_data; 1439 tape->b_count = atomic_read(&bh->b_count); 1440 } 1441 } 1442 } 1443 return ret; 1444} 1445 1446static void idetape_init_merge_stage(idetape_tape_t *tape) 1447{ 1448 struct idetape_bh *bh = tape->merge_stage->bh; 1449 1450 tape->bh = bh; 1451 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) 1452 atomic_set(&bh->b_count, 0); 1453 else { 1454 tape->b_data = bh->b_data; 1455 tape->b_count = atomic_read(&bh->b_count); 1456 } 1457} 1458 1459static ide_startstop_t idetape_read_position_callback(ide_drive_t *drive) 1460{ 1461 idetape_tape_t *tape = drive->driver_data; 1462 u8 *readpos = tape->pc->buf; 1463 1464 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1465 1466 if (!tape->pc->error) { 1467 debug_log(DBG_SENSE, "BOP - %s\n", 1468 (readpos[0] & 0x80) ? "Yes" : "No"); 1469 debug_log(DBG_SENSE, "EOP - %s\n", 1470 (readpos[0] & 0x40) ? "Yes" : "No"); 1471 1472 if (readpos[0] & 0x4) { 1473 printk(KERN_INFO "ide-tape: Block location is unknown" 1474 "to the tape\n"); 1475 clear_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags); 1476 idetape_end_request(drive, 0, 0); 1477 } else { 1478 debug_log(DBG_SENSE, "Block Location - %u\n", 1479 be32_to_cpu(*(u32 *)&readpos[4])); 1480 1481 tape->partition = readpos[1]; 1482 tape->first_frame = 1483 be32_to_cpu(*(u32 *)&readpos[4]); 1484 set_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags); 1485 idetape_end_request(drive, 1, 0); 1486 } 1487 } else { 1488 idetape_end_request(drive, 0, 0); 1489 } 1490 return ide_stopped; 1491} 1492 1493/* 1494 * Write a filemark if write_filemark=1. Flush the device buffers without 1495 * writing a filemark otherwise. 1496 */ 1497static void idetape_create_write_filemark_cmd(ide_drive_t *drive, 1498 struct ide_atapi_pc *pc, int write_filemark) 1499{ 1500 idetape_init_pc(pc); 1501 pc->c[0] = WRITE_FILEMARKS; 1502 pc->c[4] = write_filemark; 1503 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1504 pc->idetape_callback = &idetape_pc_callback; 1505} 1506 1507static void idetape_create_test_unit_ready_cmd(struct ide_atapi_pc *pc) 1508{ 1509 idetape_init_pc(pc); 1510 pc->c[0] = TEST_UNIT_READY; 1511 pc->idetape_callback = &idetape_pc_callback; 1512} 1513 1514/* 1515 * We add a special packet command request to the tail of the request queue, and 1516 * wait for it to be serviced. This is not to be called from within the request 1517 * handling part of the driver! We allocate here data on the stack and it is 1518 * valid until the request is finished. This is not the case for the bottom part 1519 * of the driver, where we are always leaving the functions to wait for an 1520 * interrupt or a timer event. 1521 * 1522 * From the bottom part of the driver, we should allocate safe memory using 1523 * idetape_next_pc_storage() and ide_tape_next_rq_storage(), and add the request 1524 * to the request list without waiting for it to be serviced! In that case, we 1525 * usually use idetape_queue_pc_head(). 1526 */ 1527static int idetape_queue_pc_tail(ide_drive_t *drive, struct ide_atapi_pc *pc) 1528{ 1529 struct ide_tape_obj *tape = drive->driver_data; 1530 struct request rq; 1531 1532 idetape_init_rq(&rq, REQ_IDETAPE_PC1); 1533 rq.buffer = (char *) pc; 1534 rq.rq_disk = tape->disk; 1535 return ide_do_drive_cmd(drive, &rq, ide_wait); 1536} 1537 1538static void idetape_create_load_unload_cmd(ide_drive_t *drive, 1539 struct ide_atapi_pc *pc, int cmd) 1540{ 1541 idetape_init_pc(pc); 1542 pc->c[0] = START_STOP; 1543 pc->c[4] = cmd; 1544 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1545 pc->idetape_callback = &idetape_pc_callback; 1546} 1547 1548static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout) 1549{ 1550 idetape_tape_t *tape = drive->driver_data; 1551 struct ide_atapi_pc pc; 1552 int load_attempted = 0; 1553 1554 /* Wait for the tape to become ready */ 1555 set_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags); 1556 timeout += jiffies; 1557 while (time_before(jiffies, timeout)) { 1558 idetape_create_test_unit_ready_cmd(&pc); 1559 if (!idetape_queue_pc_tail(drive, &pc)) 1560 return 0; 1561 if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2) 1562 || (tape->asc == 0x3A)) { 1563 /* no media */ 1564 if (load_attempted) 1565 return -ENOMEDIUM; 1566 idetape_create_load_unload_cmd(drive, &pc, 1567 IDETAPE_LU_LOAD_MASK); 1568 idetape_queue_pc_tail(drive, &pc); 1569 load_attempted = 1; 1570 /* not about to be ready */ 1571 } else if (!(tape->sense_key == 2 && tape->asc == 4 && 1572 (tape->ascq == 1 || tape->ascq == 8))) 1573 return -EIO; 1574 msleep(100); 1575 } 1576 return -EIO; 1577} 1578 1579static int idetape_flush_tape_buffers(ide_drive_t *drive) 1580{ 1581 struct ide_atapi_pc pc; 1582 int rc; 1583 1584 idetape_create_write_filemark_cmd(drive, &pc, 0); 1585 rc = idetape_queue_pc_tail(drive, &pc); 1586 if (rc) 1587 return rc; 1588 idetape_wait_ready(drive, 60 * 5 * HZ); 1589 return 0; 1590} 1591 1592static void idetape_create_read_position_cmd(struct ide_atapi_pc *pc) 1593{ 1594 idetape_init_pc(pc); 1595 pc->c[0] = READ_POSITION; 1596 pc->req_xfer = 20; 1597 pc->idetape_callback = &idetape_read_position_callback; 1598} 1599 1600static int idetape_read_position(ide_drive_t *drive) 1601{ 1602 idetape_tape_t *tape = drive->driver_data; 1603 struct ide_atapi_pc pc; 1604 int position; 1605 1606 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1607 1608 idetape_create_read_position_cmd(&pc); 1609 if (idetape_queue_pc_tail(drive, &pc)) 1610 return -1; 1611 position = tape->first_frame; 1612 return position; 1613} 1614 1615static void idetape_create_locate_cmd(ide_drive_t *drive, 1616 struct ide_atapi_pc *pc, 1617 unsigned int block, u8 partition, int skip) 1618{ 1619 idetape_init_pc(pc); 1620 pc->c[0] = POSITION_TO_ELEMENT; 1621 pc->c[1] = 2; 1622 put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[3]); 1623 pc->c[8] = partition; 1624 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1625 pc->idetape_callback = &idetape_pc_callback; 1626} 1627 1628static int idetape_create_prevent_cmd(ide_drive_t *drive, 1629 struct ide_atapi_pc *pc, int prevent) 1630{ 1631 idetape_tape_t *tape = drive->driver_data; 1632 1633 /* device supports locking according to capabilities page */ 1634 if (!(tape->caps[6] & 0x01)) 1635 return 0; 1636 1637 idetape_init_pc(pc); 1638 pc->c[0] = ALLOW_MEDIUM_REMOVAL; 1639 pc->c[4] = prevent; 1640 pc->idetape_callback = &idetape_pc_callback; 1641 return 1; 1642} 1643 1644static void __idetape_discard_read_pipeline(ide_drive_t *drive) 1645{ 1646 idetape_tape_t *tape = drive->driver_data; 1647 1648 if (tape->chrdev_dir != IDETAPE_DIR_READ) 1649 return; 1650 1651 clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags); 1652 tape->merge_stage_size = 0; 1653 if (tape->merge_stage != NULL) { 1654 ide_tape_kfree_buffer(tape->merge_stage); 1655 tape->merge_stage = NULL; 1656 } 1657 1658 tape->chrdev_dir = IDETAPE_DIR_NONE; 1659} 1660 1661/* 1662 * Position the tape to the requested block using the LOCATE packet command. 1663 * A READ POSITION command is then issued to check where we are positioned. Like 1664 * all higher level operations, we queue the commands at the tail of the request 1665 * queue and wait for their completion. 1666 */ 1667static int idetape_position_tape(ide_drive_t *drive, unsigned int block, 1668 u8 partition, int skip) 1669{ 1670 idetape_tape_t *tape = drive->driver_data; 1671 int retval; 1672 struct ide_atapi_pc pc; 1673 1674 if (tape->chrdev_dir == IDETAPE_DIR_READ) 1675 __idetape_discard_read_pipeline(drive); 1676 idetape_wait_ready(drive, 60 * 5 * HZ); 1677 idetape_create_locate_cmd(drive, &pc, block, partition, skip); 1678 retval = idetape_queue_pc_tail(drive, &pc); 1679 if (retval) 1680 return (retval); 1681 1682 idetape_create_read_position_cmd(&pc); 1683 return (idetape_queue_pc_tail(drive, &pc)); 1684} 1685 1686static void idetape_discard_read_pipeline(ide_drive_t *drive, 1687 int restore_position) 1688{ 1689 idetape_tape_t *tape = drive->driver_data; 1690 int seek, position; 1691 1692 __idetape_discard_read_pipeline(drive); 1693 if (restore_position) { 1694 position = idetape_read_position(drive); 1695 seek = position > 0 ? position : 0; 1696 if (idetape_position_tape(drive, seek, 0, 0)) { 1697 printk(KERN_INFO "ide-tape: %s: position_tape failed in" 1698 " discard_pipeline()\n", tape->name); 1699 return; 1700 } 1701 } 1702} 1703 1704/* 1705 * Generate a read/write request for the block device interface and wait for it 1706 * to be serviced. 1707 */ 1708static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int blocks, 1709 struct idetape_bh *bh) 1710{ 1711 idetape_tape_t *tape = drive->driver_data; 1712 struct request rq; 1713 1714 debug_log(DBG_SENSE, "%s: cmd=%d\n", __func__, cmd); 1715 1716 idetape_init_rq(&rq, cmd); 1717 rq.rq_disk = tape->disk; 1718 rq.special = (void *)bh; 1719 rq.sector = tape->first_frame; 1720 rq.nr_sectors = blocks; 1721 rq.current_nr_sectors = blocks; 1722 (void) ide_do_drive_cmd(drive, &rq, ide_wait); 1723 1724 if ((cmd & (REQ_IDETAPE_READ | REQ_IDETAPE_WRITE)) == 0) 1725 return 0; 1726 1727 if (tape->merge_stage) 1728 idetape_init_merge_stage(tape); 1729 if (rq.errors == IDETAPE_ERROR_GENERAL) 1730 return -EIO; 1731 return (tape->blk_size * (blocks-rq.current_nr_sectors)); 1732} 1733 1734static void idetape_create_inquiry_cmd(struct ide_atapi_pc *pc) 1735{ 1736 idetape_init_pc(pc); 1737 pc->c[0] = INQUIRY; 1738 pc->c[4] = 254; 1739 pc->req_xfer = 254; 1740 pc->idetape_callback = &idetape_pc_callback; 1741} 1742 1743static void idetape_create_rewind_cmd(ide_drive_t *drive, 1744 struct ide_atapi_pc *pc) 1745{ 1746 idetape_init_pc(pc); 1747 pc->c[0] = REZERO_UNIT; 1748 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1749 pc->idetape_callback = &idetape_pc_callback; 1750} 1751 1752static void idetape_create_erase_cmd(struct ide_atapi_pc *pc) 1753{ 1754 idetape_init_pc(pc); 1755 pc->c[0] = ERASE; 1756 pc->c[1] = 1; 1757 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1758 pc->idetape_callback = &idetape_pc_callback; 1759} 1760 1761static void idetape_create_space_cmd(struct ide_atapi_pc *pc, int count, u8 cmd) 1762{ 1763 idetape_init_pc(pc); 1764 pc->c[0] = SPACE; 1765 put_unaligned(cpu_to_be32(count), (unsigned int *) &pc->c[1]); 1766 pc->c[1] = cmd; 1767 pc->flags |= PC_FLAG_WAIT_FOR_DSC; 1768 pc->idetape_callback = &idetape_pc_callback; 1769} 1770 1771/* Queue up a character device originated write request. */ 1772static int idetape_add_chrdev_write_request(ide_drive_t *drive, int blocks) 1773{ 1774 idetape_tape_t *tape = drive->driver_data; 1775 1776 debug_log(DBG_CHRDEV, "Enter %s\n", __func__); 1777 1778 return idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, 1779 blocks, tape->merge_stage->bh); 1780} 1781 1782static void idetape_empty_write_pipeline(ide_drive_t *drive) 1783{ 1784 idetape_tape_t *tape = drive->driver_data; 1785 int blocks, min; 1786 struct idetape_bh *bh; 1787 1788 if (tape->chrdev_dir != IDETAPE_DIR_WRITE) { 1789 printk(KERN_ERR "ide-tape: bug: Trying to empty write pipeline," 1790 " but we are not writing.\n"); 1791 return; 1792 } 1793 if (tape->merge_stage_size > tape->buffer_size) { 1794 printk(KERN_ERR "ide-tape: bug: merge_buffer too big\n"); 1795 tape->merge_stage_size = tape->buffer_size; 1796 } 1797 if (tape->merge_stage_size) { 1798 blocks = tape->merge_stage_size / tape->blk_size; 1799 if (tape->merge_stage_size % tape->blk_size) { 1800 unsigned int i; 1801 1802 blocks++; 1803 i = tape->blk_size - tape->merge_stage_size % 1804 tape->blk_size; 1805 bh = tape->bh->b_reqnext; 1806 while (bh) { 1807 atomic_set(&bh->b_count, 0); 1808 bh = bh->b_reqnext; 1809 } 1810 bh = tape->bh; 1811 while (i) { 1812 if (bh == NULL) { 1813 printk(KERN_INFO "ide-tape: bug," 1814 " bh NULL\n"); 1815 break; 1816 } 1817 min = min(i, (unsigned int)(bh->b_size - 1818 atomic_read(&bh->b_count))); 1819 memset(bh->b_data + atomic_read(&bh->b_count), 1820 0, min); 1821 atomic_add(min, &bh->b_count); 1822 i -= min; 1823 bh = bh->b_reqnext; 1824 } 1825 } 1826 (void) idetape_add_chrdev_write_request(drive, blocks); 1827 tape->merge_stage_size = 0; 1828 } 1829 if (tape->merge_stage != NULL) { 1830 ide_tape_kfree_buffer(tape->merge_stage); 1831 tape->merge_stage = NULL; 1832 } 1833 tape->chrdev_dir = IDETAPE_DIR_NONE; 1834} 1835 1836static int idetape_init_read(ide_drive_t *drive) 1837{ 1838 idetape_tape_t *tape = drive->driver_data; 1839 int bytes_read; 1840 1841 /* Initialize read operation */ 1842 if (tape->chrdev_dir != IDETAPE_DIR_READ) { 1843 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) { 1844 idetape_empty_write_pipeline(drive); 1845 idetape_flush_tape_buffers(drive); 1846 } 1847 if (tape->merge_stage || tape->merge_stage_size) { 1848 printk(KERN_ERR "ide-tape: merge_stage_size should be" 1849 " 0 now\n"); 1850 tape->merge_stage_size = 0; 1851 } 1852 tape->merge_stage = ide_tape_kmalloc_buffer(tape, 0, 0); 1853 if (!tape->merge_stage) 1854 return -ENOMEM; 1855 tape->chrdev_dir = IDETAPE_DIR_READ; 1856 1857 /* 1858 * Issue a read 0 command to ensure that DSC handshake is 1859 * switched from completion mode to buffer available mode. 1860 * No point in issuing this if DSC overlap isn't supported, some 1861 * drives (Seagate STT3401A) will return an error. 1862 */ 1863 if (drive->dsc_overlap) { 1864 bytes_read = idetape_queue_rw_tail(drive, 1865 REQ_IDETAPE_READ, 0, 1866 tape->merge_stage->bh); 1867 if (bytes_read < 0) { 1868 ide_tape_kfree_buffer(tape->merge_stage); 1869 tape->merge_stage = NULL; 1870 tape->chrdev_dir = IDETAPE_DIR_NONE; 1871 return bytes_read; 1872 } 1873 } 1874 } 1875 1876 return 0; 1877} 1878 1879/* called from idetape_chrdev_read() to service a chrdev read request. */ 1880static int idetape_add_chrdev_read_request(ide_drive_t *drive, int blocks) 1881{ 1882 idetape_tape_t *tape = drive->driver_data; 1883 1884 debug_log(DBG_PROCS, "Enter %s, %d blocks\n", __func__, blocks); 1885 1886 /* If we are at a filemark, return a read length of 0 */ 1887 if (test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) 1888 return 0; 1889 1890 idetape_init_read(drive); 1891 1892 return idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, blocks, 1893 tape->merge_stage->bh); 1894} 1895 1896static void idetape_pad_zeros(ide_drive_t *drive, int bcount) 1897{ 1898 idetape_tape_t *tape = drive->driver_data; 1899 struct idetape_bh *bh; 1900 int blocks; 1901 1902 while (bcount) { 1903 unsigned int count; 1904 1905 bh = tape->merge_stage->bh; 1906 count = min(tape->buffer_size, bcount); 1907 bcount -= count; 1908 blocks = count / tape->blk_size; 1909 while (count) { 1910 atomic_set(&bh->b_count, 1911 min(count, (unsigned int)bh->b_size)); 1912 memset(bh->b_data, 0, atomic_read(&bh->b_count)); 1913 count -= atomic_read(&bh->b_count); 1914 bh = bh->b_reqnext; 1915 } 1916 idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, blocks, 1917 tape->merge_stage->bh); 1918 } 1919} 1920 1921/* 1922 * Rewinds the tape to the Beginning Of the current Partition (BOP). We 1923 * currently support only one partition. 1924 */ 1925static int idetape_rewind_tape(ide_drive_t *drive) 1926{ 1927 int retval; 1928 struct ide_atapi_pc pc; 1929 idetape_tape_t *tape; 1930 tape = drive->driver_data; 1931 1932 debug_log(DBG_SENSE, "Enter %s\n", __func__); 1933 1934 idetape_create_rewind_cmd(drive, &pc); 1935 retval = idetape_queue_pc_tail(drive, &pc); 1936 if (retval) 1937 return retval; 1938 1939 idetape_create_read_position_cmd(&pc); 1940 retval = idetape_queue_pc_tail(drive, &pc); 1941 if (retval) 1942 return retval; 1943 return 0; 1944} 1945 1946/* mtio.h compatible commands should be issued to the chrdev interface. */ 1947static int idetape_blkdev_ioctl(ide_drive_t *drive, unsigned int cmd, 1948 unsigned long arg) 1949{ 1950 idetape_tape_t *tape = drive->driver_data; 1951 void __user *argp = (void __user *)arg; 1952 1953 struct idetape_config { 1954 int dsc_rw_frequency; 1955 int dsc_media_access_frequency; 1956 int nr_stages; 1957 } config; 1958 1959 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1960 1961 switch (cmd) { 1962 case 0x0340: 1963 if (copy_from_user(&config, argp, sizeof(config))) 1964 return -EFAULT; 1965 tape->best_dsc_rw_freq = config.dsc_rw_frequency; 1966 break; 1967 case 0x0350: 1968 config.dsc_rw_frequency = (int) tape->best_dsc_rw_freq; 1969 config.nr_stages = 1; 1970 if (copy_to_user(argp, &config, sizeof(config))) 1971 return -EFAULT; 1972 break; 1973 default: 1974 return -EIO; 1975 } 1976 return 0; 1977} 1978 1979static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op, 1980 int mt_count) 1981{ 1982 idetape_tape_t *tape = drive->driver_data; 1983 struct ide_atapi_pc pc; 1984 int retval, count = 0; 1985 int sprev = !!(tape->caps[4] & 0x20); 1986 1987 if (mt_count == 0) 1988 return 0; 1989 if (MTBSF == mt_op || MTBSFM == mt_op) { 1990 if (!sprev) 1991 return -EIO; 1992 mt_count = -mt_count; 1993 } 1994 1995 if (tape->chrdev_dir == IDETAPE_DIR_READ) { 1996 tape->merge_stage_size = 0; 1997 if (test_and_clear_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) 1998 ++count; 1999 idetape_discard_read_pipeline(drive, 0); 2000 } 2001 2002 /* 2003 * The filemark was not found in our internal pipeline; now we can issue 2004 * the space command. 2005 */ 2006 switch (mt_op) { 2007 case MTFSF: 2008 case MTBSF: 2009 idetape_create_space_cmd(&pc, mt_count - count, 2010 IDETAPE_SPACE_OVER_FILEMARK); 2011 return idetape_queue_pc_tail(drive, &pc); 2012 case MTFSFM: 2013 case MTBSFM: 2014 if (!sprev) 2015 return -EIO; 2016 retval = idetape_space_over_filemarks(drive, MTFSF, 2017 mt_count - count); 2018 if (retval) 2019 return retval; 2020 count = (MTBSFM == mt_op ? 1 : -1); 2021 return idetape_space_over_filemarks(drive, MTFSF, count); 2022 default: 2023 printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n", 2024 mt_op); 2025 return -EIO; 2026 } 2027} 2028 2029/* 2030 * Our character device read / write functions. 2031 * 2032 * The tape is optimized to maximize throughput when it is transferring an 2033 * integral number of the "continuous transfer limit", which is a parameter of 2034 * the specific tape (26kB on my particular tape, 32kB for Onstream). 2035 * 2036 * As of version 1.3 of the driver, the character device provides an abstract 2037 * continuous view of the media - any mix of block sizes (even 1 byte) on the 2038 * same backup/restore procedure is supported. The driver will internally 2039 * convert the requests to the recommended transfer unit, so that an unmatch 2040 * between the user's block size to the recommended size will only result in a 2041 * (slightly) increased driver overhead, but will no longer hit performance. 2042 * This is not applicable to Onstream. 2043 */ 2044static ssize_t idetape_chrdev_read(struct file *file, char __user *buf, 2045 size_t count, loff_t *ppos) 2046{ 2047 struct ide_tape_obj *tape = ide_tape_f(file); 2048 ide_drive_t *drive = tape->drive; 2049 ssize_t bytes_read, temp, actually_read = 0, rc; 2050 ssize_t ret = 0; 2051 u16 ctl = *(u16 *)&tape->caps[12]; 2052 2053 debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count); 2054 2055 if (tape->chrdev_dir != IDETAPE_DIR_READ) { 2056 if (test_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags)) 2057 if (count > tape->blk_size && 2058 (count % tape->blk_size) == 0) 2059 tape->user_bs_factor = count / tape->blk_size; 2060 } 2061 rc = idetape_init_read(drive); 2062 if (rc < 0) 2063 return rc; 2064 if (count == 0) 2065 return (0); 2066 if (tape->merge_stage_size) { 2067 actually_read = min((unsigned int)(tape->merge_stage_size), 2068 (unsigned int)count); 2069 if (idetape_copy_stage_to_user(tape, buf, actually_read)) 2070 ret = -EFAULT; 2071 buf += actually_read; 2072 tape->merge_stage_size -= actually_read; 2073 count -= actually_read; 2074 } 2075 while (count >= tape->buffer_size) { 2076 bytes_read = idetape_add_chrdev_read_request(drive, ctl); 2077 if (bytes_read <= 0) 2078 goto finish; 2079 if (idetape_copy_stage_to_user(tape, buf, bytes_read)) 2080 ret = -EFAULT; 2081 buf += bytes_read; 2082 count -= bytes_read; 2083 actually_read += bytes_read; 2084 } 2085 if (count) { 2086 bytes_read = idetape_add_chrdev_read_request(drive, ctl); 2087 if (bytes_read <= 0) 2088 goto finish; 2089 temp = min((unsigned long)count, (unsigned long)bytes_read); 2090 if (idetape_copy_stage_to_user(tape, buf, temp)) 2091 ret = -EFAULT; 2092 actually_read += temp; 2093 tape->merge_stage_size = bytes_read-temp; 2094 } 2095finish: 2096 if (!actually_read && test_bit(IDETAPE_FLAG_FILEMARK, &tape->flags)) { 2097 debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name); 2098 2099 idetape_space_over_filemarks(drive, MTFSF, 1); 2100 return 0; 2101 } 2102 2103 return ret ? ret : actually_read; 2104} 2105 2106static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf, 2107 size_t count, loff_t *ppos) 2108{ 2109 struct ide_tape_obj *tape = ide_tape_f(file); 2110 ide_drive_t *drive = tape->drive; 2111 ssize_t actually_written = 0; 2112 ssize_t ret = 0; 2113 u16 ctl = *(u16 *)&tape->caps[12]; 2114 2115 /* The drive is write protected. */ 2116 if (tape->write_prot) 2117 return -EACCES; 2118 2119 debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count); 2120 2121 /* Initialize write operation */ 2122 if (tape->chrdev_dir != IDETAPE_DIR_WRITE) { 2123 if (tape->chrdev_dir == IDETAPE_DIR_READ) 2124 idetape_discard_read_pipeline(drive, 1); 2125 if (tape->merge_stage || tape->merge_stage_size) { 2126 printk(KERN_ERR "ide-tape: merge_stage_size " 2127 "should be 0 now\n"); 2128 tape->merge_stage_size = 0; 2129 } 2130 tape->merge_stage = ide_tape_kmalloc_buffer(tape, 0, 0); 2131 if (!tape->merge_stage) 2132 return -ENOMEM; 2133 tape->chrdev_dir = IDETAPE_DIR_WRITE; 2134 idetape_init_merge_stage(tape); 2135 2136 /* 2137 * Issue a write 0 command to ensure that DSC handshake is 2138 * switched from completion mode to buffer available mode. No 2139 * point in issuing this if DSC overlap isn't supported, some 2140 * drives (Seagate STT3401A) will return an error. 2141 */ 2142 if (drive->dsc_overlap) { 2143 ssize_t retval = idetape_queue_rw_tail(drive, 2144 REQ_IDETAPE_WRITE, 0, 2145 tape->merge_stage->bh); 2146 if (retval < 0) { 2147 ide_tape_kfree_buffer(tape->merge_stage); 2148 tape->merge_stage = NULL; 2149 tape->chrdev_dir = IDETAPE_DIR_NONE; 2150 return retval; 2151 } 2152 } 2153 } 2154 if (count == 0) 2155 return (0); 2156 if (tape->merge_stage_size) { 2157 if (tape->merge_stage_size >= tape->buffer_size) { 2158 printk(KERN_ERR "ide-tape: bug: merge buf too big\n"); 2159 tape->merge_stage_size = 0; 2160 } 2161 actually_written = min((unsigned int) 2162 (tape->buffer_size - tape->merge_stage_size), 2163 (unsigned int)count); 2164 if (idetape_copy_stage_from_user(tape, buf, actually_written)) 2165 ret = -EFAULT; 2166 buf += actually_written; 2167 tape->merge_stage_size += actually_written; 2168 count -= actually_written; 2169 2170 if (tape->merge_stage_size == tape->buffer_size) { 2171 ssize_t retval; 2172 tape->merge_stage_size = 0; 2173 retval = idetape_add_chrdev_write_request(drive, ctl); 2174 if (retval <= 0) 2175 return (retval); 2176 } 2177 } 2178 while (count >= tape->buffer_size) { 2179 ssize_t retval; 2180 if (idetape_copy_stage_from_user(tape, buf, tape->buffer_size)) 2181 ret = -EFAULT; 2182 buf += tape->buffer_size; 2183 count -= tape->buffer_size; 2184 retval = idetape_add_chrdev_write_request(drive, ctl); 2185 actually_written += tape->buffer_size; 2186 if (retval <= 0) 2187 return (retval); 2188 } 2189 if (count) { 2190 actually_written += count; 2191 if (idetape_copy_stage_from_user(tape, buf, count)) 2192 ret = -EFAULT; 2193 tape->merge_stage_size += count; 2194 } 2195 return ret ? ret : actually_written; 2196} 2197 2198static int idetape_write_filemark(ide_drive_t *drive) 2199{ 2200 struct ide_atapi_pc pc; 2201 2202 /* Write a filemark */ 2203 idetape_create_write_filemark_cmd(drive, &pc, 1); 2204 if (idetape_queue_pc_tail(drive, &pc)) { 2205 printk(KERN_ERR "ide-tape: Couldn't write a filemark\n"); 2206 return -EIO; 2207 } 2208 return 0; 2209} 2210 2211/* 2212 * Called from idetape_chrdev_ioctl when the general mtio MTIOCTOP ioctl is 2213 * requested. 2214 * 2215 * Note: MTBSF and MTBSFM are not supported when the tape doesn't support 2216 * spacing over filemarks in the reverse direction. In this case, MTFSFM is also 2217 * usually not supported. 2218 * 2219 * The following commands are currently not supported: 2220 * 2221 * MTFSS, MTBSS, MTWSM, MTSETDENSITY, MTSETDRVBUFFER, MT_ST_BOOLEANS, 2222 * MT_ST_WRITE_THRESHOLD. 2223 */ 2224static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count) 2225{ 2226 idetape_tape_t *tape = drive->driver_data; 2227 struct ide_atapi_pc pc; 2228 int i, retval; 2229 2230 debug_log(DBG_ERR, "Handling MTIOCTOP ioctl: mt_op=%d, mt_count=%d\n", 2231 mt_op, mt_count); 2232 2233 switch (mt_op) { 2234 case MTFSF: 2235 case MTFSFM: 2236 case MTBSF: 2237 case MTBSFM: 2238 if (!mt_count) 2239 return 0; 2240 return idetape_space_over_filemarks(drive, mt_op, mt_count); 2241 default: 2242 break; 2243 } 2244 2245 switch (mt_op) { 2246 case MTWEOF: 2247 if (tape->write_prot) 2248 return -EACCES; 2249 idetape_discard_read_pipeline(drive, 1); 2250 for (i = 0; i < mt_count; i++) { 2251 retval = idetape_write_filemark(drive); 2252 if (retval) 2253 return retval; 2254 } 2255 return 0; 2256 case MTREW: 2257 idetape_discard_read_pipeline(drive, 0); 2258 if (idetape_rewind_tape(drive)) 2259 return -EIO; 2260 return 0; 2261 case MTLOAD: 2262 idetape_discard_read_pipeline(drive, 0); 2263 idetape_create_load_unload_cmd(drive, &pc, 2264 IDETAPE_LU_LOAD_MASK); 2265 return idetape_queue_pc_tail(drive, &pc); 2266 case MTUNLOAD: 2267 case MTOFFL: 2268 /* 2269 * If door is locked, attempt to unlock before 2270 * attempting to eject. 2271 */ 2272 if (tape->door_locked) { 2273 if (idetape_create_prevent_cmd(drive, &pc, 0)) 2274 if (!idetape_queue_pc_tail(drive, &pc)) 2275 tape->door_locked = DOOR_UNLOCKED; 2276 } 2277 idetape_discard_read_pipeline(drive, 0); 2278 idetape_create_load_unload_cmd(drive, &pc, 2279 !IDETAPE_LU_LOAD_MASK); 2280 retval = idetape_queue_pc_tail(drive, &pc); 2281 if (!retval) 2282 clear_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags); 2283 return retval; 2284 case MTNOP: 2285 idetape_discard_read_pipeline(drive, 0); 2286 return idetape_flush_tape_buffers(drive); 2287 case MTRETEN: 2288 idetape_discard_read_pipeline(drive, 0); 2289 idetape_create_load_unload_cmd(drive, &pc, 2290 IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK); 2291 return idetape_queue_pc_tail(drive, &pc); 2292 case MTEOM: 2293 idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD); 2294 return idetape_queue_pc_tail(drive, &pc); 2295 case MTERASE: 2296 (void)idetape_rewind_tape(drive); 2297 idetape_create_erase_cmd(&pc); 2298 return idetape_queue_pc_tail(drive, &pc); 2299 case MTSETBLK: 2300 if (mt_count) { 2301 if (mt_count < tape->blk_size || 2302 mt_count % tape->blk_size) 2303 return -EIO; 2304 tape->user_bs_factor = mt_count / tape->blk_size; 2305 clear_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags); 2306 } else 2307 set_bit(IDETAPE_FLAG_DETECT_BS, &tape->flags); 2308 return 0; 2309 case MTSEEK: 2310 idetape_discard_read_pipeline(drive, 0); 2311 return idetape_position_tape(drive, 2312 mt_count * tape->user_bs_factor, tape->partition, 0); 2313 case MTSETPART: 2314 idetape_discard_read_pipeline(drive, 0); 2315 return idetape_position_tape(drive, 0, mt_count, 0); 2316 case MTFSR: 2317 case MTBSR: 2318 case MTLOCK: 2319 if (!idetape_create_prevent_cmd(drive, &pc, 1)) 2320 return 0; 2321 retval = idetape_queue_pc_tail(drive, &pc); 2322 if (retval) 2323 return retval; 2324 tape->door_locked = DOOR_EXPLICITLY_LOCKED; 2325 return 0; 2326 case MTUNLOCK: 2327 if (!idetape_create_prevent_cmd(drive, &pc, 0)) 2328 return 0; 2329 retval = idetape_queue_pc_tail(drive, &pc); 2330 if (retval) 2331 return retval; 2332 tape->door_locked = DOOR_UNLOCKED; 2333 return 0; 2334 default: 2335 printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n", 2336 mt_op); 2337 return -EIO; 2338 } 2339} 2340 2341/* 2342 * Our character device ioctls. General mtio.h magnetic io commands are 2343 * supported here, and not in the corresponding block interface. Our own 2344 * ide-tape ioctls are supported on both interfaces. 2345 */ 2346static int idetape_chrdev_ioctl(struct inode *inode, struct file *file, 2347 unsigned int cmd, unsigned long arg) 2348{ 2349 struct ide_tape_obj *tape = ide_tape_f(file); 2350 ide_drive_t *drive = tape->drive; 2351 struct mtop mtop; 2352 struct mtget mtget; 2353 struct mtpos mtpos; 2354 int block_offset = 0, position = tape->first_frame; 2355 void __user *argp = (void __user *)arg; 2356 2357 debug_log(DBG_CHRDEV, "Enter %s, cmd=%u\n", __func__, cmd); 2358 2359 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) { 2360 idetape_empty_write_pipeline(drive); 2361 idetape_flush_tape_buffers(drive); 2362 } 2363 if (cmd == MTIOCGET || cmd == MTIOCPOS) { 2364 block_offset = tape->merge_stage_size / 2365 (tape->blk_size * tape->user_bs_factor); 2366 position = idetape_read_position(drive); 2367 if (position < 0) 2368 return -EIO; 2369 } 2370 switch (cmd) { 2371 case MTIOCTOP: 2372 if (copy_from_user(&mtop, argp, sizeof(struct mtop))) 2373 return -EFAULT; 2374 return idetape_mtioctop(drive, mtop.mt_op, mtop.mt_count); 2375 case MTIOCGET: 2376 memset(&mtget, 0, sizeof(struct mtget)); 2377 mtget.mt_type = MT_ISSCSI2; 2378 mtget.mt_blkno = position / tape->user_bs_factor - block_offset; 2379 mtget.mt_dsreg = 2380 ((tape->blk_size * tape->user_bs_factor) 2381 << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK; 2382 2383 if (tape->drv_write_prot) 2384 mtget.mt_gstat |= GMT_WR_PROT(0xffffffff); 2385 2386 if (copy_to_user(argp, &mtget, sizeof(struct mtget))) 2387 return -EFAULT; 2388 return 0; 2389 case MTIOCPOS: 2390 mtpos.mt_blkno = position / tape->user_bs_factor - block_offset; 2391 if (copy_to_user(argp, &mtpos, sizeof(struct mtpos))) 2392 return -EFAULT; 2393 return 0; 2394 default: 2395 if (tape->chrdev_dir == IDETAPE_DIR_READ) 2396 idetape_discard_read_pipeline(drive, 1); 2397 return idetape_blkdev_ioctl(drive, cmd, arg); 2398 } 2399} 2400 2401/* 2402 * Do a mode sense page 0 with block descriptor and if it succeeds set the tape 2403 * block size with the reported value. 2404 */ 2405static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive) 2406{ 2407 idetape_tape_t *tape = drive->driver_data; 2408 struct ide_atapi_pc pc; 2409 2410 idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR); 2411 if (idetape_queue_pc_tail(drive, &pc)) { 2412 printk(KERN_ERR "ide-tape: Can't get block descriptor\n"); 2413 if (tape->blk_size == 0) { 2414 printk(KERN_WARNING "ide-tape: Cannot deal with zero " 2415 "block size, assuming 32k\n"); 2416 tape->blk_size = 32768; 2417 } 2418 return; 2419 } 2420 tape->blk_size = (pc.buf[4 + 5] << 16) + 2421 (pc.buf[4 + 6] << 8) + 2422 pc.buf[4 + 7]; 2423 tape->drv_write_prot = (pc.buf[2] & 0x80) >> 7; 2424} 2425 2426static int idetape_chrdev_open(struct inode *inode, struct file *filp) 2427{ 2428 unsigned int minor = iminor(inode), i = minor & ~0xc0; 2429 ide_drive_t *drive; 2430 idetape_tape_t *tape; 2431 struct ide_atapi_pc pc; 2432 int retval; 2433 2434 if (i >= MAX_HWIFS * MAX_DRIVES) 2435 return -ENXIO; 2436 2437 tape = ide_tape_chrdev_get(i); 2438 if (!tape) 2439 return -ENXIO; 2440 2441 debug_log(DBG_CHRDEV, "Enter %s\n", __func__); 2442 2443 /* 2444 * We really want to do nonseekable_open(inode, filp); here, but some 2445 * versions of tar incorrectly call lseek on tapes and bail out if that 2446 * fails. So we disallow pread() and pwrite(), but permit lseeks. 2447 */ 2448 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE); 2449 2450 drive = tape->drive; 2451 2452 filp->private_data = tape; 2453 2454 if (test_and_set_bit(IDETAPE_FLAG_BUSY, &tape->flags)) { 2455 retval = -EBUSY; 2456 goto out_put_tape; 2457 } 2458 2459 retval = idetape_wait_ready(drive, 60 * HZ); 2460 if (retval) { 2461 clear_bit(IDETAPE_FLAG_BUSY, &tape->flags); 2462 printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name); 2463 goto out_put_tape; 2464 } 2465 2466 idetape_read_position(drive); 2467 if (!test_bit(IDETAPE_FLAG_ADDRESS_VALID, &tape->flags)) 2468 (void)idetape_rewind_tape(drive); 2469 2470 /* Read block size and write protect status from drive. */ 2471 ide_tape_get_bsize_from_bdesc(drive); 2472 2473 /* Set write protect flag if device is opened as read-only. */ 2474 if ((filp->f_flags & O_ACCMODE) == O_RDONLY) 2475 tape->write_prot = 1; 2476 else 2477 tape->write_prot = tape->drv_write_prot; 2478 2479 /* Make sure drive isn't write protected if user wants to write. */ 2480 if (tape->write_prot) { 2481 if ((filp->f_flags & O_ACCMODE) == O_WRONLY || 2482 (filp->f_flags & O_ACCMODE) == O_RDWR) { 2483 clear_bit(IDETAPE_FLAG_BUSY, &tape->flags); 2484 retval = -EROFS; 2485 goto out_put_tape; 2486 } 2487 } 2488 2489 /* Lock the tape drive door so user can't eject. */ 2490 if (tape->chrdev_dir == IDETAPE_DIR_NONE) { 2491 if (idetape_create_prevent_cmd(drive, &pc, 1)) { 2492 if (!idetape_queue_pc_tail(drive, &pc)) { 2493 if (tape->door_locked != DOOR_EXPLICITLY_LOCKED) 2494 tape->door_locked = DOOR_LOCKED; 2495 } 2496 } 2497 } 2498 return 0; 2499 2500out_put_tape: 2501 ide_tape_put(tape); 2502 return retval; 2503} 2504 2505static void idetape_write_release(ide_drive_t *drive, unsigned int minor) 2506{ 2507 idetape_tape_t *tape = drive->driver_data; 2508 2509 idetape_empty_write_pipeline(drive); 2510 tape->merge_stage = ide_tape_kmalloc_buffer(tape, 1, 0); 2511 if (tape->merge_stage != NULL) { 2512 idetape_pad_zeros(drive, tape->blk_size * 2513 (tape->user_bs_factor - 1)); 2514 ide_tape_kfree_buffer(tape->merge_stage); 2515 tape->merge_stage = NULL; 2516 } 2517 idetape_write_filemark(drive); 2518 idetape_flush_tape_buffers(drive); 2519 idetape_flush_tape_buffers(drive); 2520} 2521 2522static int idetape_chrdev_release(struct inode *inode, struct file *filp) 2523{ 2524 struct ide_tape_obj *tape = ide_tape_f(filp); 2525 ide_drive_t *drive = tape->drive; 2526 struct ide_atapi_pc pc; 2527 unsigned int minor = iminor(inode); 2528 2529 lock_kernel(); 2530 tape = drive->driver_data; 2531 2532 debug_log(DBG_CHRDEV, "Enter %s\n", __func__); 2533 2534 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) 2535 idetape_write_release(drive, minor); 2536 if (tape->chrdev_dir == IDETAPE_DIR_READ) { 2537 if (minor < 128) 2538 idetape_discard_read_pipeline(drive, 1); 2539 } 2540 2541 if (minor < 128 && test_bit(IDETAPE_FLAG_MEDIUM_PRESENT, &tape->flags)) 2542 (void) idetape_rewind_tape(drive); 2543 if (tape->chrdev_dir == IDETAPE_DIR_NONE) { 2544 if (tape->door_locked == DOOR_LOCKED) { 2545 if (idetape_create_prevent_cmd(drive, &pc, 0)) { 2546 if (!idetape_queue_pc_tail(drive, &pc)) 2547 tape->door_locked = DOOR_UNLOCKED; 2548 } 2549 } 2550 } 2551 clear_bit(IDETAPE_FLAG_BUSY, &tape->flags); 2552 ide_tape_put(tape); 2553 unlock_kernel(); 2554 return 0; 2555} 2556 2557/* 2558 * check the contents of the ATAPI IDENTIFY command results. We return: 2559 * 2560 * 1 - If the tape can be supported by us, based on the information we have so 2561 * far. 2562 * 2563 * 0 - If this tape driver is not currently supported by us. 2564 */ 2565static int idetape_identify_device(ide_drive_t *drive) 2566{ 2567 u8 gcw[2], protocol, device_type, removable, packet_size; 2568 2569 if (drive->id_read == 0) 2570 return 1; 2571 2572 *((unsigned short *) &gcw) = drive->id->config; 2573 2574 protocol = (gcw[1] & 0xC0) >> 6; 2575 device_type = gcw[1] & 0x1F; 2576 removable = !!(gcw[0] & 0x80); 2577 packet_size = gcw[0] & 0x3; 2578 2579 /* Check that we can support this device */ 2580 if (protocol != 2) 2581 printk(KERN_ERR "ide-tape: Protocol (0x%02x) is not ATAPI\n", 2582 protocol); 2583 else if (device_type != 1) 2584 printk(KERN_ERR "ide-tape: Device type (0x%02x) is not set " 2585 "to tape\n", device_type); 2586 else if (!removable) 2587 printk(KERN_ERR "ide-tape: The removable flag is not set\n"); 2588 else if (packet_size != 0) { 2589 printk(KERN_ERR "ide-tape: Packet size (0x%02x) is not 12" 2590 " bytes\n", packet_size); 2591 } else 2592 return 1; 2593 return 0; 2594} 2595 2596static void idetape_get_inquiry_results(ide_drive_t *drive) 2597{ 2598 idetape_tape_t *tape = drive->driver_data; 2599 struct ide_atapi_pc pc; 2600 char fw_rev[6], vendor_id[10], product_id[18]; 2601 2602 idetape_create_inquiry_cmd(&pc); 2603 if (idetape_queue_pc_tail(drive, &pc)) { 2604 printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n", 2605 tape->name); 2606 return; 2607 } 2608 memcpy(vendor_id, &pc.buf[8], 8); 2609 memcpy(product_id, &pc.buf[16], 16); 2610 memcpy(fw_rev, &pc.buf[32], 4); 2611 2612 ide_fixstring(vendor_id, 10, 0); 2613 ide_fixstring(product_id, 18, 0); 2614 ide_fixstring(fw_rev, 6, 0); 2615 2616 printk(KERN_INFO "ide-tape: %s <-> %s: %s %s rev %s\n", 2617 drive->name, tape->name, vendor_id, product_id, fw_rev); 2618} 2619 2620/* 2621 * Ask the tape about its various parameters. In particular, we will adjust our 2622 * data transfer buffer size to the recommended value as returned by the tape. 2623 */ 2624static void idetape_get_mode_sense_results(ide_drive_t *drive) 2625{ 2626 idetape_tape_t *tape = drive->driver_data; 2627 struct ide_atapi_pc pc; 2628 u8 *caps; 2629 u8 speed, max_speed; 2630 2631 idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE); 2632 if (idetape_queue_pc_tail(drive, &pc)) { 2633 printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming" 2634 " some default values\n"); 2635 tape->blk_size = 512; 2636 put_unaligned(52, (u16 *)&tape->caps[12]); 2637 put_unaligned(540, (u16 *)&tape->caps[14]); 2638 put_unaligned(6*52, (u16 *)&tape->caps[16]); 2639 return; 2640 } 2641 caps = pc.buf + 4 + pc.buf[3]; 2642 2643 /* convert to host order and save for later use */ 2644 speed = be16_to_cpu(*(u16 *)&caps[14]); 2645 max_speed = be16_to_cpu(*(u16 *)&caps[8]); 2646 2647 put_unaligned(max_speed, (u16 *)&caps[8]); 2648 put_unaligned(be16_to_cpu(*(u16 *)&caps[12]), (u16 *)&caps[12]); 2649 put_unaligned(speed, (u16 *)&caps[14]); 2650 put_unaligned(be16_to_cpu(*(u16 *)&caps[16]), (u16 *)&caps[16]); 2651 2652 if (!speed) { 2653 printk(KERN_INFO "ide-tape: %s: invalid tape speed " 2654 "(assuming 650KB/sec)\n", drive->name); 2655 put_unaligned(650, (u16 *)&caps[14]); 2656 } 2657 if (!max_speed) { 2658 printk(KERN_INFO "ide-tape: %s: invalid max_speed " 2659 "(assuming 650KB/sec)\n", drive->name); 2660 put_unaligned(650, (u16 *)&caps[8]); 2661 } 2662 2663 memcpy(&tape->caps, caps, 20); 2664 if (caps[7] & 0x02) 2665 tape->blk_size = 512; 2666 else if (caps[7] & 0x04) 2667 tape->blk_size = 1024; 2668} 2669 2670#ifdef CONFIG_IDE_PROC_FS 2671static void idetape_add_settings(ide_drive_t *drive) 2672{ 2673 idetape_tape_t *tape = drive->driver_data; 2674 2675 ide_add_setting(drive, "buffer", SETTING_READ, TYPE_SHORT, 0, 0xffff, 2676 1, 2, (u16 *)&tape->caps[16], NULL); 2677 ide_add_setting(drive, "speed", SETTING_READ, TYPE_SHORT, 0, 0xffff, 2678 1, 1, (u16 *)&tape->caps[14], NULL); 2679 ide_add_setting(drive, "buffer_size", SETTING_READ, TYPE_INT, 0, 0xffff, 2680 1, 1024, &tape->buffer_size, NULL); 2681 ide_add_setting(drive, "tdsc", SETTING_RW, TYPE_INT, IDETAPE_DSC_RW_MIN, 2682 IDETAPE_DSC_RW_MAX, 1000, HZ, &tape->best_dsc_rw_freq, 2683 NULL); 2684 ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 2685 1, &drive->dsc_overlap, NULL); 2686 ide_add_setting(drive, "avg_speed", SETTING_READ, TYPE_INT, 0, 0xffff, 2687 1, 1, &tape->avg_speed, NULL); 2688 ide_add_setting(drive, "debug_mask", SETTING_RW, TYPE_INT, 0, 0xffff, 1, 2689 1, &tape->debug_mask, NULL); 2690} 2691#else 2692static inline void idetape_add_settings(ide_drive_t *drive) { ; } 2693#endif 2694 2695/* 2696 * The function below is called to: 2697 * 2698 * 1. Initialize our various state variables. 2699 * 2. Ask the tape for its capabilities. 2700 * 3. Allocate a buffer which will be used for data transfer. The buffer size 2701 * is chosen based on the recommendation which we received in step 2. 2702 * 2703 * Note that at this point ide.c already assigned us an irq, so that we can 2704 * queue requests here and wait for their completion. 2705 */ 2706static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor) 2707{ 2708 unsigned long t; 2709 int speed; 2710 int buffer_size; 2711 u8 gcw[2]; 2712 u16 *ctl = (u16 *)&tape->caps[12]; 2713 2714 spin_lock_init(&tape->lock); 2715 drive->dsc_overlap = 1; 2716 if (drive->hwif->host_flags & IDE_HFLAG_NO_DSC) { 2717 printk(KERN_INFO "ide-tape: %s: disabling DSC overlap\n", 2718 tape->name); 2719 drive->dsc_overlap = 0; 2720 } 2721 /* Seagate Travan drives do not support DSC overlap. */ 2722 if (strstr(drive->id->model, "Seagate STT3401")) 2723 drive->dsc_overlap = 0; 2724 tape->minor = minor; 2725 tape->name[0] = 'h'; 2726 tape->name[1] = 't'; 2727 tape->name[2] = '0' + minor; 2728 tape->chrdev_dir = IDETAPE_DIR_NONE; 2729 tape->pc = tape->pc_stack; 2730 *((unsigned short *) &gcw) = drive->id->config; 2731 2732 /* Command packet DRQ type */ 2733 if (((gcw[0] & 0x60) >> 5) == 1) 2734 set_bit(IDETAPE_FLAG_DRQ_INTERRUPT, &tape->flags); 2735 2736 idetape_get_inquiry_results(drive); 2737 idetape_get_mode_sense_results(drive); 2738 ide_tape_get_bsize_from_bdesc(drive); 2739 tape->user_bs_factor = 1; 2740 tape->buffer_size = *ctl * tape->blk_size; 2741 while (tape->buffer_size > 0xffff) { 2742 printk(KERN_NOTICE "ide-tape: decreasing stage size\n"); 2743 *ctl /= 2; 2744 tape->buffer_size = *ctl * tape->blk_size; 2745 } 2746 buffer_size = tape->buffer_size; 2747 tape->pages_per_buffer = buffer_size / PAGE_SIZE; 2748 if (buffer_size % PAGE_SIZE) { 2749 tape->pages_per_buffer++; 2750 tape->excess_bh_size = PAGE_SIZE - buffer_size % PAGE_SIZE; 2751 } 2752 2753 /* select the "best" DSC read/write polling freq */ 2754 speed = max(*(u16 *)&tape->caps[14], *(u16 *)&tape->caps[8]); 2755 2756 t = (IDETAPE_FIFO_THRESHOLD * tape->buffer_size * HZ) / (speed * 1000); 2757 2758 /* 2759 * Ensure that the number we got makes sense; limit it within 2760 * IDETAPE_DSC_RW_MIN and IDETAPE_DSC_RW_MAX. 2761 */ 2762 tape->best_dsc_rw_freq = max_t(unsigned long, 2763 min_t(unsigned long, t, IDETAPE_DSC_RW_MAX), 2764 IDETAPE_DSC_RW_MIN); 2765 printk(KERN_INFO "ide-tape: %s <-> %s: %dKBps, %d*%dkB buffer, " 2766 "%lums tDSC%s\n", 2767 drive->name, tape->name, *(u16 *)&tape->caps[14], 2768 (*(u16 *)&tape->caps[16] * 512) / tape->buffer_size, 2769 tape->buffer_size / 1024, 2770 tape->best_dsc_rw_freq * 1000 / HZ, 2771 drive->using_dma ? ", DMA":""); 2772 2773 idetape_add_settings(drive); 2774} 2775 2776static void ide_tape_remove(ide_drive_t *drive) 2777{ 2778 idetape_tape_t *tape = drive->driver_data; 2779 2780 ide_proc_unregister_driver(drive, tape->driver); 2781 2782 ide_unregister_region(tape->disk); 2783 2784 ide_tape_put(tape); 2785} 2786 2787static void ide_tape_release(struct kref *kref) 2788{ 2789 struct ide_tape_obj *tape = to_ide_tape(kref); 2790 ide_drive_t *drive = tape->drive; 2791 struct gendisk *g = tape->disk; 2792 2793 BUG_ON(tape->merge_stage_size); 2794 2795 drive->dsc_overlap = 0; 2796 drive->driver_data = NULL; 2797 device_destroy(idetape_sysfs_class, MKDEV(IDETAPE_MAJOR, tape->minor)); 2798 device_destroy(idetape_sysfs_class, 2799 MKDEV(IDETAPE_MAJOR, tape->minor + 128)); 2800 idetape_devs[tape->minor] = NULL; 2801 g->private_data = NULL; 2802 put_disk(g); 2803 kfree(tape); 2804} 2805 2806#ifdef CONFIG_IDE_PROC_FS 2807static int proc_idetape_read_name 2808 (char *page, char **start, off_t off, int count, int *eof, void *data) 2809{ 2810 ide_drive_t *drive = (ide_drive_t *) data; 2811 idetape_tape_t *tape = drive->driver_data; 2812 char *out = page; 2813 int len; 2814 2815 len = sprintf(out, "%s\n", tape->name); 2816 PROC_IDE_READ_RETURN(page, start, off, count, eof, len); 2817} 2818 2819static ide_proc_entry_t idetape_proc[] = { 2820 { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL }, 2821 { "name", S_IFREG|S_IRUGO, proc_idetape_read_name, NULL }, 2822 { NULL, 0, NULL, NULL } 2823}; 2824#endif 2825 2826static int ide_tape_probe(ide_drive_t *); 2827 2828static ide_driver_t idetape_driver = { 2829 .gen_driver = { 2830 .owner = THIS_MODULE, 2831 .name = "ide-tape", 2832 .bus = &ide_bus_type, 2833 }, 2834 .probe = ide_tape_probe, 2835 .remove = ide_tape_remove, 2836 .version = IDETAPE_VERSION, 2837 .media = ide_tape, 2838 .supports_dsc_overlap = 1, 2839 .do_request = idetape_do_request, 2840 .end_request = idetape_end_request, 2841 .error = __ide_error, 2842 .abort = __ide_abort, 2843#ifdef CONFIG_IDE_PROC_FS 2844 .proc = idetape_proc, 2845#endif 2846}; 2847 2848/* Our character device supporting functions, passed to register_chrdev. */ 2849static const struct file_operations idetape_fops = { 2850 .owner = THIS_MODULE, 2851 .read = idetape_chrdev_read, 2852 .write = idetape_chrdev_write, 2853 .ioctl = idetape_chrdev_ioctl, 2854 .open = idetape_chrdev_open, 2855 .release = idetape_chrdev_release, 2856}; 2857 2858static int idetape_open(struct inode *inode, struct file *filp) 2859{ 2860 struct gendisk *disk = inode->i_bdev->bd_disk; 2861 struct ide_tape_obj *tape; 2862 2863 tape = ide_tape_get(disk); 2864 if (!tape) 2865 return -ENXIO; 2866 2867 return 0; 2868} 2869 2870static int idetape_release(struct inode *inode, struct file *filp) 2871{ 2872 struct gendisk *disk = inode->i_bdev->bd_disk; 2873 struct ide_tape_obj *tape = ide_tape_g(disk); 2874 2875 ide_tape_put(tape); 2876 2877 return 0; 2878} 2879 2880static int idetape_ioctl(struct inode *inode, struct file *file, 2881 unsigned int cmd, unsigned long arg) 2882{ 2883 struct block_device *bdev = inode->i_bdev; 2884 struct ide_tape_obj *tape = ide_tape_g(bdev->bd_disk); 2885 ide_drive_t *drive = tape->drive; 2886 int err = generic_ide_ioctl(drive, file, bdev, cmd, arg); 2887 if (err == -EINVAL) 2888 err = idetape_blkdev_ioctl(drive, cmd, arg); 2889 return err; 2890} 2891 2892static struct block_device_operations idetape_block_ops = { 2893 .owner = THIS_MODULE, 2894 .open = idetape_open, 2895 .release = idetape_release, 2896 .ioctl = idetape_ioctl, 2897}; 2898 2899static int ide_tape_probe(ide_drive_t *drive) 2900{ 2901 idetape_tape_t *tape; 2902 struct gendisk *g; 2903 int minor; 2904 2905 if (!strstr("ide-tape", drive->driver_req)) 2906 goto failed; 2907 if (!drive->present) 2908 goto failed; 2909 if (drive->media != ide_tape) 2910 goto failed; 2911 if (!idetape_identify_device(drive)) { 2912 printk(KERN_ERR "ide-tape: %s: not supported by this version of" 2913 " the driver\n", drive->name); 2914 goto failed; 2915 } 2916 if (drive->scsi) { 2917 printk(KERN_INFO "ide-tape: passing drive %s to ide-scsi" 2918 " emulation.\n", drive->name); 2919 goto failed; 2920 } 2921 tape = kzalloc(sizeof(idetape_tape_t), GFP_KERNEL); 2922 if (tape == NULL) { 2923 printk(KERN_ERR "ide-tape: %s: Can't allocate a tape struct\n", 2924 drive->name); 2925 goto failed; 2926 } 2927 2928 g = alloc_disk(1 << PARTN_BITS); 2929 if (!g) 2930 goto out_free_tape; 2931 2932 ide_init_disk(g, drive); 2933 2934 ide_proc_register_driver(drive, &idetape_driver); 2935 2936 kref_init(&tape->kref); 2937 2938 tape->drive = drive; 2939 tape->driver = &idetape_driver; 2940 tape->disk = g; 2941 2942 g->private_data = &tape->driver; 2943 2944 drive->driver_data = tape; 2945 2946 mutex_lock(&idetape_ref_mutex); 2947 for (minor = 0; idetape_devs[minor]; minor++) 2948 ; 2949 idetape_devs[minor] = tape; 2950 mutex_unlock(&idetape_ref_mutex); 2951 2952 idetape_setup(drive, tape, minor); 2953 2954 device_create(idetape_sysfs_class, &drive->gendev, 2955 MKDEV(IDETAPE_MAJOR, minor), "%s", tape->name); 2956 device_create(idetape_sysfs_class, &drive->gendev, 2957 MKDEV(IDETAPE_MAJOR, minor + 128), "n%s", tape->name); 2958 2959 g->fops = &idetape_block_ops; 2960 ide_register_region(g); 2961 2962 return 0; 2963 2964out_free_tape: 2965 kfree(tape); 2966failed: 2967 return -ENODEV; 2968} 2969 2970static void __exit idetape_exit(void) 2971{ 2972 driver_unregister(&idetape_driver.gen_driver); 2973 class_destroy(idetape_sysfs_class); 2974 unregister_chrdev(IDETAPE_MAJOR, "ht"); 2975} 2976 2977static int __init idetape_init(void) 2978{ 2979 int error = 1; 2980 idetape_sysfs_class = class_create(THIS_MODULE, "ide_tape"); 2981 if (IS_ERR(idetape_sysfs_class)) { 2982 idetape_sysfs_class = NULL; 2983 printk(KERN_ERR "Unable to create sysfs class for ide tapes\n"); 2984 error = -EBUSY; 2985 goto out; 2986 } 2987 2988 if (register_chrdev(IDETAPE_MAJOR, "ht", &idetape_fops)) { 2989 printk(KERN_ERR "ide-tape: Failed to register chrdev" 2990 " interface\n"); 2991 error = -EBUSY; 2992 goto out_free_class; 2993 } 2994 2995 error = driver_register(&idetape_driver.gen_driver); 2996 if (error) 2997 goto out_free_driver; 2998 2999 return 0; 3000 3001out_free_driver: 3002 driver_unregister(&idetape_driver.gen_driver); 3003out_free_class: 3004 class_destroy(idetape_sysfs_class); 3005out: 3006 return error; 3007} 3008 3009MODULE_ALIAS("ide:*m-tape*"); 3010module_init(idetape_init); 3011module_exit(idetape_exit); 3012MODULE_ALIAS_CHARDEV_MAJOR(IDETAPE_MAJOR); 3013MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver"); 3014MODULE_LICENSE("GPL"); 3015