ide-tape.c revision 97219851b92fd083539003bca48c379d415566ac
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.19" 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 <asm/irq.h> 43#include <asm/uaccess.h> 44#include <asm/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 77/* 78 * Pipelined mode parameters. 79 * 80 * We try to use the minimum number of stages which is enough to 81 * keep the tape constantly streaming. To accomplish that, we implement 82 * a feedback loop around the maximum number of stages: 83 * 84 * We start from MIN maximum stages (we will not even use MIN stages 85 * if we don't need them), increment it by RATE*(MAX-MIN) 86 * whenever we sense that the pipeline is empty, until we reach 87 * the optimum value or until we reach MAX. 88 * 89 * Setting the following parameter to 0 is illegal: the pipelined mode 90 * cannot be disabled (idetape_calculate_speeds() divides by 91 * tape->max_stages.) 92 */ 93#define IDETAPE_MIN_PIPELINE_STAGES 1 94#define IDETAPE_MAX_PIPELINE_STAGES 400 95#define IDETAPE_INCREASE_STAGES_RATE 20 96 97/* 98 * After each failed packet command we issue a request sense command 99 * and retry the packet command IDETAPE_MAX_PC_RETRIES times. 100 * 101 * Setting IDETAPE_MAX_PC_RETRIES to 0 will disable retries. 102 */ 103#define IDETAPE_MAX_PC_RETRIES 3 104 105/* 106 * With each packet command, we allocate a buffer of 107 * IDETAPE_PC_BUFFER_SIZE bytes. This is used for several packet 108 * commands (Not for READ/WRITE commands). 109 */ 110#define IDETAPE_PC_BUFFER_SIZE 256 111 112/* 113 * In various places in the driver, we need to allocate storage 114 * for packet commands and requests, which will remain valid while 115 * we leave the driver to wait for an interrupt or a timeout event. 116 */ 117#define IDETAPE_PC_STACK (10 + IDETAPE_MAX_PC_RETRIES) 118 119/* 120 * Some drives (for example, Seagate STT3401A Travan) require a very long 121 * timeout, because they don't return an interrupt or clear their busy bit 122 * until after the command completes (even retension commands). 123 */ 124#define IDETAPE_WAIT_CMD (900*HZ) 125 126/* 127 * The following parameter is used to select the point in the internal 128 * tape fifo in which we will start to refill the buffer. Decreasing 129 * the following parameter will improve the system's latency and 130 * interactive response, while using a high value might improve system 131 * throughput. 132 */ 133#define IDETAPE_FIFO_THRESHOLD 2 134 135/* 136 * DSC polling parameters. 137 * 138 * Polling for DSC (a single bit in the status register) is a very 139 * important function in ide-tape. There are two cases in which we 140 * poll for DSC: 141 * 142 * 1. Before a read/write packet command, to ensure that we 143 * can transfer data from/to the tape's data buffers, without 144 * causing an actual media access. In case the tape is not 145 * ready yet, we take out our request from the device 146 * request queue, so that ide.c will service requests from 147 * the other device on the same interface meanwhile. 148 * 149 * 2. After the successful initialization of a "media access 150 * packet command", which is a command which can take a long 151 * time to complete (it can be several seconds or even an hour). 152 * 153 * Again, we postpone our request in the middle to free the bus 154 * for the other device. The polling frequency here should be 155 * lower than the read/write frequency since those media access 156 * commands are slow. We start from a "fast" frequency - 157 * IDETAPE_DSC_MA_FAST (one second), and if we don't receive DSC 158 * after IDETAPE_DSC_MA_THRESHOLD (5 minutes), we switch it to a 159 * lower frequency - IDETAPE_DSC_MA_SLOW (1 minute). 160 * 161 * We also set a timeout for the timer, in case something goes wrong. 162 * The timeout should be longer then the maximum execution time of a 163 * tape operation. 164 */ 165 166/* 167 * DSC timings. 168 */ 169#define IDETAPE_DSC_RW_MIN 5*HZ/100 /* 50 msec */ 170#define IDETAPE_DSC_RW_MAX 40*HZ/100 /* 400 msec */ 171#define IDETAPE_DSC_RW_TIMEOUT 2*60*HZ /* 2 minutes */ 172#define IDETAPE_DSC_MA_FAST 2*HZ /* 2 seconds */ 173#define IDETAPE_DSC_MA_THRESHOLD 5*60*HZ /* 5 minutes */ 174#define IDETAPE_DSC_MA_SLOW 30*HZ /* 30 seconds */ 175#define IDETAPE_DSC_MA_TIMEOUT 2*60*60*HZ /* 2 hours */ 176 177/*************************** End of tunable parameters ***********************/ 178 179/* 180 * Read/Write error simulation 181 */ 182#define SIMULATE_ERRORS 0 183 184/* 185 * For general magnetic tape device compatibility. 186 */ 187 188/* tape directions */ 189enum { 190 IDETAPE_DIR_NONE = (1 << 0), 191 IDETAPE_DIR_READ = (1 << 1), 192 IDETAPE_DIR_WRITE = (1 << 2), 193}; 194 195struct idetape_bh { 196 u32 b_size; 197 atomic_t b_count; 198 struct idetape_bh *b_reqnext; 199 char *b_data; 200}; 201 202/* 203 * Our view of a packet command. 204 */ 205typedef struct idetape_packet_command_s { 206 u8 c[12]; /* Actual packet bytes */ 207 int retries; /* On each retry, we increment retries */ 208 int error; /* Error code */ 209 int request_transfer; /* Bytes to transfer */ 210 int actually_transferred; /* Bytes actually transferred */ 211 int buffer_size; /* Size of our data buffer */ 212 struct idetape_bh *bh; 213 char *b_data; 214 int b_count; 215 u8 *buffer; /* Data buffer */ 216 u8 *current_position; /* Pointer into the above buffer */ 217 ide_startstop_t (*callback) (ide_drive_t *); /* Called when this packet command is completed */ 218 u8 pc_buffer[IDETAPE_PC_BUFFER_SIZE]; /* Temporary buffer */ 219 unsigned long flags; /* Status/Action bit flags: long for set_bit */ 220} idetape_pc_t; 221 222/* 223 * Packet command flag bits. 224 */ 225/* Set when an error is considered normal - We won't retry */ 226#define PC_ABORT 0 227/* 1 When polling for DSC on a media access command */ 228#define PC_WAIT_FOR_DSC 1 229/* 1 when we prefer to use DMA if possible */ 230#define PC_DMA_RECOMMENDED 2 231/* 1 while DMA in progress */ 232#define PC_DMA_IN_PROGRESS 3 233/* 1 when encountered problem during DMA */ 234#define PC_DMA_ERROR 4 235/* Data direction */ 236#define PC_WRITING 5 237 238/* 239 * A pipeline stage. 240 */ 241typedef struct idetape_stage_s { 242 struct request rq; /* The corresponding request */ 243 struct idetape_bh *bh; /* The data buffers */ 244 struct idetape_stage_s *next; /* Pointer to the next stage */ 245} idetape_stage_t; 246 247/* 248 * Most of our global data which we need to save even as we leave the 249 * driver due to an interrupt or a timer event is stored in a variable 250 * of type idetape_tape_t, defined below. 251 */ 252typedef struct ide_tape_obj { 253 ide_drive_t *drive; 254 ide_driver_t *driver; 255 struct gendisk *disk; 256 struct kref kref; 257 258 /* 259 * Since a typical character device operation requires more 260 * than one packet command, we provide here enough memory 261 * for the maximum of interconnected packet commands. 262 * The packet commands are stored in the circular array pc_stack. 263 * pc_stack_index points to the last used entry, and warps around 264 * to the start when we get to the last array entry. 265 * 266 * pc points to the current processed packet command. 267 * 268 * failed_pc points to the last failed packet command, or contains 269 * NULL if we do not need to retry any packet command. This is 270 * required since an additional packet command is needed before the 271 * retry, to get detailed information on what went wrong. 272 */ 273 /* Current packet command */ 274 idetape_pc_t *pc; 275 /* Last failed packet command */ 276 idetape_pc_t *failed_pc; 277 /* Packet command stack */ 278 idetape_pc_t pc_stack[IDETAPE_PC_STACK]; 279 /* Next free packet command storage space */ 280 int pc_stack_index; 281 struct request rq_stack[IDETAPE_PC_STACK]; 282 /* We implement a circular array */ 283 int rq_stack_index; 284 285 /* 286 * DSC polling variables. 287 * 288 * While polling for DSC we use postponed_rq to postpone the 289 * current request so that ide.c will be able to service 290 * pending requests on the other device. Note that at most 291 * we will have only one DSC (usually data transfer) request 292 * in the device request queue. Additional requests can be 293 * queued in our internal pipeline, but they will be visible 294 * to ide.c only one at a time. 295 */ 296 struct request *postponed_rq; 297 /* The time in which we started polling for DSC */ 298 unsigned long dsc_polling_start; 299 /* Timer used to poll for dsc */ 300 struct timer_list dsc_timer; 301 /* Read/Write dsc polling frequency */ 302 unsigned long best_dsc_rw_freq; 303 unsigned long dsc_poll_freq; 304 unsigned long dsc_timeout; 305 306 /* 307 * Read position information 308 */ 309 u8 partition; 310 /* Current block */ 311 unsigned int first_frame; 312 313 /* 314 * Last error information 315 */ 316 u8 sense_key, asc, ascq; 317 318 /* 319 * Character device operation 320 */ 321 unsigned int minor; 322 /* device name */ 323 char name[4]; 324 /* Current character device data transfer direction */ 325 u8 chrdev_dir; 326 327 /* tape block size, usually 512 or 1024 bytes */ 328 unsigned short blk_size; 329 int user_bs_factor; 330 331 /* Copy of the tape's Capabilities and Mechanical Page */ 332 u8 caps[20]; 333 334 /* 335 * Active data transfer request parameters. 336 * 337 * At most, there is only one ide-tape originated data transfer 338 * request in the device request queue. This allows ide.c to 339 * easily service requests from the other device when we 340 * postpone our active request. In the pipelined operation 341 * mode, we use our internal pipeline structure to hold 342 * more data requests. 343 * 344 * The data buffer size is chosen based on the tape's 345 * recommendation. 346 */ 347 /* Ptr to the request which is waiting in the device request queue */ 348 struct request *active_data_rq; 349 /* Data buffer size (chosen based on the tape's recommendation */ 350 int stage_size; 351 idetape_stage_t *merge_stage; 352 int merge_stage_size; 353 struct idetape_bh *bh; 354 char *b_data; 355 int b_count; 356 357 /* 358 * Pipeline parameters. 359 * 360 * To accomplish non-pipelined mode, we simply set the following 361 * variables to zero (or NULL, where appropriate). 362 */ 363 /* Number of currently used stages */ 364 int nr_stages; 365 /* Number of pending stages */ 366 int nr_pending_stages; 367 /* We will not allocate more than this number of stages */ 368 int max_stages, min_pipeline, max_pipeline; 369 /* The first stage which will be removed from the pipeline */ 370 idetape_stage_t *first_stage; 371 /* The currently active stage */ 372 idetape_stage_t *active_stage; 373 /* Will be serviced after the currently active request */ 374 idetape_stage_t *next_stage; 375 /* New requests will be added to the pipeline here */ 376 idetape_stage_t *last_stage; 377 /* Optional free stage which we can use */ 378 idetape_stage_t *cache_stage; 379 int pages_per_stage; 380 /* Wasted space in each stage */ 381 int excess_bh_size; 382 383 /* Status/Action flags: long for set_bit */ 384 unsigned long flags; 385 /* protects the ide-tape queue */ 386 spinlock_t lock; 387 388 /* 389 * Measures average tape speed 390 */ 391 unsigned long avg_time; 392 int avg_size; 393 int avg_speed; 394 395 /* the door is currently locked */ 396 int door_locked; 397 /* the tape hardware is write protected */ 398 char drv_write_prot; 399 /* the tape is write protected (hardware or opened as read-only) */ 400 char write_prot; 401 402 /* 403 * Limit the number of times a request can 404 * be postponed, to avoid an infinite postpone 405 * deadlock. 406 */ 407 /* request postpone count limit */ 408 int postpone_cnt; 409 410 /* 411 * Measures number of frames: 412 * 413 * 1. written/read to/from the driver pipeline (pipeline_head). 414 * 2. written/read to/from the tape buffers (idetape_bh). 415 * 3. written/read by the tape to/from the media (tape_head). 416 */ 417 int pipeline_head; 418 int buffer_head; 419 int tape_head; 420 int last_tape_head; 421 422 /* 423 * Speed control at the tape buffers input/output 424 */ 425 unsigned long insert_time; 426 int insert_size; 427 int insert_speed; 428 int max_insert_speed; 429 int measure_insert_time; 430 431 /* 432 * Speed regulation negative feedback loop 433 */ 434 int speed_control; 435 int pipeline_head_speed; 436 int controlled_pipeline_head_speed; 437 int uncontrolled_pipeline_head_speed; 438 int controlled_last_pipeline_head; 439 unsigned long uncontrolled_pipeline_head_time; 440 unsigned long controlled_pipeline_head_time; 441 int controlled_previous_pipeline_head; 442 int uncontrolled_previous_pipeline_head; 443 unsigned long controlled_previous_head_time; 444 unsigned long uncontrolled_previous_head_time; 445 int restart_speed_control_req; 446 447 u32 debug_mask; 448} idetape_tape_t; 449 450static DEFINE_MUTEX(idetape_ref_mutex); 451 452static struct class *idetape_sysfs_class; 453 454#define to_ide_tape(obj) container_of(obj, struct ide_tape_obj, kref) 455 456#define ide_tape_g(disk) \ 457 container_of((disk)->private_data, struct ide_tape_obj, driver) 458 459static struct ide_tape_obj *ide_tape_get(struct gendisk *disk) 460{ 461 struct ide_tape_obj *tape = NULL; 462 463 mutex_lock(&idetape_ref_mutex); 464 tape = ide_tape_g(disk); 465 if (tape) 466 kref_get(&tape->kref); 467 mutex_unlock(&idetape_ref_mutex); 468 return tape; 469} 470 471static void ide_tape_release(struct kref *); 472 473static void ide_tape_put(struct ide_tape_obj *tape) 474{ 475 mutex_lock(&idetape_ref_mutex); 476 kref_put(&tape->kref, ide_tape_release); 477 mutex_unlock(&idetape_ref_mutex); 478} 479 480/* 481 * Tape door status 482 */ 483#define DOOR_UNLOCKED 0 484#define DOOR_LOCKED 1 485#define DOOR_EXPLICITLY_LOCKED 2 486 487/* 488 * Tape flag bits values. 489 */ 490#define IDETAPE_IGNORE_DSC 0 491#define IDETAPE_ADDRESS_VALID 1 /* 0 When the tape position is unknown */ 492#define IDETAPE_BUSY 2 /* Device already opened */ 493#define IDETAPE_PIPELINE_ERROR 3 /* Error detected in a pipeline stage */ 494#define IDETAPE_DETECT_BS 4 /* Attempt to auto-detect the current user block size */ 495#define IDETAPE_FILEMARK 5 /* Currently on a filemark */ 496#define IDETAPE_DRQ_INTERRUPT 6 /* DRQ interrupt device */ 497#define IDETAPE_READ_ERROR 7 498#define IDETAPE_PIPELINE_ACTIVE 8 /* pipeline active */ 499/* 0 = no tape is loaded, so we don't rewind after ejecting */ 500#define IDETAPE_MEDIUM_PRESENT 9 501 502/* 503 * Some defines for the READ BUFFER command 504 */ 505#define IDETAPE_RETRIEVE_FAULTY_BLOCK 6 506 507/* 508 * Some defines for the SPACE command 509 */ 510#define IDETAPE_SPACE_OVER_FILEMARK 1 511#define IDETAPE_SPACE_TO_EOD 3 512 513/* 514 * Some defines for the LOAD UNLOAD command 515 */ 516#define IDETAPE_LU_LOAD_MASK 1 517#define IDETAPE_LU_RETENSION_MASK 2 518#define IDETAPE_LU_EOT_MASK 4 519 520/* 521 * Special requests for our block device strategy routine. 522 * 523 * In order to service a character device command, we add special 524 * requests to the tail of our block device request queue and wait 525 * for their completion. 526 */ 527 528enum { 529 REQ_IDETAPE_PC1 = (1 << 0), /* packet command (first stage) */ 530 REQ_IDETAPE_PC2 = (1 << 1), /* packet command (second stage) */ 531 REQ_IDETAPE_READ = (1 << 2), 532 REQ_IDETAPE_WRITE = (1 << 3), 533 REQ_IDETAPE_READ_BUFFER = (1 << 4), 534}; 535 536/* 537 * Error codes which are returned in rq->errors to the higher part 538 * of the driver. 539 */ 540#define IDETAPE_ERROR_GENERAL 101 541#define IDETAPE_ERROR_FILEMARK 102 542#define IDETAPE_ERROR_EOD 103 543 544/* 545 * The following is used to format the general configuration word of 546 * the ATAPI IDENTIFY DEVICE command. 547 */ 548struct idetape_id_gcw { 549 unsigned packet_size :2; /* Packet Size */ 550 unsigned reserved234 :3; /* Reserved */ 551 unsigned drq_type :2; /* Command packet DRQ type */ 552 unsigned removable :1; /* Removable media */ 553 unsigned device_type :5; /* Device type */ 554 unsigned reserved13 :1; /* Reserved */ 555 unsigned protocol :2; /* Protocol type */ 556}; 557 558/* Structures related to the SELECT SENSE / MODE SENSE packet commands. */ 559#define IDETAPE_BLOCK_DESCRIPTOR 0 560#define IDETAPE_CAPABILITIES_PAGE 0x2a 561 562/* 563 * The variables below are used for the character device interface. 564 * Additional state variables are defined in our ide_drive_t structure. 565 */ 566static struct ide_tape_obj * idetape_devs[MAX_HWIFS * MAX_DRIVES]; 567 568#define ide_tape_f(file) ((file)->private_data) 569 570static struct ide_tape_obj *ide_tape_chrdev_get(unsigned int i) 571{ 572 struct ide_tape_obj *tape = NULL; 573 574 mutex_lock(&idetape_ref_mutex); 575 tape = idetape_devs[i]; 576 if (tape) 577 kref_get(&tape->kref); 578 mutex_unlock(&idetape_ref_mutex); 579 return tape; 580} 581 582/* 583 * Function declarations 584 * 585 */ 586static int idetape_chrdev_release (struct inode *inode, struct file *filp); 587static void idetape_write_release (ide_drive_t *drive, unsigned int minor); 588 589/* 590 * Too bad. The drive wants to send us data which we are not ready to accept. 591 * Just throw it away. 592 */ 593static void idetape_discard_data (ide_drive_t *drive, unsigned int bcount) 594{ 595 while (bcount--) 596 (void) HWIF(drive)->INB(IDE_DATA_REG); 597} 598 599static void idetape_input_buffers (ide_drive_t *drive, idetape_pc_t *pc, unsigned int bcount) 600{ 601 struct idetape_bh *bh = pc->bh; 602 int count; 603 604 while (bcount) { 605 if (bh == NULL) { 606 printk(KERN_ERR "ide-tape: bh == NULL in " 607 "idetape_input_buffers\n"); 608 idetape_discard_data(drive, bcount); 609 return; 610 } 611 count = min((unsigned int)(bh->b_size - atomic_read(&bh->b_count)), bcount); 612 HWIF(drive)->atapi_input_bytes(drive, bh->b_data + atomic_read(&bh->b_count), count); 613 bcount -= count; 614 atomic_add(count, &bh->b_count); 615 if (atomic_read(&bh->b_count) == bh->b_size) { 616 bh = bh->b_reqnext; 617 if (bh) 618 atomic_set(&bh->b_count, 0); 619 } 620 } 621 pc->bh = bh; 622} 623 624static void idetape_output_buffers (ide_drive_t *drive, idetape_pc_t *pc, unsigned int bcount) 625{ 626 struct idetape_bh *bh = pc->bh; 627 int count; 628 629 while (bcount) { 630 if (bh == NULL) { 631 printk(KERN_ERR "ide-tape: bh == NULL in " 632 "idetape_output_buffers\n"); 633 return; 634 } 635 count = min((unsigned int)pc->b_count, (unsigned int)bcount); 636 HWIF(drive)->atapi_output_bytes(drive, pc->b_data, count); 637 bcount -= count; 638 pc->b_data += count; 639 pc->b_count -= count; 640 if (!pc->b_count) { 641 pc->bh = bh = bh->b_reqnext; 642 if (bh) { 643 pc->b_data = bh->b_data; 644 pc->b_count = atomic_read(&bh->b_count); 645 } 646 } 647 } 648} 649 650static void idetape_update_buffers (idetape_pc_t *pc) 651{ 652 struct idetape_bh *bh = pc->bh; 653 int count; 654 unsigned int bcount = pc->actually_transferred; 655 656 if (test_bit(PC_WRITING, &pc->flags)) 657 return; 658 while (bcount) { 659 if (bh == NULL) { 660 printk(KERN_ERR "ide-tape: bh == NULL in " 661 "idetape_update_buffers\n"); 662 return; 663 } 664 count = min((unsigned int)bh->b_size, (unsigned int)bcount); 665 atomic_set(&bh->b_count, count); 666 if (atomic_read(&bh->b_count) == bh->b_size) 667 bh = bh->b_reqnext; 668 bcount -= count; 669 } 670 pc->bh = bh; 671} 672 673/* 674 * idetape_next_pc_storage returns a pointer to a place in which we can 675 * safely store a packet command, even though we intend to leave the 676 * driver. A storage space for a maximum of IDETAPE_PC_STACK packet 677 * commands is allocated at initialization time. 678 */ 679static idetape_pc_t *idetape_next_pc_storage (ide_drive_t *drive) 680{ 681 idetape_tape_t *tape = drive->driver_data; 682 683 debug_log(DBG_PCRQ_STACK, "pc_stack_index=%d\n", tape->pc_stack_index); 684 685 if (tape->pc_stack_index == IDETAPE_PC_STACK) 686 tape->pc_stack_index=0; 687 return (&tape->pc_stack[tape->pc_stack_index++]); 688} 689 690/* 691 * idetape_next_rq_storage is used along with idetape_next_pc_storage. 692 * Since we queue packet commands in the request queue, we need to 693 * allocate a request, along with the allocation of a packet command. 694 */ 695 696/************************************************************** 697 * * 698 * This should get fixed to use kmalloc(.., GFP_ATOMIC) * 699 * followed later on by kfree(). -ml * 700 * * 701 **************************************************************/ 702 703static struct request *idetape_next_rq_storage (ide_drive_t *drive) 704{ 705 idetape_tape_t *tape = drive->driver_data; 706 707 debug_log(DBG_PCRQ_STACK, "rq_stack_index=%d\n", tape->rq_stack_index); 708 709 if (tape->rq_stack_index == IDETAPE_PC_STACK) 710 tape->rq_stack_index=0; 711 return (&tape->rq_stack[tape->rq_stack_index++]); 712} 713 714/* 715 * idetape_init_pc initializes a packet command. 716 */ 717static void idetape_init_pc (idetape_pc_t *pc) 718{ 719 memset(pc->c, 0, 12); 720 pc->retries = 0; 721 pc->flags = 0; 722 pc->request_transfer = 0; 723 pc->buffer = pc->pc_buffer; 724 pc->buffer_size = IDETAPE_PC_BUFFER_SIZE; 725 pc->bh = NULL; 726 pc->b_data = NULL; 727} 728 729/* 730 * called on each failed packet command retry to analyze the request sense. We 731 * currently do not utilize this information. 732 */ 733static void idetape_analyze_error(ide_drive_t *drive, u8 *sense) 734{ 735 idetape_tape_t *tape = drive->driver_data; 736 idetape_pc_t *pc = tape->failed_pc; 737 738 tape->sense_key = sense[2] & 0xF; 739 tape->asc = sense[12]; 740 tape->ascq = sense[13]; 741 742 debug_log(DBG_ERR, "pc = %x, sense key = %x, asc = %x, ascq = %x\n", 743 pc->c[0], tape->sense_key, tape->asc, tape->ascq); 744 745 /* Correct pc->actually_transferred by asking the tape. */ 746 if (test_bit(PC_DMA_ERROR, &pc->flags)) { 747 pc->actually_transferred = pc->request_transfer - 748 tape->blk_size * 749 be32_to_cpu(get_unaligned((u32 *)&sense[3])); 750 idetape_update_buffers(pc); 751 } 752 753 /* 754 * If error was the result of a zero-length read or write command, 755 * with sense key=5, asc=0x22, ascq=0, let it slide. Some drives 756 * (i.e. Seagate STT3401A Travan) don't support 0-length read/writes. 757 */ 758 if ((pc->c[0] == READ_6 || pc->c[0] == WRITE_6) 759 /* length == 0 */ 760 && pc->c[4] == 0 && pc->c[3] == 0 && pc->c[2] == 0) { 761 if (tape->sense_key == 5) { 762 /* don't report an error, everything's ok */ 763 pc->error = 0; 764 /* don't retry read/write */ 765 set_bit(PC_ABORT, &pc->flags); 766 } 767 } 768 if (pc->c[0] == READ_6 && (sense[2] & 0x80)) { 769 pc->error = IDETAPE_ERROR_FILEMARK; 770 set_bit(PC_ABORT, &pc->flags); 771 } 772 if (pc->c[0] == WRITE_6) { 773 if ((sense[2] & 0x40) || (tape->sense_key == 0xd 774 && tape->asc == 0x0 && tape->ascq == 0x2)) { 775 pc->error = IDETAPE_ERROR_EOD; 776 set_bit(PC_ABORT, &pc->flags); 777 } 778 } 779 if (pc->c[0] == READ_6 || pc->c[0] == WRITE_6) { 780 if (tape->sense_key == 8) { 781 pc->error = IDETAPE_ERROR_EOD; 782 set_bit(PC_ABORT, &pc->flags); 783 } 784 if (!test_bit(PC_ABORT, &pc->flags) && 785 pc->actually_transferred) 786 pc->retries = IDETAPE_MAX_PC_RETRIES + 1; 787 } 788} 789 790static void idetape_activate_next_stage(ide_drive_t *drive) 791{ 792 idetape_tape_t *tape = drive->driver_data; 793 idetape_stage_t *stage = tape->next_stage; 794 struct request *rq = &stage->rq; 795 796 debug_log(DBG_PROCS, "Enter %s\n", __func__); 797 798 if (stage == NULL) { 799 printk(KERN_ERR "ide-tape: bug: Trying to activate a non" 800 " existing stage\n"); 801 return; 802 } 803 804 rq->rq_disk = tape->disk; 805 rq->buffer = NULL; 806 rq->special = (void *)stage->bh; 807 tape->active_data_rq = rq; 808 tape->active_stage = stage; 809 tape->next_stage = stage->next; 810} 811 812/* 813 * idetape_kfree_stage calls kfree to completely free a stage, along with 814 * its related buffers. 815 */ 816static void __idetape_kfree_stage (idetape_stage_t *stage) 817{ 818 struct idetape_bh *prev_bh, *bh = stage->bh; 819 int size; 820 821 while (bh != NULL) { 822 if (bh->b_data != NULL) { 823 size = (int) bh->b_size; 824 while (size > 0) { 825 free_page((unsigned long) bh->b_data); 826 size -= PAGE_SIZE; 827 bh->b_data += PAGE_SIZE; 828 } 829 } 830 prev_bh = bh; 831 bh = bh->b_reqnext; 832 kfree(prev_bh); 833 } 834 kfree(stage); 835} 836 837static void idetape_kfree_stage (idetape_tape_t *tape, idetape_stage_t *stage) 838{ 839 __idetape_kfree_stage(stage); 840} 841 842/* 843 * idetape_remove_stage_head removes tape->first_stage from the pipeline. 844 * The caller should avoid race conditions. 845 */ 846static void idetape_remove_stage_head (ide_drive_t *drive) 847{ 848 idetape_tape_t *tape = drive->driver_data; 849 idetape_stage_t *stage; 850 851 debug_log(DBG_PROCS, "Enter %s\n", __func__); 852 853 if (tape->first_stage == NULL) { 854 printk(KERN_ERR "ide-tape: bug: tape->first_stage is NULL\n"); 855 return; 856 } 857 if (tape->active_stage == tape->first_stage) { 858 printk(KERN_ERR "ide-tape: bug: Trying to free our active " 859 "pipeline stage\n"); 860 return; 861 } 862 stage = tape->first_stage; 863 tape->first_stage = stage->next; 864 idetape_kfree_stage(tape, stage); 865 tape->nr_stages--; 866 if (tape->first_stage == NULL) { 867 tape->last_stage = NULL; 868 if (tape->next_stage != NULL) 869 printk(KERN_ERR "ide-tape: bug: tape->next_stage != NULL\n"); 870 if (tape->nr_stages) 871 printk(KERN_ERR "ide-tape: bug: nr_stages should be 0 now\n"); 872 } 873} 874 875/* 876 * This will free all the pipeline stages starting from new_last_stage->next 877 * to the end of the list, and point tape->last_stage to new_last_stage. 878 */ 879static void idetape_abort_pipeline(ide_drive_t *drive, 880 idetape_stage_t *new_last_stage) 881{ 882 idetape_tape_t *tape = drive->driver_data; 883 idetape_stage_t *stage = new_last_stage->next; 884 idetape_stage_t *nstage; 885 886 debug_log(DBG_PROCS, "%s: Enter %s\n", tape->name, __func__); 887 888 while (stage) { 889 nstage = stage->next; 890 idetape_kfree_stage(tape, stage); 891 --tape->nr_stages; 892 --tape->nr_pending_stages; 893 stage = nstage; 894 } 895 if (new_last_stage) 896 new_last_stage->next = NULL; 897 tape->last_stage = new_last_stage; 898 tape->next_stage = NULL; 899} 900 901/* 902 * idetape_end_request is used to finish servicing a request, and to 903 * insert a pending pipeline request into the main device queue. 904 */ 905static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects) 906{ 907 struct request *rq = HWGROUP(drive)->rq; 908 idetape_tape_t *tape = drive->driver_data; 909 unsigned long flags; 910 int error; 911 int remove_stage = 0; 912 idetape_stage_t *active_stage; 913 914 debug_log(DBG_PROCS, "Enter %s\n", __func__); 915 916 switch (uptodate) { 917 case 0: error = IDETAPE_ERROR_GENERAL; break; 918 case 1: error = 0; break; 919 default: error = uptodate; 920 } 921 rq->errors = error; 922 if (error) 923 tape->failed_pc = NULL; 924 925 if (!blk_special_request(rq)) { 926 ide_end_request(drive, uptodate, nr_sects); 927 return 0; 928 } 929 930 spin_lock_irqsave(&tape->lock, flags); 931 932 /* The request was a pipelined data transfer request */ 933 if (tape->active_data_rq == rq) { 934 active_stage = tape->active_stage; 935 tape->active_stage = NULL; 936 tape->active_data_rq = NULL; 937 tape->nr_pending_stages--; 938 if (rq->cmd[0] & REQ_IDETAPE_WRITE) { 939 remove_stage = 1; 940 if (error) { 941 set_bit(IDETAPE_PIPELINE_ERROR, &tape->flags); 942 if (error == IDETAPE_ERROR_EOD) 943 idetape_abort_pipeline(drive, active_stage); 944 } 945 } else if (rq->cmd[0] & REQ_IDETAPE_READ) { 946 if (error == IDETAPE_ERROR_EOD) { 947 set_bit(IDETAPE_PIPELINE_ERROR, &tape->flags); 948 idetape_abort_pipeline(drive, active_stage); 949 } 950 } 951 if (tape->next_stage != NULL) { 952 idetape_activate_next_stage(drive); 953 954 /* 955 * Insert the next request into the request queue. 956 */ 957 (void)ide_do_drive_cmd(drive, tape->active_data_rq, 958 ide_end); 959 } else if (!error) { 960 /* 961 * This is a part of the feedback loop which tries to 962 * find the optimum number of stages. We are starting 963 * from a minimum maximum number of stages, and if we 964 * sense that the pipeline is empty, we try to increase 965 * it, until we reach the user compile time memory 966 * limit. 967 */ 968 int i = (tape->max_pipeline - tape->min_pipeline) / 10; 969 970 tape->max_stages += max(i, 1); 971 tape->max_stages = max(tape->max_stages, 972 tape->min_pipeline); 973 tape->max_stages = min(tape->max_stages, 974 tape->max_pipeline); 975 } 976 } 977 ide_end_drive_cmd(drive, 0, 0); 978// blkdev_dequeue_request(rq); 979// drive->rq = NULL; 980// end_that_request_last(rq); 981 982 if (remove_stage) 983 idetape_remove_stage_head(drive); 984 if (tape->active_data_rq == NULL) 985 clear_bit(IDETAPE_PIPELINE_ACTIVE, &tape->flags); 986 spin_unlock_irqrestore(&tape->lock, flags); 987 return 0; 988} 989 990static ide_startstop_t idetape_request_sense_callback (ide_drive_t *drive) 991{ 992 idetape_tape_t *tape = drive->driver_data; 993 994 debug_log(DBG_PROCS, "Enter %s\n", __func__); 995 996 if (!tape->pc->error) { 997 idetape_analyze_error(drive, tape->pc->buffer); 998 idetape_end_request(drive, 1, 0); 999 } else { 1000 printk(KERN_ERR "ide-tape: Error in REQUEST SENSE itself - Aborting request!\n"); 1001 idetape_end_request(drive, 0, 0); 1002 } 1003 return ide_stopped; 1004} 1005 1006static void idetape_create_request_sense_cmd (idetape_pc_t *pc) 1007{ 1008 idetape_init_pc(pc); 1009 pc->c[0] = REQUEST_SENSE; 1010 pc->c[4] = 20; 1011 pc->request_transfer = 20; 1012 pc->callback = &idetape_request_sense_callback; 1013} 1014 1015static void idetape_init_rq(struct request *rq, u8 cmd) 1016{ 1017 memset(rq, 0, sizeof(*rq)); 1018 rq->cmd_type = REQ_TYPE_SPECIAL; 1019 rq->cmd[0] = cmd; 1020} 1021 1022/* 1023 * idetape_queue_pc_head generates a new packet command request in front 1024 * of the request queue, before the current request, so that it will be 1025 * processed immediately, on the next pass through the driver. 1026 * 1027 * idetape_queue_pc_head is called from the request handling part of 1028 * the driver (the "bottom" part). Safe storage for the request should 1029 * be allocated with idetape_next_pc_storage and idetape_next_rq_storage 1030 * before calling idetape_queue_pc_head. 1031 * 1032 * Memory for those requests is pre-allocated at initialization time, and 1033 * is limited to IDETAPE_PC_STACK requests. We assume that we have enough 1034 * space for the maximum possible number of inter-dependent packet commands. 1035 * 1036 * The higher level of the driver - The ioctl handler and the character 1037 * device handling functions should queue request to the lower level part 1038 * and wait for their completion using idetape_queue_pc_tail or 1039 * idetape_queue_rw_tail. 1040 */ 1041static void idetape_queue_pc_head (ide_drive_t *drive, idetape_pc_t *pc,struct request *rq) 1042{ 1043 struct ide_tape_obj *tape = drive->driver_data; 1044 1045 idetape_init_rq(rq, REQ_IDETAPE_PC1); 1046 rq->buffer = (char *) pc; 1047 rq->rq_disk = tape->disk; 1048 (void) ide_do_drive_cmd(drive, rq, ide_preempt); 1049} 1050 1051/* 1052 * idetape_retry_pc is called when an error was detected during the 1053 * last packet command. We queue a request sense packet command in 1054 * the head of the request list. 1055 */ 1056static ide_startstop_t idetape_retry_pc (ide_drive_t *drive) 1057{ 1058 idetape_tape_t *tape = drive->driver_data; 1059 idetape_pc_t *pc; 1060 struct request *rq; 1061 1062 (void)ide_read_error(drive); 1063 pc = idetape_next_pc_storage(drive); 1064 rq = idetape_next_rq_storage(drive); 1065 idetape_create_request_sense_cmd(pc); 1066 set_bit(IDETAPE_IGNORE_DSC, &tape->flags); 1067 idetape_queue_pc_head(drive, pc, rq); 1068 return ide_stopped; 1069} 1070 1071/* 1072 * idetape_postpone_request postpones the current request so that 1073 * ide.c will be able to service requests from another device on 1074 * the same hwgroup while we are polling for DSC. 1075 */ 1076static void idetape_postpone_request (ide_drive_t *drive) 1077{ 1078 idetape_tape_t *tape = drive->driver_data; 1079 1080 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1081 1082 tape->postponed_rq = HWGROUP(drive)->rq; 1083 ide_stall_queue(drive, tape->dsc_poll_freq); 1084} 1085 1086typedef void idetape_io_buf(ide_drive_t *, idetape_pc_t *, unsigned int); 1087 1088/* 1089 * This is the usual interrupt handler which will be called during a packet 1090 * command. We will transfer some of the data (as requested by the drive) and 1091 * will re-point interrupt handler to us. When data transfer is finished, we 1092 * will act according to the algorithm described before 1093 * idetape_issue_packet_command. 1094 */ 1095static ide_startstop_t idetape_pc_intr(ide_drive_t *drive) 1096{ 1097 ide_hwif_t *hwif = drive->hwif; 1098 idetape_tape_t *tape = drive->driver_data; 1099 idetape_pc_t *pc = tape->pc; 1100 xfer_func_t *xferfunc; 1101 idetape_io_buf *iobuf; 1102 unsigned int temp; 1103#if SIMULATE_ERRORS 1104 static int error_sim_count = 0; 1105#endif 1106 u16 bcount; 1107 u8 stat, ireason; 1108 1109 debug_log(DBG_PROCS, "Enter %s - interrupt handler\n", __func__); 1110 1111 /* Clear the interrupt */ 1112 stat = ide_read_status(drive); 1113 1114 if (test_bit(PC_DMA_IN_PROGRESS, &pc->flags)) { 1115 if (hwif->ide_dma_end(drive) || (stat & ERR_STAT)) { 1116 /* 1117 * A DMA error is sometimes expected. For example, 1118 * if the tape is crossing a filemark during a 1119 * READ command, it will issue an irq and position 1120 * itself before the filemark, so that only a partial 1121 * data transfer will occur (which causes the DMA 1122 * error). In that case, we will later ask the tape 1123 * how much bytes of the original request were 1124 * actually transferred (we can't receive that 1125 * information from the DMA engine on most chipsets). 1126 */ 1127 1128 /* 1129 * On the contrary, a DMA error is never expected; 1130 * it usually indicates a hardware error or abort. 1131 * If the tape crosses a filemark during a READ 1132 * command, it will issue an irq and position itself 1133 * after the filemark (not before). Only a partial 1134 * data transfer will occur, but no DMA error. 1135 * (AS, 19 Apr 2001) 1136 */ 1137 set_bit(PC_DMA_ERROR, &pc->flags); 1138 } else { 1139 pc->actually_transferred = pc->request_transfer; 1140 idetape_update_buffers(pc); 1141 } 1142 debug_log(DBG_PROCS, "DMA finished\n"); 1143 1144 } 1145 1146 /* No more interrupts */ 1147 if ((stat & DRQ_STAT) == 0) { 1148 debug_log(DBG_SENSE, "Packet command completed, %d bytes" 1149 " transferred\n", pc->actually_transferred); 1150 1151 clear_bit(PC_DMA_IN_PROGRESS, &pc->flags); 1152 local_irq_enable(); 1153 1154#if SIMULATE_ERRORS 1155 if ((pc->c[0] == WRITE_6 || pc->c[0] == READ_6) && 1156 (++error_sim_count % 100) == 0) { 1157 printk(KERN_INFO "ide-tape: %s: simulating error\n", 1158 tape->name); 1159 stat |= ERR_STAT; 1160 } 1161#endif 1162 if ((stat & ERR_STAT) && pc->c[0] == REQUEST_SENSE) 1163 stat &= ~ERR_STAT; 1164 if ((stat & ERR_STAT) || test_bit(PC_DMA_ERROR, &pc->flags)) { 1165 /* Error detected */ 1166 debug_log(DBG_ERR, "%s: I/O error\n", tape->name); 1167 1168 if (pc->c[0] == REQUEST_SENSE) { 1169 printk(KERN_ERR "ide-tape: I/O error in request" 1170 " sense command\n"); 1171 return ide_do_reset(drive); 1172 } 1173 debug_log(DBG_ERR, "[cmd %x]: check condition\n", 1174 pc->c[0]); 1175 1176 /* Retry operation */ 1177 return idetape_retry_pc(drive); 1178 } 1179 pc->error = 0; 1180 if (test_bit(PC_WAIT_FOR_DSC, &pc->flags) && 1181 (stat & SEEK_STAT) == 0) { 1182 /* Media access command */ 1183 tape->dsc_polling_start = jiffies; 1184 tape->dsc_poll_freq = IDETAPE_DSC_MA_FAST; 1185 tape->dsc_timeout = jiffies + IDETAPE_DSC_MA_TIMEOUT; 1186 /* Allow ide.c to handle other requests */ 1187 idetape_postpone_request(drive); 1188 return ide_stopped; 1189 } 1190 if (tape->failed_pc == pc) 1191 tape->failed_pc = NULL; 1192 /* Command finished - Call the callback function */ 1193 return pc->callback(drive); 1194 } 1195 if (test_and_clear_bit(PC_DMA_IN_PROGRESS, &pc->flags)) { 1196 printk(KERN_ERR "ide-tape: The tape wants to issue more " 1197 "interrupts in DMA mode\n"); 1198 printk(KERN_ERR "ide-tape: DMA disabled, reverting to PIO\n"); 1199 ide_dma_off(drive); 1200 return ide_do_reset(drive); 1201 } 1202 /* Get the number of bytes to transfer on this interrupt. */ 1203 bcount = (hwif->INB(IDE_BCOUNTH_REG) << 8) | 1204 hwif->INB(IDE_BCOUNTL_REG); 1205 1206 ireason = hwif->INB(IDE_IREASON_REG); 1207 1208 if (ireason & CD) { 1209 printk(KERN_ERR "ide-tape: CoD != 0 in %s\n", __func__); 1210 return ide_do_reset(drive); 1211 } 1212 if (((ireason & IO) == IO) == test_bit(PC_WRITING, &pc->flags)) { 1213 /* Hopefully, we will never get here */ 1214 printk(KERN_ERR "ide-tape: We wanted to %s, ", 1215 (ireason & IO) ? "Write" : "Read"); 1216 printk(KERN_ERR "ide-tape: but the tape wants us to %s !\n", 1217 (ireason & IO) ? "Read" : "Write"); 1218 return ide_do_reset(drive); 1219 } 1220 if (!test_bit(PC_WRITING, &pc->flags)) { 1221 /* Reading - Check that we have enough space */ 1222 temp = pc->actually_transferred + bcount; 1223 if (temp > pc->request_transfer) { 1224 if (temp > pc->buffer_size) { 1225 printk(KERN_ERR "ide-tape: The tape wants to " 1226 "send us more data than expected " 1227 "- discarding data\n"); 1228 idetape_discard_data(drive, bcount); 1229 ide_set_handler(drive, &idetape_pc_intr, 1230 IDETAPE_WAIT_CMD, NULL); 1231 return ide_started; 1232 } 1233 debug_log(DBG_SENSE, "The tape wants to send us more " 1234 "data than expected - allowing transfer\n"); 1235 } 1236 iobuf = &idetape_input_buffers; 1237 xferfunc = hwif->atapi_input_bytes; 1238 } else { 1239 iobuf = &idetape_output_buffers; 1240 xferfunc = hwif->atapi_output_bytes; 1241 } 1242 1243 if (pc->bh) 1244 iobuf(drive, pc, bcount); 1245 else 1246 xferfunc(drive, pc->current_position, bcount); 1247 1248 /* Update the current position */ 1249 pc->actually_transferred += bcount; 1250 pc->current_position += bcount; 1251 1252 debug_log(DBG_SENSE, "[cmd %x] transferred %d bytes on that intr.\n", 1253 pc->c[0], bcount); 1254 1255 /* And set the interrupt handler again */ 1256 ide_set_handler(drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL); 1257 return ide_started; 1258} 1259 1260/* 1261 * Packet Command Interface 1262 * 1263 * The current Packet Command is available in tape->pc, and will not 1264 * change until we finish handling it. Each packet command is associated 1265 * with a callback function that will be called when the command is 1266 * finished. 1267 * 1268 * The handling will be done in three stages: 1269 * 1270 * 1. idetape_issue_packet_command will send the packet command to the 1271 * drive, and will set the interrupt handler to idetape_pc_intr. 1272 * 1273 * 2. On each interrupt, idetape_pc_intr will be called. This step 1274 * will be repeated until the device signals us that no more 1275 * interrupts will be issued. 1276 * 1277 * 3. ATAPI Tape media access commands have immediate status with a 1278 * delayed process. In case of a successful initiation of a 1279 * media access packet command, the DSC bit will be set when the 1280 * actual execution of the command is finished. 1281 * Since the tape drive will not issue an interrupt, we have to 1282 * poll for this event. In this case, we define the request as 1283 * "low priority request" by setting rq_status to 1284 * IDETAPE_RQ_POSTPONED, set a timer to poll for DSC and exit 1285 * the driver. 1286 * 1287 * ide.c will then give higher priority to requests which 1288 * originate from the other device, until will change rq_status 1289 * to RQ_ACTIVE. 1290 * 1291 * 4. When the packet command is finished, it will be checked for errors. 1292 * 1293 * 5. In case an error was found, we queue a request sense packet 1294 * command in front of the request queue and retry the operation 1295 * up to IDETAPE_MAX_PC_RETRIES times. 1296 * 1297 * 6. In case no error was found, or we decided to give up and not 1298 * to retry again, the callback function will be called and then 1299 * we will handle the next request. 1300 * 1301 */ 1302static ide_startstop_t idetape_transfer_pc(ide_drive_t *drive) 1303{ 1304 ide_hwif_t *hwif = drive->hwif; 1305 idetape_tape_t *tape = drive->driver_data; 1306 idetape_pc_t *pc = tape->pc; 1307 int retries = 100; 1308 ide_startstop_t startstop; 1309 u8 ireason; 1310 1311 if (ide_wait_stat(&startstop,drive,DRQ_STAT,BUSY_STAT,WAIT_READY)) { 1312 printk(KERN_ERR "ide-tape: Strange, packet command initiated yet DRQ isn't asserted\n"); 1313 return startstop; 1314 } 1315 ireason = hwif->INB(IDE_IREASON_REG); 1316 while (retries-- && ((ireason & CD) == 0 || (ireason & IO))) { 1317 printk(KERN_ERR "ide-tape: (IO,CoD != (0,1) while issuing " 1318 "a packet command, retrying\n"); 1319 udelay(100); 1320 ireason = hwif->INB(IDE_IREASON_REG); 1321 if (retries == 0) { 1322 printk(KERN_ERR "ide-tape: (IO,CoD != (0,1) while " 1323 "issuing a packet command, ignoring\n"); 1324 ireason |= CD; 1325 ireason &= ~IO; 1326 } 1327 } 1328 if ((ireason & CD) == 0 || (ireason & IO)) { 1329 printk(KERN_ERR "ide-tape: (IO,CoD) != (0,1) while issuing " 1330 "a packet command\n"); 1331 return ide_do_reset(drive); 1332 } 1333 /* Set the interrupt routine */ 1334 ide_set_handler(drive, &idetape_pc_intr, IDETAPE_WAIT_CMD, NULL); 1335#ifdef CONFIG_BLK_DEV_IDEDMA 1336 /* Begin DMA, if necessary */ 1337 if (test_bit(PC_DMA_IN_PROGRESS, &pc->flags)) 1338 hwif->dma_start(drive); 1339#endif 1340 /* Send the actual packet */ 1341 HWIF(drive)->atapi_output_bytes(drive, pc->c, 12); 1342 return ide_started; 1343} 1344 1345static ide_startstop_t idetape_issue_packet_command (ide_drive_t *drive, idetape_pc_t *pc) 1346{ 1347 ide_hwif_t *hwif = drive->hwif; 1348 idetape_tape_t *tape = drive->driver_data; 1349 int dma_ok = 0; 1350 u16 bcount; 1351 1352 if (tape->pc->c[0] == REQUEST_SENSE && 1353 pc->c[0] == REQUEST_SENSE) { 1354 printk(KERN_ERR "ide-tape: possible ide-tape.c bug - " 1355 "Two request sense in serial were issued\n"); 1356 } 1357 1358 if (tape->failed_pc == NULL && pc->c[0] != REQUEST_SENSE) 1359 tape->failed_pc = pc; 1360 /* Set the current packet command */ 1361 tape->pc = pc; 1362 1363 if (pc->retries > IDETAPE_MAX_PC_RETRIES || 1364 test_bit(PC_ABORT, &pc->flags)) { 1365 /* 1366 * We will "abort" retrying a packet command in case 1367 * a legitimate error code was received (crossing a 1368 * filemark, or end of the media, for example). 1369 */ 1370 if (!test_bit(PC_ABORT, &pc->flags)) { 1371 if (!(pc->c[0] == TEST_UNIT_READY && 1372 tape->sense_key == 2 && tape->asc == 4 && 1373 (tape->ascq == 1 || tape->ascq == 8))) { 1374 printk(KERN_ERR "ide-tape: %s: I/O error, " 1375 "pc = %2x, key = %2x, " 1376 "asc = %2x, ascq = %2x\n", 1377 tape->name, pc->c[0], 1378 tape->sense_key, tape->asc, 1379 tape->ascq); 1380 } 1381 /* Giving up */ 1382 pc->error = IDETAPE_ERROR_GENERAL; 1383 } 1384 tape->failed_pc = NULL; 1385 return pc->callback(drive); 1386 } 1387 debug_log(DBG_SENSE, "Retry #%d, cmd = %02X\n", pc->retries, pc->c[0]); 1388 1389 pc->retries++; 1390 /* We haven't transferred any data yet */ 1391 pc->actually_transferred = 0; 1392 pc->current_position = pc->buffer; 1393 /* Request to transfer the entire buffer at once */ 1394 bcount = pc->request_transfer; 1395 1396 if (test_and_clear_bit(PC_DMA_ERROR, &pc->flags)) { 1397 printk(KERN_WARNING "ide-tape: DMA disabled, " 1398 "reverting to PIO\n"); 1399 ide_dma_off(drive); 1400 } 1401 if (test_bit(PC_DMA_RECOMMENDED, &pc->flags) && drive->using_dma) 1402 dma_ok = !hwif->dma_setup(drive); 1403 1404 ide_pktcmd_tf_load(drive, IDE_TFLAG_NO_SELECT_MASK | 1405 IDE_TFLAG_OUT_DEVICE, bcount, dma_ok); 1406 1407 if (dma_ok) /* Will begin DMA later */ 1408 set_bit(PC_DMA_IN_PROGRESS, &pc->flags); 1409 if (test_bit(IDETAPE_DRQ_INTERRUPT, &tape->flags)) { 1410 ide_execute_command(drive, WIN_PACKETCMD, &idetape_transfer_pc, 1411 IDETAPE_WAIT_CMD, NULL); 1412 return ide_started; 1413 } else { 1414 hwif->OUTB(WIN_PACKETCMD, IDE_COMMAND_REG); 1415 return idetape_transfer_pc(drive); 1416 } 1417} 1418 1419/* 1420 * General packet command callback function. 1421 */ 1422static ide_startstop_t idetape_pc_callback (ide_drive_t *drive) 1423{ 1424 idetape_tape_t *tape = drive->driver_data; 1425 1426 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1427 1428 idetape_end_request(drive, tape->pc->error ? 0 : 1, 0); 1429 return ide_stopped; 1430} 1431 1432/* 1433 * A mode sense command is used to "sense" tape parameters. 1434 */ 1435static void idetape_create_mode_sense_cmd (idetape_pc_t *pc, u8 page_code) 1436{ 1437 idetape_init_pc(pc); 1438 pc->c[0] = MODE_SENSE; 1439 if (page_code != IDETAPE_BLOCK_DESCRIPTOR) 1440 pc->c[1] = 8; /* DBD = 1 - Don't return block descriptors */ 1441 pc->c[2] = page_code; 1442 /* 1443 * Changed pc->c[3] to 0 (255 will at best return unused info). 1444 * 1445 * For SCSI this byte is defined as subpage instead of high byte 1446 * of length and some IDE drives seem to interpret it this way 1447 * and return an error when 255 is used. 1448 */ 1449 pc->c[3] = 0; 1450 pc->c[4] = 255; /* (We will just discard data in that case) */ 1451 if (page_code == IDETAPE_BLOCK_DESCRIPTOR) 1452 pc->request_transfer = 12; 1453 else if (page_code == IDETAPE_CAPABILITIES_PAGE) 1454 pc->request_transfer = 24; 1455 else 1456 pc->request_transfer = 50; 1457 pc->callback = &idetape_pc_callback; 1458} 1459 1460static void idetape_calculate_speeds(ide_drive_t *drive) 1461{ 1462 idetape_tape_t *tape = drive->driver_data; 1463 1464 if (time_after(jiffies, tape->controlled_pipeline_head_time + 120 * HZ)) { 1465 tape->controlled_previous_pipeline_head = tape->controlled_last_pipeline_head; 1466 tape->controlled_previous_head_time = tape->controlled_pipeline_head_time; 1467 tape->controlled_last_pipeline_head = tape->pipeline_head; 1468 tape->controlled_pipeline_head_time = jiffies; 1469 } 1470 if (time_after(jiffies, tape->controlled_pipeline_head_time + 60 * HZ)) 1471 tape->controlled_pipeline_head_speed = (tape->pipeline_head - tape->controlled_last_pipeline_head) * 32 * HZ / (jiffies - tape->controlled_pipeline_head_time); 1472 else if (time_after(jiffies, tape->controlled_previous_head_time)) 1473 tape->controlled_pipeline_head_speed = (tape->pipeline_head - tape->controlled_previous_pipeline_head) * 32 * HZ / (jiffies - tape->controlled_previous_head_time); 1474 1475 if (tape->nr_pending_stages < tape->max_stages /*- 1 */) { 1476 /* -1 for read mode error recovery */ 1477 if (time_after(jiffies, tape->uncontrolled_previous_head_time + 10 * HZ)) { 1478 tape->uncontrolled_pipeline_head_time = jiffies; 1479 tape->uncontrolled_pipeline_head_speed = (tape->pipeline_head - tape->uncontrolled_previous_pipeline_head) * 32 * HZ / (jiffies - tape->uncontrolled_previous_head_time); 1480 } 1481 } else { 1482 tape->uncontrolled_previous_head_time = jiffies; 1483 tape->uncontrolled_previous_pipeline_head = tape->pipeline_head; 1484 if (time_after(jiffies, tape->uncontrolled_pipeline_head_time + 30 * HZ)) { 1485 tape->uncontrolled_pipeline_head_time = jiffies; 1486 } 1487 } 1488 tape->pipeline_head_speed = max(tape->uncontrolled_pipeline_head_speed, tape->controlled_pipeline_head_speed); 1489 1490 if (tape->speed_control == 1) { 1491 if (tape->nr_pending_stages >= tape->max_stages / 2) 1492 tape->max_insert_speed = tape->pipeline_head_speed + 1493 (1100 - tape->pipeline_head_speed) * 2 * (tape->nr_pending_stages - tape->max_stages / 2) / tape->max_stages; 1494 else 1495 tape->max_insert_speed = 500 + 1496 (tape->pipeline_head_speed - 500) * 2 * tape->nr_pending_stages / tape->max_stages; 1497 1498 if (tape->nr_pending_stages >= tape->max_stages * 99 / 100) 1499 tape->max_insert_speed = 5000; 1500 } else 1501 tape->max_insert_speed = tape->speed_control; 1502 1503 tape->max_insert_speed = max(tape->max_insert_speed, 500); 1504} 1505 1506static ide_startstop_t idetape_media_access_finished (ide_drive_t *drive) 1507{ 1508 idetape_tape_t *tape = drive->driver_data; 1509 idetape_pc_t *pc = tape->pc; 1510 u8 stat; 1511 1512 stat = ide_read_status(drive); 1513 1514 if (stat & SEEK_STAT) { 1515 if (stat & ERR_STAT) { 1516 /* Error detected */ 1517 if (pc->c[0] != TEST_UNIT_READY) 1518 printk(KERN_ERR "ide-tape: %s: I/O error, ", 1519 tape->name); 1520 /* Retry operation */ 1521 return idetape_retry_pc(drive); 1522 } 1523 pc->error = 0; 1524 if (tape->failed_pc == pc) 1525 tape->failed_pc = NULL; 1526 } else { 1527 pc->error = IDETAPE_ERROR_GENERAL; 1528 tape->failed_pc = NULL; 1529 } 1530 return pc->callback(drive); 1531} 1532 1533static ide_startstop_t idetape_rw_callback (ide_drive_t *drive) 1534{ 1535 idetape_tape_t *tape = drive->driver_data; 1536 struct request *rq = HWGROUP(drive)->rq; 1537 int blocks = tape->pc->actually_transferred / tape->blk_size; 1538 1539 tape->avg_size += blocks * tape->blk_size; 1540 tape->insert_size += blocks * tape->blk_size; 1541 if (tape->insert_size > 1024 * 1024) 1542 tape->measure_insert_time = 1; 1543 if (tape->measure_insert_time) { 1544 tape->measure_insert_time = 0; 1545 tape->insert_time = jiffies; 1546 tape->insert_size = 0; 1547 } 1548 if (time_after(jiffies, tape->insert_time)) 1549 tape->insert_speed = tape->insert_size / 1024 * HZ / (jiffies - tape->insert_time); 1550 if (time_after_eq(jiffies, tape->avg_time + HZ)) { 1551 tape->avg_speed = tape->avg_size * HZ / (jiffies - tape->avg_time) / 1024; 1552 tape->avg_size = 0; 1553 tape->avg_time = jiffies; 1554 } 1555 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1556 1557 tape->first_frame += blocks; 1558 rq->current_nr_sectors -= blocks; 1559 1560 if (!tape->pc->error) 1561 idetape_end_request(drive, 1, 0); 1562 else 1563 idetape_end_request(drive, tape->pc->error, 0); 1564 return ide_stopped; 1565} 1566 1567static void idetape_create_read_cmd(idetape_tape_t *tape, idetape_pc_t *pc, unsigned int length, struct idetape_bh *bh) 1568{ 1569 idetape_init_pc(pc); 1570 pc->c[0] = READ_6; 1571 put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); 1572 pc->c[1] = 1; 1573 pc->callback = &idetape_rw_callback; 1574 pc->bh = bh; 1575 atomic_set(&bh->b_count, 0); 1576 pc->buffer = NULL; 1577 pc->buffer_size = length * tape->blk_size; 1578 pc->request_transfer = pc->buffer_size; 1579 if (pc->request_transfer == tape->stage_size) 1580 set_bit(PC_DMA_RECOMMENDED, &pc->flags); 1581} 1582 1583static void idetape_create_read_buffer_cmd(idetape_tape_t *tape, idetape_pc_t *pc, unsigned int length, struct idetape_bh *bh) 1584{ 1585 int size = 32768; 1586 struct idetape_bh *p = bh; 1587 1588 idetape_init_pc(pc); 1589 pc->c[0] = READ_BUFFER; 1590 pc->c[1] = IDETAPE_RETRIEVE_FAULTY_BLOCK; 1591 pc->c[7] = size >> 8; 1592 pc->c[8] = size & 0xff; 1593 pc->callback = &idetape_pc_callback; 1594 pc->bh = bh; 1595 atomic_set(&bh->b_count, 0); 1596 pc->buffer = NULL; 1597 while (p) { 1598 atomic_set(&p->b_count, 0); 1599 p = p->b_reqnext; 1600 } 1601 pc->request_transfer = pc->buffer_size = size; 1602} 1603 1604static void idetape_create_write_cmd(idetape_tape_t *tape, idetape_pc_t *pc, unsigned int length, struct idetape_bh *bh) 1605{ 1606 idetape_init_pc(pc); 1607 pc->c[0] = WRITE_6; 1608 put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]); 1609 pc->c[1] = 1; 1610 pc->callback = &idetape_rw_callback; 1611 set_bit(PC_WRITING, &pc->flags); 1612 pc->bh = bh; 1613 pc->b_data = bh->b_data; 1614 pc->b_count = atomic_read(&bh->b_count); 1615 pc->buffer = NULL; 1616 pc->buffer_size = length * tape->blk_size; 1617 pc->request_transfer = pc->buffer_size; 1618 if (pc->request_transfer == tape->stage_size) 1619 set_bit(PC_DMA_RECOMMENDED, &pc->flags); 1620} 1621 1622/* 1623 * idetape_do_request is our request handling function. 1624 */ 1625static ide_startstop_t idetape_do_request(ide_drive_t *drive, 1626 struct request *rq, sector_t block) 1627{ 1628 idetape_tape_t *tape = drive->driver_data; 1629 idetape_pc_t *pc = NULL; 1630 struct request *postponed_rq = tape->postponed_rq; 1631 u8 stat; 1632 1633 debug_log(DBG_SENSE, "sector: %ld, nr_sectors: %ld," 1634 " current_nr_sectors: %d\n", 1635 rq->sector, rq->nr_sectors, rq->current_nr_sectors); 1636 1637 if (!blk_special_request(rq)) { 1638 /* 1639 * We do not support buffer cache originated requests. 1640 */ 1641 printk(KERN_NOTICE "ide-tape: %s: Unsupported request in " 1642 "request queue (%d)\n", drive->name, rq->cmd_type); 1643 ide_end_request(drive, 0, 0); 1644 return ide_stopped; 1645 } 1646 1647 /* 1648 * Retry a failed packet command 1649 */ 1650 if (tape->failed_pc != NULL && 1651 tape->pc->c[0] == REQUEST_SENSE) { 1652 return idetape_issue_packet_command(drive, tape->failed_pc); 1653 } 1654 if (postponed_rq != NULL) 1655 if (rq != postponed_rq) { 1656 printk(KERN_ERR "ide-tape: ide-tape.c bug - " 1657 "Two DSC requests were queued\n"); 1658 idetape_end_request(drive, 0, 0); 1659 return ide_stopped; 1660 } 1661 1662 tape->postponed_rq = NULL; 1663 1664 /* 1665 * If the tape is still busy, postpone our request and service 1666 * the other device meanwhile. 1667 */ 1668 stat = ide_read_status(drive); 1669 1670 if (!drive->dsc_overlap && !(rq->cmd[0] & REQ_IDETAPE_PC2)) 1671 set_bit(IDETAPE_IGNORE_DSC, &tape->flags); 1672 1673 if (drive->post_reset == 1) { 1674 set_bit(IDETAPE_IGNORE_DSC, &tape->flags); 1675 drive->post_reset = 0; 1676 } 1677 1678 if (time_after(jiffies, tape->insert_time)) 1679 tape->insert_speed = tape->insert_size / 1024 * HZ / (jiffies - tape->insert_time); 1680 idetape_calculate_speeds(drive); 1681 if (!test_and_clear_bit(IDETAPE_IGNORE_DSC, &tape->flags) && 1682 (stat & SEEK_STAT) == 0) { 1683 if (postponed_rq == NULL) { 1684 tape->dsc_polling_start = jiffies; 1685 tape->dsc_poll_freq = tape->best_dsc_rw_freq; 1686 tape->dsc_timeout = jiffies + IDETAPE_DSC_RW_TIMEOUT; 1687 } else if (time_after(jiffies, tape->dsc_timeout)) { 1688 printk(KERN_ERR "ide-tape: %s: DSC timeout\n", 1689 tape->name); 1690 if (rq->cmd[0] & REQ_IDETAPE_PC2) { 1691 idetape_media_access_finished(drive); 1692 return ide_stopped; 1693 } else { 1694 return ide_do_reset(drive); 1695 } 1696 } else if (time_after(jiffies, tape->dsc_polling_start + IDETAPE_DSC_MA_THRESHOLD)) 1697 tape->dsc_poll_freq = IDETAPE_DSC_MA_SLOW; 1698 idetape_postpone_request(drive); 1699 return ide_stopped; 1700 } 1701 if (rq->cmd[0] & REQ_IDETAPE_READ) { 1702 tape->buffer_head++; 1703 tape->postpone_cnt = 0; 1704 pc = idetape_next_pc_storage(drive); 1705 idetape_create_read_cmd(tape, pc, rq->current_nr_sectors, (struct idetape_bh *)rq->special); 1706 goto out; 1707 } 1708 if (rq->cmd[0] & REQ_IDETAPE_WRITE) { 1709 tape->buffer_head++; 1710 tape->postpone_cnt = 0; 1711 pc = idetape_next_pc_storage(drive); 1712 idetape_create_write_cmd(tape, pc, rq->current_nr_sectors, (struct idetape_bh *)rq->special); 1713 goto out; 1714 } 1715 if (rq->cmd[0] & REQ_IDETAPE_READ_BUFFER) { 1716 tape->postpone_cnt = 0; 1717 pc = idetape_next_pc_storage(drive); 1718 idetape_create_read_buffer_cmd(tape, pc, rq->current_nr_sectors, (struct idetape_bh *)rq->special); 1719 goto out; 1720 } 1721 if (rq->cmd[0] & REQ_IDETAPE_PC1) { 1722 pc = (idetape_pc_t *) rq->buffer; 1723 rq->cmd[0] &= ~(REQ_IDETAPE_PC1); 1724 rq->cmd[0] |= REQ_IDETAPE_PC2; 1725 goto out; 1726 } 1727 if (rq->cmd[0] & REQ_IDETAPE_PC2) { 1728 idetape_media_access_finished(drive); 1729 return ide_stopped; 1730 } 1731 BUG(); 1732out: 1733 return idetape_issue_packet_command(drive, pc); 1734} 1735 1736/* 1737 * Pipeline related functions 1738 */ 1739static inline int idetape_pipeline_active (idetape_tape_t *tape) 1740{ 1741 int rc1, rc2; 1742 1743 rc1 = test_bit(IDETAPE_PIPELINE_ACTIVE, &tape->flags); 1744 rc2 = (tape->active_data_rq != NULL); 1745 return rc1; 1746} 1747 1748/* 1749 * idetape_kmalloc_stage uses __get_free_page to allocate a pipeline 1750 * stage, along with all the necessary small buffers which together make 1751 * a buffer of size tape->stage_size (or a bit more). We attempt to 1752 * combine sequential pages as much as possible. 1753 * 1754 * Returns a pointer to the new allocated stage, or NULL if we 1755 * can't (or don't want to) allocate a stage. 1756 * 1757 * Pipeline stages are optional and are used to increase performance. 1758 * If we can't allocate them, we'll manage without them. 1759 */ 1760static idetape_stage_t *__idetape_kmalloc_stage (idetape_tape_t *tape, int full, int clear) 1761{ 1762 idetape_stage_t *stage; 1763 struct idetape_bh *prev_bh, *bh; 1764 int pages = tape->pages_per_stage; 1765 char *b_data = NULL; 1766 1767 if ((stage = kmalloc(sizeof (idetape_stage_t),GFP_KERNEL)) == NULL) 1768 return NULL; 1769 stage->next = NULL; 1770 1771 bh = stage->bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL); 1772 if (bh == NULL) 1773 goto abort; 1774 bh->b_reqnext = NULL; 1775 if ((bh->b_data = (char *) __get_free_page (GFP_KERNEL)) == NULL) 1776 goto abort; 1777 if (clear) 1778 memset(bh->b_data, 0, PAGE_SIZE); 1779 bh->b_size = PAGE_SIZE; 1780 atomic_set(&bh->b_count, full ? bh->b_size : 0); 1781 1782 while (--pages) { 1783 if ((b_data = (char *) __get_free_page (GFP_KERNEL)) == NULL) 1784 goto abort; 1785 if (clear) 1786 memset(b_data, 0, PAGE_SIZE); 1787 if (bh->b_data == b_data + PAGE_SIZE) { 1788 bh->b_size += PAGE_SIZE; 1789 bh->b_data -= PAGE_SIZE; 1790 if (full) 1791 atomic_add(PAGE_SIZE, &bh->b_count); 1792 continue; 1793 } 1794 if (b_data == bh->b_data + bh->b_size) { 1795 bh->b_size += PAGE_SIZE; 1796 if (full) 1797 atomic_add(PAGE_SIZE, &bh->b_count); 1798 continue; 1799 } 1800 prev_bh = bh; 1801 if ((bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL)) == NULL) { 1802 free_page((unsigned long) b_data); 1803 goto abort; 1804 } 1805 bh->b_reqnext = NULL; 1806 bh->b_data = b_data; 1807 bh->b_size = PAGE_SIZE; 1808 atomic_set(&bh->b_count, full ? bh->b_size : 0); 1809 prev_bh->b_reqnext = bh; 1810 } 1811 bh->b_size -= tape->excess_bh_size; 1812 if (full) 1813 atomic_sub(tape->excess_bh_size, &bh->b_count); 1814 return stage; 1815abort: 1816 __idetape_kfree_stage(stage); 1817 return NULL; 1818} 1819 1820static idetape_stage_t *idetape_kmalloc_stage (idetape_tape_t *tape) 1821{ 1822 idetape_stage_t *cache_stage = tape->cache_stage; 1823 1824 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1825 1826 if (tape->nr_stages >= tape->max_stages) 1827 return NULL; 1828 if (cache_stage != NULL) { 1829 tape->cache_stage = NULL; 1830 return cache_stage; 1831 } 1832 return __idetape_kmalloc_stage(tape, 0, 0); 1833} 1834 1835static int idetape_copy_stage_from_user (idetape_tape_t *tape, idetape_stage_t *stage, const char __user *buf, int n) 1836{ 1837 struct idetape_bh *bh = tape->bh; 1838 int count; 1839 int ret = 0; 1840 1841 while (n) { 1842 if (bh == NULL) { 1843 printk(KERN_ERR "ide-tape: bh == NULL in " 1844 "idetape_copy_stage_from_user\n"); 1845 return 1; 1846 } 1847 count = min((unsigned int)(bh->b_size - atomic_read(&bh->b_count)), (unsigned int)n); 1848 if (copy_from_user(bh->b_data + atomic_read(&bh->b_count), buf, count)) 1849 ret = 1; 1850 n -= count; 1851 atomic_add(count, &bh->b_count); 1852 buf += count; 1853 if (atomic_read(&bh->b_count) == bh->b_size) { 1854 bh = bh->b_reqnext; 1855 if (bh) 1856 atomic_set(&bh->b_count, 0); 1857 } 1858 } 1859 tape->bh = bh; 1860 return ret; 1861} 1862 1863static int idetape_copy_stage_to_user (idetape_tape_t *tape, char __user *buf, idetape_stage_t *stage, int n) 1864{ 1865 struct idetape_bh *bh = tape->bh; 1866 int count; 1867 int ret = 0; 1868 1869 while (n) { 1870 if (bh == NULL) { 1871 printk(KERN_ERR "ide-tape: bh == NULL in " 1872 "idetape_copy_stage_to_user\n"); 1873 return 1; 1874 } 1875 count = min(tape->b_count, n); 1876 if (copy_to_user(buf, tape->b_data, count)) 1877 ret = 1; 1878 n -= count; 1879 tape->b_data += count; 1880 tape->b_count -= count; 1881 buf += count; 1882 if (!tape->b_count) { 1883 tape->bh = bh = bh->b_reqnext; 1884 if (bh) { 1885 tape->b_data = bh->b_data; 1886 tape->b_count = atomic_read(&bh->b_count); 1887 } 1888 } 1889 } 1890 return ret; 1891} 1892 1893static void idetape_init_merge_stage (idetape_tape_t *tape) 1894{ 1895 struct idetape_bh *bh = tape->merge_stage->bh; 1896 1897 tape->bh = bh; 1898 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) 1899 atomic_set(&bh->b_count, 0); 1900 else { 1901 tape->b_data = bh->b_data; 1902 tape->b_count = atomic_read(&bh->b_count); 1903 } 1904} 1905 1906static void idetape_switch_buffers (idetape_tape_t *tape, idetape_stage_t *stage) 1907{ 1908 struct idetape_bh *tmp; 1909 1910 tmp = stage->bh; 1911 stage->bh = tape->merge_stage->bh; 1912 tape->merge_stage->bh = tmp; 1913 idetape_init_merge_stage(tape); 1914} 1915 1916/* 1917 * idetape_add_stage_tail adds a new stage at the end of the pipeline. 1918 */ 1919static void idetape_add_stage_tail (ide_drive_t *drive,idetape_stage_t *stage) 1920{ 1921 idetape_tape_t *tape = drive->driver_data; 1922 unsigned long flags; 1923 1924 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1925 1926 spin_lock_irqsave(&tape->lock, flags); 1927 stage->next = NULL; 1928 if (tape->last_stage != NULL) 1929 tape->last_stage->next=stage; 1930 else 1931 tape->first_stage = tape->next_stage=stage; 1932 tape->last_stage = stage; 1933 if (tape->next_stage == NULL) 1934 tape->next_stage = tape->last_stage; 1935 tape->nr_stages++; 1936 tape->nr_pending_stages++; 1937 spin_unlock_irqrestore(&tape->lock, flags); 1938} 1939 1940/* 1941 * idetape_wait_for_request installs a completion in a pending request 1942 * and sleeps until it is serviced. 1943 * 1944 * The caller should ensure that the request will not be serviced 1945 * before we install the completion (usually by disabling interrupts). 1946 */ 1947static void idetape_wait_for_request (ide_drive_t *drive, struct request *rq) 1948{ 1949 DECLARE_COMPLETION_ONSTACK(wait); 1950 idetape_tape_t *tape = drive->driver_data; 1951 1952 if (rq == NULL || !blk_special_request(rq)) { 1953 printk (KERN_ERR "ide-tape: bug: Trying to sleep on non-valid request\n"); 1954 return; 1955 } 1956 rq->end_io_data = &wait; 1957 rq->end_io = blk_end_sync_rq; 1958 spin_unlock_irq(&tape->lock); 1959 wait_for_completion(&wait); 1960 /* The stage and its struct request have been deallocated */ 1961 spin_lock_irq(&tape->lock); 1962} 1963 1964static ide_startstop_t idetape_read_position_callback(ide_drive_t *drive) 1965{ 1966 idetape_tape_t *tape = drive->driver_data; 1967 u8 *readpos = tape->pc->buffer; 1968 1969 debug_log(DBG_PROCS, "Enter %s\n", __func__); 1970 1971 if (!tape->pc->error) { 1972 debug_log(DBG_SENSE, "BOP - %s\n", 1973 (readpos[0] & 0x80) ? "Yes" : "No"); 1974 debug_log(DBG_SENSE, "EOP - %s\n", 1975 (readpos[0] & 0x40) ? "Yes" : "No"); 1976 1977 if (readpos[0] & 0x4) { 1978 printk(KERN_INFO "ide-tape: Block location is unknown" 1979 "to the tape\n"); 1980 clear_bit(IDETAPE_ADDRESS_VALID, &tape->flags); 1981 idetape_end_request(drive, 0, 0); 1982 } else { 1983 debug_log(DBG_SENSE, "Block Location - %u\n", 1984 be32_to_cpu(*(u32 *)&readpos[4])); 1985 1986 tape->partition = readpos[1]; 1987 tape->first_frame = 1988 be32_to_cpu(*(u32 *)&readpos[4]); 1989 set_bit(IDETAPE_ADDRESS_VALID, &tape->flags); 1990 idetape_end_request(drive, 1, 0); 1991 } 1992 } else { 1993 idetape_end_request(drive, 0, 0); 1994 } 1995 return ide_stopped; 1996} 1997 1998/* 1999 * idetape_create_write_filemark_cmd will: 2000 * 2001 * 1. Write a filemark if write_filemark=1. 2002 * 2. Flush the device buffers without writing a filemark 2003 * if write_filemark=0. 2004 * 2005 */ 2006static void idetape_create_write_filemark_cmd (ide_drive_t *drive, idetape_pc_t *pc,int write_filemark) 2007{ 2008 idetape_init_pc(pc); 2009 pc->c[0] = WRITE_FILEMARKS; 2010 pc->c[4] = write_filemark; 2011 set_bit(PC_WAIT_FOR_DSC, &pc->flags); 2012 pc->callback = &idetape_pc_callback; 2013} 2014 2015static void idetape_create_test_unit_ready_cmd(idetape_pc_t *pc) 2016{ 2017 idetape_init_pc(pc); 2018 pc->c[0] = TEST_UNIT_READY; 2019 pc->callback = &idetape_pc_callback; 2020} 2021 2022/* 2023 * idetape_queue_pc_tail is based on the following functions: 2024 * 2025 * ide_do_drive_cmd from ide.c 2026 * cdrom_queue_request and cdrom_queue_packet_command from ide-cd.c 2027 * 2028 * We add a special packet command request to the tail of the request 2029 * queue, and wait for it to be serviced. 2030 * 2031 * This is not to be called from within the request handling part 2032 * of the driver ! We allocate here data in the stack, and it is valid 2033 * until the request is finished. This is not the case for the bottom 2034 * part of the driver, where we are always leaving the functions to wait 2035 * for an interrupt or a timer event. 2036 * 2037 * From the bottom part of the driver, we should allocate safe memory 2038 * using idetape_next_pc_storage and idetape_next_rq_storage, and add 2039 * the request to the request list without waiting for it to be serviced ! 2040 * In that case, we usually use idetape_queue_pc_head. 2041 */ 2042static int __idetape_queue_pc_tail (ide_drive_t *drive, idetape_pc_t *pc) 2043{ 2044 struct ide_tape_obj *tape = drive->driver_data; 2045 struct request rq; 2046 2047 idetape_init_rq(&rq, REQ_IDETAPE_PC1); 2048 rq.buffer = (char *) pc; 2049 rq.rq_disk = tape->disk; 2050 return ide_do_drive_cmd(drive, &rq, ide_wait); 2051} 2052 2053static void idetape_create_load_unload_cmd (ide_drive_t *drive, idetape_pc_t *pc,int cmd) 2054{ 2055 idetape_init_pc(pc); 2056 pc->c[0] = START_STOP; 2057 pc->c[4] = cmd; 2058 set_bit(PC_WAIT_FOR_DSC, &pc->flags); 2059 pc->callback = &idetape_pc_callback; 2060} 2061 2062static int idetape_wait_ready(ide_drive_t *drive, unsigned long timeout) 2063{ 2064 idetape_tape_t *tape = drive->driver_data; 2065 idetape_pc_t pc; 2066 int load_attempted = 0; 2067 2068 /* 2069 * Wait for the tape to become ready 2070 */ 2071 set_bit(IDETAPE_MEDIUM_PRESENT, &tape->flags); 2072 timeout += jiffies; 2073 while (time_before(jiffies, timeout)) { 2074 idetape_create_test_unit_ready_cmd(&pc); 2075 if (!__idetape_queue_pc_tail(drive, &pc)) 2076 return 0; 2077 if ((tape->sense_key == 2 && tape->asc == 4 && tape->ascq == 2) 2078 || (tape->asc == 0x3A)) { /* no media */ 2079 if (load_attempted) 2080 return -ENOMEDIUM; 2081 idetape_create_load_unload_cmd(drive, &pc, IDETAPE_LU_LOAD_MASK); 2082 __idetape_queue_pc_tail(drive, &pc); 2083 load_attempted = 1; 2084 /* not about to be ready */ 2085 } else if (!(tape->sense_key == 2 && tape->asc == 4 && 2086 (tape->ascq == 1 || tape->ascq == 8))) 2087 return -EIO; 2088 msleep(100); 2089 } 2090 return -EIO; 2091} 2092 2093static int idetape_queue_pc_tail (ide_drive_t *drive,idetape_pc_t *pc) 2094{ 2095 return __idetape_queue_pc_tail(drive, pc); 2096} 2097 2098static int idetape_flush_tape_buffers (ide_drive_t *drive) 2099{ 2100 idetape_pc_t pc; 2101 int rc; 2102 2103 idetape_create_write_filemark_cmd(drive, &pc, 0); 2104 if ((rc = idetape_queue_pc_tail(drive, &pc))) 2105 return rc; 2106 idetape_wait_ready(drive, 60 * 5 * HZ); 2107 return 0; 2108} 2109 2110static void idetape_create_read_position_cmd (idetape_pc_t *pc) 2111{ 2112 idetape_init_pc(pc); 2113 pc->c[0] = READ_POSITION; 2114 pc->request_transfer = 20; 2115 pc->callback = &idetape_read_position_callback; 2116} 2117 2118static int idetape_read_position (ide_drive_t *drive) 2119{ 2120 idetape_tape_t *tape = drive->driver_data; 2121 idetape_pc_t pc; 2122 int position; 2123 2124 debug_log(DBG_PROCS, "Enter %s\n", __func__); 2125 2126 idetape_create_read_position_cmd(&pc); 2127 if (idetape_queue_pc_tail(drive, &pc)) 2128 return -1; 2129 position = tape->first_frame; 2130 return position; 2131} 2132 2133static void idetape_create_locate_cmd (ide_drive_t *drive, idetape_pc_t *pc, unsigned int block, u8 partition, int skip) 2134{ 2135 idetape_init_pc(pc); 2136 pc->c[0] = POSITION_TO_ELEMENT; 2137 pc->c[1] = 2; 2138 put_unaligned(cpu_to_be32(block), (unsigned int *) &pc->c[3]); 2139 pc->c[8] = partition; 2140 set_bit(PC_WAIT_FOR_DSC, &pc->flags); 2141 pc->callback = &idetape_pc_callback; 2142} 2143 2144static int idetape_create_prevent_cmd (ide_drive_t *drive, idetape_pc_t *pc, int prevent) 2145{ 2146 idetape_tape_t *tape = drive->driver_data; 2147 2148 /* device supports locking according to capabilities page */ 2149 if (!(tape->caps[6] & 0x01)) 2150 return 0; 2151 2152 idetape_init_pc(pc); 2153 pc->c[0] = ALLOW_MEDIUM_REMOVAL; 2154 pc->c[4] = prevent; 2155 pc->callback = &idetape_pc_callback; 2156 return 1; 2157} 2158 2159static int __idetape_discard_read_pipeline (ide_drive_t *drive) 2160{ 2161 idetape_tape_t *tape = drive->driver_data; 2162 unsigned long flags; 2163 int cnt; 2164 2165 if (tape->chrdev_dir != IDETAPE_DIR_READ) 2166 return 0; 2167 2168 /* Remove merge stage. */ 2169 cnt = tape->merge_stage_size / tape->blk_size; 2170 if (test_and_clear_bit(IDETAPE_FILEMARK, &tape->flags)) 2171 ++cnt; /* Filemarks count as 1 sector */ 2172 tape->merge_stage_size = 0; 2173 if (tape->merge_stage != NULL) { 2174 __idetape_kfree_stage(tape->merge_stage); 2175 tape->merge_stage = NULL; 2176 } 2177 2178 /* Clear pipeline flags. */ 2179 clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags); 2180 tape->chrdev_dir = IDETAPE_DIR_NONE; 2181 2182 /* Remove pipeline stages. */ 2183 if (tape->first_stage == NULL) 2184 return 0; 2185 2186 spin_lock_irqsave(&tape->lock, flags); 2187 tape->next_stage = NULL; 2188 if (idetape_pipeline_active(tape)) 2189 idetape_wait_for_request(drive, tape->active_data_rq); 2190 spin_unlock_irqrestore(&tape->lock, flags); 2191 2192 while (tape->first_stage != NULL) { 2193 struct request *rq_ptr = &tape->first_stage->rq; 2194 2195 cnt += rq_ptr->nr_sectors - rq_ptr->current_nr_sectors; 2196 if (rq_ptr->errors == IDETAPE_ERROR_FILEMARK) 2197 ++cnt; 2198 idetape_remove_stage_head(drive); 2199 } 2200 tape->nr_pending_stages = 0; 2201 tape->max_stages = tape->min_pipeline; 2202 return cnt; 2203} 2204 2205/* 2206 * idetape_position_tape positions the tape to the requested block 2207 * using the LOCATE packet command. A READ POSITION command is then 2208 * issued to check where we are positioned. 2209 * 2210 * Like all higher level operations, we queue the commands at the tail 2211 * of the request queue and wait for their completion. 2212 * 2213 */ 2214static int idetape_position_tape (ide_drive_t *drive, unsigned int block, u8 partition, int skip) 2215{ 2216 idetape_tape_t *tape = drive->driver_data; 2217 int retval; 2218 idetape_pc_t pc; 2219 2220 if (tape->chrdev_dir == IDETAPE_DIR_READ) 2221 __idetape_discard_read_pipeline(drive); 2222 idetape_wait_ready(drive, 60 * 5 * HZ); 2223 idetape_create_locate_cmd(drive, &pc, block, partition, skip); 2224 retval = idetape_queue_pc_tail(drive, &pc); 2225 if (retval) 2226 return (retval); 2227 2228 idetape_create_read_position_cmd(&pc); 2229 return (idetape_queue_pc_tail(drive, &pc)); 2230} 2231 2232static void idetape_discard_read_pipeline (ide_drive_t *drive, int restore_position) 2233{ 2234 idetape_tape_t *tape = drive->driver_data; 2235 int cnt; 2236 int seek, position; 2237 2238 cnt = __idetape_discard_read_pipeline(drive); 2239 if (restore_position) { 2240 position = idetape_read_position(drive); 2241 seek = position > cnt ? position - cnt : 0; 2242 if (idetape_position_tape(drive, seek, 0, 0)) { 2243 printk(KERN_INFO "ide-tape: %s: position_tape failed in discard_pipeline()\n", tape->name); 2244 return; 2245 } 2246 } 2247} 2248 2249/* 2250 * idetape_queue_rw_tail generates a read/write request for the block 2251 * device interface and wait for it to be serviced. 2252 */ 2253static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int blocks, struct idetape_bh *bh) 2254{ 2255 idetape_tape_t *tape = drive->driver_data; 2256 struct request rq; 2257 2258 debug_log(DBG_SENSE, "%s: cmd=%d\n", __func__, cmd); 2259 2260 if (idetape_pipeline_active(tape)) { 2261 printk(KERN_ERR "ide-tape: bug: the pipeline is active in %s\n", 2262 __func__); 2263 return (0); 2264 } 2265 2266 idetape_init_rq(&rq, cmd); 2267 rq.rq_disk = tape->disk; 2268 rq.special = (void *)bh; 2269 rq.sector = tape->first_frame; 2270 rq.nr_sectors = rq.current_nr_sectors = blocks; 2271 (void) ide_do_drive_cmd(drive, &rq, ide_wait); 2272 2273 if ((cmd & (REQ_IDETAPE_READ | REQ_IDETAPE_WRITE)) == 0) 2274 return 0; 2275 2276 if (tape->merge_stage) 2277 idetape_init_merge_stage(tape); 2278 if (rq.errors == IDETAPE_ERROR_GENERAL) 2279 return -EIO; 2280 return (tape->blk_size * (blocks-rq.current_nr_sectors)); 2281} 2282 2283/* 2284 * idetape_insert_pipeline_into_queue is used to start servicing the 2285 * pipeline stages, starting from tape->next_stage. 2286 */ 2287static void idetape_insert_pipeline_into_queue (ide_drive_t *drive) 2288{ 2289 idetape_tape_t *tape = drive->driver_data; 2290 2291 if (tape->next_stage == NULL) 2292 return; 2293 if (!idetape_pipeline_active(tape)) { 2294 set_bit(IDETAPE_PIPELINE_ACTIVE, &tape->flags); 2295 idetape_activate_next_stage(drive); 2296 (void) ide_do_drive_cmd(drive, tape->active_data_rq, ide_end); 2297 } 2298} 2299 2300static void idetape_create_inquiry_cmd (idetape_pc_t *pc) 2301{ 2302 idetape_init_pc(pc); 2303 pc->c[0] = INQUIRY; 2304 pc->c[4] = pc->request_transfer = 254; 2305 pc->callback = &idetape_pc_callback; 2306} 2307 2308static void idetape_create_rewind_cmd (ide_drive_t *drive, idetape_pc_t *pc) 2309{ 2310 idetape_init_pc(pc); 2311 pc->c[0] = REZERO_UNIT; 2312 set_bit(PC_WAIT_FOR_DSC, &pc->flags); 2313 pc->callback = &idetape_pc_callback; 2314} 2315 2316static void idetape_create_erase_cmd (idetape_pc_t *pc) 2317{ 2318 idetape_init_pc(pc); 2319 pc->c[0] = ERASE; 2320 pc->c[1] = 1; 2321 set_bit(PC_WAIT_FOR_DSC, &pc->flags); 2322 pc->callback = &idetape_pc_callback; 2323} 2324 2325static void idetape_create_space_cmd (idetape_pc_t *pc,int count, u8 cmd) 2326{ 2327 idetape_init_pc(pc); 2328 pc->c[0] = SPACE; 2329 put_unaligned(cpu_to_be32(count), (unsigned int *) &pc->c[1]); 2330 pc->c[1] = cmd; 2331 set_bit(PC_WAIT_FOR_DSC, &pc->flags); 2332 pc->callback = &idetape_pc_callback; 2333} 2334 2335static void idetape_wait_first_stage (ide_drive_t *drive) 2336{ 2337 idetape_tape_t *tape = drive->driver_data; 2338 unsigned long flags; 2339 2340 if (tape->first_stage == NULL) 2341 return; 2342 spin_lock_irqsave(&tape->lock, flags); 2343 if (tape->active_stage == tape->first_stage) 2344 idetape_wait_for_request(drive, tape->active_data_rq); 2345 spin_unlock_irqrestore(&tape->lock, flags); 2346} 2347 2348/* 2349 * idetape_add_chrdev_write_request tries to add a character device 2350 * originated write request to our pipeline. In case we don't succeed, 2351 * we revert to non-pipelined operation mode for this request. 2352 * 2353 * 1. Try to allocate a new pipeline stage. 2354 * 2. If we can't, wait for more and more requests to be serviced 2355 * and try again each time. 2356 * 3. If we still can't allocate a stage, fallback to 2357 * non-pipelined operation mode for this request. 2358 */ 2359static int idetape_add_chrdev_write_request (ide_drive_t *drive, int blocks) 2360{ 2361 idetape_tape_t *tape = drive->driver_data; 2362 idetape_stage_t *new_stage; 2363 unsigned long flags; 2364 struct request *rq; 2365 2366 debug_log(DBG_CHRDEV, "Enter %s\n", __func__); 2367 2368 /* 2369 * Attempt to allocate a new stage. 2370 * Pay special attention to possible race conditions. 2371 */ 2372 while ((new_stage = idetape_kmalloc_stage(tape)) == NULL) { 2373 spin_lock_irqsave(&tape->lock, flags); 2374 if (idetape_pipeline_active(tape)) { 2375 idetape_wait_for_request(drive, tape->active_data_rq); 2376 spin_unlock_irqrestore(&tape->lock, flags); 2377 } else { 2378 spin_unlock_irqrestore(&tape->lock, flags); 2379 idetape_insert_pipeline_into_queue(drive); 2380 if (idetape_pipeline_active(tape)) 2381 continue; 2382 /* 2383 * Linux is short on memory. Fallback to 2384 * non-pipelined operation mode for this request. 2385 */ 2386 return idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, blocks, tape->merge_stage->bh); 2387 } 2388 } 2389 rq = &new_stage->rq; 2390 idetape_init_rq(rq, REQ_IDETAPE_WRITE); 2391 /* Doesn't actually matter - We always assume sequential access */ 2392 rq->sector = tape->first_frame; 2393 rq->nr_sectors = rq->current_nr_sectors = blocks; 2394 2395 idetape_switch_buffers(tape, new_stage); 2396 idetape_add_stage_tail(drive, new_stage); 2397 tape->pipeline_head++; 2398 idetape_calculate_speeds(drive); 2399 2400 /* 2401 * Estimate whether the tape has stopped writing by checking 2402 * if our write pipeline is currently empty. If we are not 2403 * writing anymore, wait for the pipeline to be full enough 2404 * (90%) before starting to service requests, so that we will 2405 * be able to keep up with the higher speeds of the tape. 2406 */ 2407 if (!idetape_pipeline_active(tape)) { 2408 if (tape->nr_stages >= tape->max_stages * 9 / 10 || 2409 tape->nr_stages >= tape->max_stages - 2410 tape->uncontrolled_pipeline_head_speed * 3 * 1024 / 2411 tape->blk_size) { 2412 tape->measure_insert_time = 1; 2413 tape->insert_time = jiffies; 2414 tape->insert_size = 0; 2415 tape->insert_speed = 0; 2416 idetape_insert_pipeline_into_queue(drive); 2417 } 2418 } 2419 if (test_and_clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags)) 2420 /* Return a deferred error */ 2421 return -EIO; 2422 return blocks; 2423} 2424 2425/* 2426 * idetape_wait_for_pipeline will wait until all pending pipeline 2427 * requests are serviced. Typically called on device close. 2428 */ 2429static void idetape_wait_for_pipeline (ide_drive_t *drive) 2430{ 2431 idetape_tape_t *tape = drive->driver_data; 2432 unsigned long flags; 2433 2434 while (tape->next_stage || idetape_pipeline_active(tape)) { 2435 idetape_insert_pipeline_into_queue(drive); 2436 spin_lock_irqsave(&tape->lock, flags); 2437 if (idetape_pipeline_active(tape)) 2438 idetape_wait_for_request(drive, tape->active_data_rq); 2439 spin_unlock_irqrestore(&tape->lock, flags); 2440 } 2441} 2442 2443static void idetape_empty_write_pipeline (ide_drive_t *drive) 2444{ 2445 idetape_tape_t *tape = drive->driver_data; 2446 int blocks, min; 2447 struct idetape_bh *bh; 2448 2449 if (tape->chrdev_dir != IDETAPE_DIR_WRITE) { 2450 printk(KERN_ERR "ide-tape: bug: Trying to empty write pipeline, but we are not writing.\n"); 2451 return; 2452 } 2453 if (tape->merge_stage_size > tape->stage_size) { 2454 printk(KERN_ERR "ide-tape: bug: merge_buffer too big\n"); 2455 tape->merge_stage_size = tape->stage_size; 2456 } 2457 if (tape->merge_stage_size) { 2458 blocks = tape->merge_stage_size / tape->blk_size; 2459 if (tape->merge_stage_size % tape->blk_size) { 2460 unsigned int i; 2461 2462 blocks++; 2463 i = tape->blk_size - tape->merge_stage_size % 2464 tape->blk_size; 2465 bh = tape->bh->b_reqnext; 2466 while (bh) { 2467 atomic_set(&bh->b_count, 0); 2468 bh = bh->b_reqnext; 2469 } 2470 bh = tape->bh; 2471 while (i) { 2472 if (bh == NULL) { 2473 2474 printk(KERN_INFO "ide-tape: bug, bh NULL\n"); 2475 break; 2476 } 2477 min = min(i, (unsigned int)(bh->b_size - atomic_read(&bh->b_count))); 2478 memset(bh->b_data + atomic_read(&bh->b_count), 0, min); 2479 atomic_add(min, &bh->b_count); 2480 i -= min; 2481 bh = bh->b_reqnext; 2482 } 2483 } 2484 (void) idetape_add_chrdev_write_request(drive, blocks); 2485 tape->merge_stage_size = 0; 2486 } 2487 idetape_wait_for_pipeline(drive); 2488 if (tape->merge_stage != NULL) { 2489 __idetape_kfree_stage(tape->merge_stage); 2490 tape->merge_stage = NULL; 2491 } 2492 clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags); 2493 tape->chrdev_dir = IDETAPE_DIR_NONE; 2494 2495 /* 2496 * On the next backup, perform the feedback loop again. 2497 * (I don't want to keep sense information between backups, 2498 * as some systems are constantly on, and the system load 2499 * can be totally different on the next backup). 2500 */ 2501 tape->max_stages = tape->min_pipeline; 2502 if (tape->first_stage != NULL || 2503 tape->next_stage != NULL || 2504 tape->last_stage != NULL || 2505 tape->nr_stages != 0) { 2506 printk(KERN_ERR "ide-tape: ide-tape pipeline bug, " 2507 "first_stage %p, next_stage %p, " 2508 "last_stage %p, nr_stages %d\n", 2509 tape->first_stage, tape->next_stage, 2510 tape->last_stage, tape->nr_stages); 2511 } 2512} 2513 2514static void idetape_restart_speed_control (ide_drive_t *drive) 2515{ 2516 idetape_tape_t *tape = drive->driver_data; 2517 2518 tape->restart_speed_control_req = 0; 2519 tape->pipeline_head = 0; 2520 tape->controlled_last_pipeline_head = 0; 2521 tape->controlled_previous_pipeline_head = tape->uncontrolled_previous_pipeline_head = 0; 2522 tape->pipeline_head_speed = tape->controlled_pipeline_head_speed = 5000; 2523 tape->uncontrolled_pipeline_head_speed = 0; 2524 tape->controlled_pipeline_head_time = tape->uncontrolled_pipeline_head_time = jiffies; 2525 tape->controlled_previous_head_time = tape->uncontrolled_previous_head_time = jiffies; 2526} 2527 2528static int idetape_initiate_read (ide_drive_t *drive, int max_stages) 2529{ 2530 idetape_tape_t *tape = drive->driver_data; 2531 idetape_stage_t *new_stage; 2532 struct request rq; 2533 int bytes_read; 2534 u16 blocks = *(u16 *)&tape->caps[12]; 2535 2536 /* Initialize read operation */ 2537 if (tape->chrdev_dir != IDETAPE_DIR_READ) { 2538 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) { 2539 idetape_empty_write_pipeline(drive); 2540 idetape_flush_tape_buffers(drive); 2541 } 2542 if (tape->merge_stage || tape->merge_stage_size) { 2543 printk (KERN_ERR "ide-tape: merge_stage_size should be 0 now\n"); 2544 tape->merge_stage_size = 0; 2545 } 2546 if ((tape->merge_stage = __idetape_kmalloc_stage(tape, 0, 0)) == NULL) 2547 return -ENOMEM; 2548 tape->chrdev_dir = IDETAPE_DIR_READ; 2549 2550 /* 2551 * Issue a read 0 command to ensure that DSC handshake 2552 * is switched from completion mode to buffer available 2553 * mode. 2554 * No point in issuing this if DSC overlap isn't supported, 2555 * some drives (Seagate STT3401A) will return an error. 2556 */ 2557 if (drive->dsc_overlap) { 2558 bytes_read = idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, 0, tape->merge_stage->bh); 2559 if (bytes_read < 0) { 2560 __idetape_kfree_stage(tape->merge_stage); 2561 tape->merge_stage = NULL; 2562 tape->chrdev_dir = IDETAPE_DIR_NONE; 2563 return bytes_read; 2564 } 2565 } 2566 } 2567 if (tape->restart_speed_control_req) 2568 idetape_restart_speed_control(drive); 2569 idetape_init_rq(&rq, REQ_IDETAPE_READ); 2570 rq.sector = tape->first_frame; 2571 rq.nr_sectors = rq.current_nr_sectors = blocks; 2572 if (!test_bit(IDETAPE_PIPELINE_ERROR, &tape->flags) && 2573 tape->nr_stages < max_stages) { 2574 new_stage = idetape_kmalloc_stage(tape); 2575 while (new_stage != NULL) { 2576 new_stage->rq = rq; 2577 idetape_add_stage_tail(drive, new_stage); 2578 if (tape->nr_stages >= max_stages) 2579 break; 2580 new_stage = idetape_kmalloc_stage(tape); 2581 } 2582 } 2583 if (!idetape_pipeline_active(tape)) { 2584 if (tape->nr_pending_stages >= 3 * max_stages / 4) { 2585 tape->measure_insert_time = 1; 2586 tape->insert_time = jiffies; 2587 tape->insert_size = 0; 2588 tape->insert_speed = 0; 2589 idetape_insert_pipeline_into_queue(drive); 2590 } 2591 } 2592 return 0; 2593} 2594 2595/* 2596 * idetape_add_chrdev_read_request is called from idetape_chrdev_read 2597 * to service a character device read request and add read-ahead 2598 * requests to our pipeline. 2599 */ 2600static int idetape_add_chrdev_read_request (ide_drive_t *drive,int blocks) 2601{ 2602 idetape_tape_t *tape = drive->driver_data; 2603 unsigned long flags; 2604 struct request *rq_ptr; 2605 int bytes_read; 2606 2607 debug_log(DBG_PROCS, "Enter %s, %d blocks\n", __func__, blocks); 2608 2609 /* 2610 * If we are at a filemark, return a read length of 0 2611 */ 2612 if (test_bit(IDETAPE_FILEMARK, &tape->flags)) 2613 return 0; 2614 2615 /* 2616 * Wait for the next block to be available at the head 2617 * of the pipeline 2618 */ 2619 idetape_initiate_read(drive, tape->max_stages); 2620 if (tape->first_stage == NULL) { 2621 if (test_bit(IDETAPE_PIPELINE_ERROR, &tape->flags)) 2622 return 0; 2623 return idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, blocks, 2624 tape->merge_stage->bh); 2625 } 2626 idetape_wait_first_stage(drive); 2627 rq_ptr = &tape->first_stage->rq; 2628 bytes_read = tape->blk_size * (rq_ptr->nr_sectors - 2629 rq_ptr->current_nr_sectors); 2630 rq_ptr->nr_sectors = rq_ptr->current_nr_sectors = 0; 2631 2632 2633 if (rq_ptr->errors == IDETAPE_ERROR_EOD) 2634 return 0; 2635 else { 2636 idetape_switch_buffers(tape, tape->first_stage); 2637 if (rq_ptr->errors == IDETAPE_ERROR_FILEMARK) 2638 set_bit(IDETAPE_FILEMARK, &tape->flags); 2639 spin_lock_irqsave(&tape->lock, flags); 2640 idetape_remove_stage_head(drive); 2641 spin_unlock_irqrestore(&tape->lock, flags); 2642 tape->pipeline_head++; 2643 idetape_calculate_speeds(drive); 2644 } 2645 if (bytes_read > blocks * tape->blk_size) { 2646 printk(KERN_ERR "ide-tape: bug: trying to return more bytes than requested\n"); 2647 bytes_read = blocks * tape->blk_size; 2648 } 2649 return (bytes_read); 2650} 2651 2652static void idetape_pad_zeros (ide_drive_t *drive, int bcount) 2653{ 2654 idetape_tape_t *tape = drive->driver_data; 2655 struct idetape_bh *bh; 2656 int blocks; 2657 2658 while (bcount) { 2659 unsigned int count; 2660 2661 bh = tape->merge_stage->bh; 2662 count = min(tape->stage_size, bcount); 2663 bcount -= count; 2664 blocks = count / tape->blk_size; 2665 while (count) { 2666 atomic_set(&bh->b_count, min(count, (unsigned int)bh->b_size)); 2667 memset(bh->b_data, 0, atomic_read(&bh->b_count)); 2668 count -= atomic_read(&bh->b_count); 2669 bh = bh->b_reqnext; 2670 } 2671 idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, blocks, tape->merge_stage->bh); 2672 } 2673} 2674 2675static int idetape_pipeline_size (ide_drive_t *drive) 2676{ 2677 idetape_tape_t *tape = drive->driver_data; 2678 idetape_stage_t *stage; 2679 struct request *rq; 2680 int size = 0; 2681 2682 idetape_wait_for_pipeline(drive); 2683 stage = tape->first_stage; 2684 while (stage != NULL) { 2685 rq = &stage->rq; 2686 size += tape->blk_size * (rq->nr_sectors - 2687 rq->current_nr_sectors); 2688 if (rq->errors == IDETAPE_ERROR_FILEMARK) 2689 size += tape->blk_size; 2690 stage = stage->next; 2691 } 2692 size += tape->merge_stage_size; 2693 return size; 2694} 2695 2696/* 2697 * Rewinds the tape to the Beginning Of the current Partition (BOP). 2698 * 2699 * We currently support only one partition. 2700 */ 2701static int idetape_rewind_tape (ide_drive_t *drive) 2702{ 2703 int retval; 2704 idetape_pc_t pc; 2705 idetape_tape_t *tape; 2706 tape = drive->driver_data; 2707 2708 debug_log(DBG_SENSE, "Enter %s\n", __func__); 2709 2710 idetape_create_rewind_cmd(drive, &pc); 2711 retval = idetape_queue_pc_tail(drive, &pc); 2712 if (retval) 2713 return retval; 2714 2715 idetape_create_read_position_cmd(&pc); 2716 retval = idetape_queue_pc_tail(drive, &pc); 2717 if (retval) 2718 return retval; 2719 return 0; 2720} 2721 2722/* 2723 * Our special ide-tape ioctl's. 2724 * 2725 * Currently there aren't any ioctl's. 2726 * mtio.h compatible commands should be issued to the character device 2727 * interface. 2728 */ 2729static int idetape_blkdev_ioctl(ide_drive_t *drive, unsigned int cmd, unsigned long arg) 2730{ 2731 idetape_tape_t *tape = drive->driver_data; 2732 void __user *argp = (void __user *)arg; 2733 2734 struct idetape_config { 2735 int dsc_rw_frequency; 2736 int dsc_media_access_frequency; 2737 int nr_stages; 2738 } config; 2739 2740 debug_log(DBG_PROCS, "Enter %s\n", __func__); 2741 2742 switch (cmd) { 2743 case 0x0340: 2744 if (copy_from_user(&config, argp, sizeof(config))) 2745 return -EFAULT; 2746 tape->best_dsc_rw_freq = config.dsc_rw_frequency; 2747 tape->max_stages = config.nr_stages; 2748 break; 2749 case 0x0350: 2750 config.dsc_rw_frequency = (int) tape->best_dsc_rw_freq; 2751 config.nr_stages = tape->max_stages; 2752 if (copy_to_user(argp, &config, sizeof(config))) 2753 return -EFAULT; 2754 break; 2755 default: 2756 return -EIO; 2757 } 2758 return 0; 2759} 2760 2761/* 2762 * idetape_space_over_filemarks is now a bit more complicated than just 2763 * passing the command to the tape since we may have crossed some 2764 * filemarks during our pipelined read-ahead mode. 2765 * 2766 * As a minor side effect, the pipeline enables us to support MTFSFM when 2767 * the filemark is in our internal pipeline even if the tape doesn't 2768 * support spacing over filemarks in the reverse direction. 2769 */ 2770static int idetape_space_over_filemarks (ide_drive_t *drive,short mt_op,int mt_count) 2771{ 2772 idetape_tape_t *tape = drive->driver_data; 2773 idetape_pc_t pc; 2774 unsigned long flags; 2775 int retval,count=0; 2776 int sprev = !!(tape->caps[4] & 0x20); 2777 2778 if (mt_count == 0) 2779 return 0; 2780 if (MTBSF == mt_op || MTBSFM == mt_op) { 2781 if (!sprev) 2782 return -EIO; 2783 mt_count = - mt_count; 2784 } 2785 2786 if (tape->chrdev_dir == IDETAPE_DIR_READ) { 2787 /* 2788 * We have a read-ahead buffer. Scan it for crossed 2789 * filemarks. 2790 */ 2791 tape->merge_stage_size = 0; 2792 if (test_and_clear_bit(IDETAPE_FILEMARK, &tape->flags)) 2793 ++count; 2794 while (tape->first_stage != NULL) { 2795 if (count == mt_count) { 2796 if (mt_op == MTFSFM) 2797 set_bit(IDETAPE_FILEMARK, &tape->flags); 2798 return 0; 2799 } 2800 spin_lock_irqsave(&tape->lock, flags); 2801 if (tape->first_stage == tape->active_stage) { 2802 /* 2803 * We have reached the active stage in the read pipeline. 2804 * There is no point in allowing the drive to continue 2805 * reading any farther, so we stop the pipeline. 2806 * 2807 * This section should be moved to a separate subroutine, 2808 * because a similar function is performed in 2809 * __idetape_discard_read_pipeline(), for example. 2810 */ 2811 tape->next_stage = NULL; 2812 spin_unlock_irqrestore(&tape->lock, flags); 2813 idetape_wait_first_stage(drive); 2814 tape->next_stage = tape->first_stage->next; 2815 } else 2816 spin_unlock_irqrestore(&tape->lock, flags); 2817 if (tape->first_stage->rq.errors == IDETAPE_ERROR_FILEMARK) 2818 ++count; 2819 idetape_remove_stage_head(drive); 2820 } 2821 idetape_discard_read_pipeline(drive, 0); 2822 } 2823 2824 /* 2825 * The filemark was not found in our internal pipeline. 2826 * Now we can issue the space command. 2827 */ 2828 switch (mt_op) { 2829 case MTFSF: 2830 case MTBSF: 2831 idetape_create_space_cmd(&pc,mt_count-count,IDETAPE_SPACE_OVER_FILEMARK); 2832 return (idetape_queue_pc_tail(drive, &pc)); 2833 case MTFSFM: 2834 case MTBSFM: 2835 if (!sprev) 2836 return (-EIO); 2837 retval = idetape_space_over_filemarks(drive, MTFSF, mt_count-count); 2838 if (retval) return (retval); 2839 count = (MTBSFM == mt_op ? 1 : -1); 2840 return (idetape_space_over_filemarks(drive, MTFSF, count)); 2841 default: 2842 printk(KERN_ERR "ide-tape: MTIO operation %d not supported\n",mt_op); 2843 return (-EIO); 2844 } 2845} 2846 2847 2848/* 2849 * Our character device read / write functions. 2850 * 2851 * The tape is optimized to maximize throughput when it is transferring 2852 * an integral number of the "continuous transfer limit", which is 2853 * a parameter of the specific tape (26 KB on my particular tape). 2854 * (32 kB for Onstream) 2855 * 2856 * As of version 1.3 of the driver, the character device provides an 2857 * abstract continuous view of the media - any mix of block sizes (even 1 2858 * byte) on the same backup/restore procedure is supported. The driver 2859 * will internally convert the requests to the recommended transfer unit, 2860 * so that an unmatch between the user's block size to the recommended 2861 * size will only result in a (slightly) increased driver overhead, but 2862 * will no longer hit performance. 2863 * This is not applicable to Onstream. 2864 */ 2865static ssize_t idetape_chrdev_read (struct file *file, char __user *buf, 2866 size_t count, loff_t *ppos) 2867{ 2868 struct ide_tape_obj *tape = ide_tape_f(file); 2869 ide_drive_t *drive = tape->drive; 2870 ssize_t bytes_read,temp, actually_read = 0, rc; 2871 ssize_t ret = 0; 2872 u16 ctl = *(u16 *)&tape->caps[12]; 2873 2874 debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count); 2875 2876 if (tape->chrdev_dir != IDETAPE_DIR_READ) { 2877 if (test_bit(IDETAPE_DETECT_BS, &tape->flags)) 2878 if (count > tape->blk_size && 2879 (count % tape->blk_size) == 0) 2880 tape->user_bs_factor = count / tape->blk_size; 2881 } 2882 if ((rc = idetape_initiate_read(drive, tape->max_stages)) < 0) 2883 return rc; 2884 if (count == 0) 2885 return (0); 2886 if (tape->merge_stage_size) { 2887 actually_read = min((unsigned int)(tape->merge_stage_size), (unsigned int)count); 2888 if (idetape_copy_stage_to_user(tape, buf, tape->merge_stage, actually_read)) 2889 ret = -EFAULT; 2890 buf += actually_read; 2891 tape->merge_stage_size -= actually_read; 2892 count -= actually_read; 2893 } 2894 while (count >= tape->stage_size) { 2895 bytes_read = idetape_add_chrdev_read_request(drive, ctl); 2896 if (bytes_read <= 0) 2897 goto finish; 2898 if (idetape_copy_stage_to_user(tape, buf, tape->merge_stage, bytes_read)) 2899 ret = -EFAULT; 2900 buf += bytes_read; 2901 count -= bytes_read; 2902 actually_read += bytes_read; 2903 } 2904 if (count) { 2905 bytes_read = idetape_add_chrdev_read_request(drive, ctl); 2906 if (bytes_read <= 0) 2907 goto finish; 2908 temp = min((unsigned long)count, (unsigned long)bytes_read); 2909 if (idetape_copy_stage_to_user(tape, buf, tape->merge_stage, temp)) 2910 ret = -EFAULT; 2911 actually_read += temp; 2912 tape->merge_stage_size = bytes_read-temp; 2913 } 2914finish: 2915 if (!actually_read && test_bit(IDETAPE_FILEMARK, &tape->flags)) { 2916 debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name); 2917 2918 idetape_space_over_filemarks(drive, MTFSF, 1); 2919 return 0; 2920 } 2921 2922 return (ret) ? ret : actually_read; 2923} 2924 2925static ssize_t idetape_chrdev_write (struct file *file, const char __user *buf, 2926 size_t count, loff_t *ppos) 2927{ 2928 struct ide_tape_obj *tape = ide_tape_f(file); 2929 ide_drive_t *drive = tape->drive; 2930 ssize_t actually_written = 0; 2931 ssize_t ret = 0; 2932 u16 ctl = *(u16 *)&tape->caps[12]; 2933 2934 /* The drive is write protected. */ 2935 if (tape->write_prot) 2936 return -EACCES; 2937 2938 debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count); 2939 2940 /* Initialize write operation */ 2941 if (tape->chrdev_dir != IDETAPE_DIR_WRITE) { 2942 if (tape->chrdev_dir == IDETAPE_DIR_READ) 2943 idetape_discard_read_pipeline(drive, 1); 2944 if (tape->merge_stage || tape->merge_stage_size) { 2945 printk(KERN_ERR "ide-tape: merge_stage_size " 2946 "should be 0 now\n"); 2947 tape->merge_stage_size = 0; 2948 } 2949 if ((tape->merge_stage = __idetape_kmalloc_stage(tape, 0, 0)) == NULL) 2950 return -ENOMEM; 2951 tape->chrdev_dir = IDETAPE_DIR_WRITE; 2952 idetape_init_merge_stage(tape); 2953 2954 /* 2955 * Issue a write 0 command to ensure that DSC handshake 2956 * is switched from completion mode to buffer available 2957 * mode. 2958 * No point in issuing this if DSC overlap isn't supported, 2959 * some drives (Seagate STT3401A) will return an error. 2960 */ 2961 if (drive->dsc_overlap) { 2962 ssize_t retval = idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, 0, tape->merge_stage->bh); 2963 if (retval < 0) { 2964 __idetape_kfree_stage(tape->merge_stage); 2965 tape->merge_stage = NULL; 2966 tape->chrdev_dir = IDETAPE_DIR_NONE; 2967 return retval; 2968 } 2969 } 2970 } 2971 if (count == 0) 2972 return (0); 2973 if (tape->restart_speed_control_req) 2974 idetape_restart_speed_control(drive); 2975 if (tape->merge_stage_size) { 2976 if (tape->merge_stage_size >= tape->stage_size) { 2977 printk(KERN_ERR "ide-tape: bug: merge buffer too big\n"); 2978 tape->merge_stage_size = 0; 2979 } 2980 actually_written = min((unsigned int)(tape->stage_size - tape->merge_stage_size), (unsigned int)count); 2981 if (idetape_copy_stage_from_user(tape, tape->merge_stage, buf, actually_written)) 2982 ret = -EFAULT; 2983 buf += actually_written; 2984 tape->merge_stage_size += actually_written; 2985 count -= actually_written; 2986 2987 if (tape->merge_stage_size == tape->stage_size) { 2988 ssize_t retval; 2989 tape->merge_stage_size = 0; 2990 retval = idetape_add_chrdev_write_request(drive, ctl); 2991 if (retval <= 0) 2992 return (retval); 2993 } 2994 } 2995 while (count >= tape->stage_size) { 2996 ssize_t retval; 2997 if (idetape_copy_stage_from_user(tape, tape->merge_stage, buf, tape->stage_size)) 2998 ret = -EFAULT; 2999 buf += tape->stage_size; 3000 count -= tape->stage_size; 3001 retval = idetape_add_chrdev_write_request(drive, ctl); 3002 actually_written += tape->stage_size; 3003 if (retval <= 0) 3004 return (retval); 3005 } 3006 if (count) { 3007 actually_written += count; 3008 if (idetape_copy_stage_from_user(tape, tape->merge_stage, buf, count)) 3009 ret = -EFAULT; 3010 tape->merge_stage_size += count; 3011 } 3012 return (ret) ? ret : actually_written; 3013} 3014 3015static int idetape_write_filemark (ide_drive_t *drive) 3016{ 3017 idetape_pc_t pc; 3018 3019 /* Write a filemark */ 3020 idetape_create_write_filemark_cmd(drive, &pc, 1); 3021 if (idetape_queue_pc_tail(drive, &pc)) { 3022 printk(KERN_ERR "ide-tape: Couldn't write a filemark\n"); 3023 return -EIO; 3024 } 3025 return 0; 3026} 3027 3028/* 3029 * Called from idetape_chrdev_ioctl when the general mtio MTIOCTOP ioctl is 3030 * requested. 3031 * 3032 * Note: MTBSF and MTBSFM are not supported when the tape doesn't support 3033 * spacing over filemarks in the reverse direction. In this case, MTFSFM is also 3034 * usually not supported (it is supported in the rare case in which we crossed 3035 * the filemark during our read-ahead pipelined operation mode). 3036 * 3037 * The following commands are currently not supported: 3038 * 3039 * MTFSS, MTBSS, MTWSM, MTSETDENSITY, MTSETDRVBUFFER, MT_ST_BOOLEANS, 3040 * MT_ST_WRITE_THRESHOLD. 3041 */ 3042static int idetape_mtioctop(ide_drive_t *drive, short mt_op, int mt_count) 3043{ 3044 idetape_tape_t *tape = drive->driver_data; 3045 idetape_pc_t pc; 3046 int i,retval; 3047 3048 debug_log(DBG_ERR, "Handling MTIOCTOP ioctl: mt_op=%d, mt_count=%d\n", 3049 mt_op, mt_count); 3050 /* 3051 * Commands which need our pipelined read-ahead stages. 3052 */ 3053 switch (mt_op) { 3054 case MTFSF: 3055 case MTFSFM: 3056 case MTBSF: 3057 case MTBSFM: 3058 if (!mt_count) 3059 return (0); 3060 return (idetape_space_over_filemarks(drive,mt_op,mt_count)); 3061 default: 3062 break; 3063 } 3064 switch (mt_op) { 3065 case MTWEOF: 3066 if (tape->write_prot) 3067 return -EACCES; 3068 idetape_discard_read_pipeline(drive, 1); 3069 for (i = 0; i < mt_count; i++) { 3070 retval = idetape_write_filemark(drive); 3071 if (retval) 3072 return retval; 3073 } 3074 return (0); 3075 case MTREW: 3076 idetape_discard_read_pipeline(drive, 0); 3077 if (idetape_rewind_tape(drive)) 3078 return -EIO; 3079 return 0; 3080 case MTLOAD: 3081 idetape_discard_read_pipeline(drive, 0); 3082 idetape_create_load_unload_cmd(drive, &pc, IDETAPE_LU_LOAD_MASK); 3083 return (idetape_queue_pc_tail(drive, &pc)); 3084 case MTUNLOAD: 3085 case MTOFFL: 3086 /* 3087 * If door is locked, attempt to unlock before 3088 * attempting to eject. 3089 */ 3090 if (tape->door_locked) { 3091 if (idetape_create_prevent_cmd(drive, &pc, 0)) 3092 if (!idetape_queue_pc_tail(drive, &pc)) 3093 tape->door_locked = DOOR_UNLOCKED; 3094 } 3095 idetape_discard_read_pipeline(drive, 0); 3096 idetape_create_load_unload_cmd(drive, &pc,!IDETAPE_LU_LOAD_MASK); 3097 retval = idetape_queue_pc_tail(drive, &pc); 3098 if (!retval) 3099 clear_bit(IDETAPE_MEDIUM_PRESENT, &tape->flags); 3100 return retval; 3101 case MTNOP: 3102 idetape_discard_read_pipeline(drive, 0); 3103 return (idetape_flush_tape_buffers(drive)); 3104 case MTRETEN: 3105 idetape_discard_read_pipeline(drive, 0); 3106 idetape_create_load_unload_cmd(drive, &pc,IDETAPE_LU_RETENSION_MASK | IDETAPE_LU_LOAD_MASK); 3107 return (idetape_queue_pc_tail(drive, &pc)); 3108 case MTEOM: 3109 idetape_create_space_cmd(&pc, 0, IDETAPE_SPACE_TO_EOD); 3110 return (idetape_queue_pc_tail(drive, &pc)); 3111 case MTERASE: 3112 (void) idetape_rewind_tape(drive); 3113 idetape_create_erase_cmd(&pc); 3114 return (idetape_queue_pc_tail(drive, &pc)); 3115 case MTSETBLK: 3116 if (mt_count) { 3117 if (mt_count < tape->blk_size || 3118 mt_count % tape->blk_size) 3119 return -EIO; 3120 tape->user_bs_factor = mt_count / 3121 tape->blk_size; 3122 clear_bit(IDETAPE_DETECT_BS, &tape->flags); 3123 } else 3124 set_bit(IDETAPE_DETECT_BS, &tape->flags); 3125 return 0; 3126 case MTSEEK: 3127 idetape_discard_read_pipeline(drive, 0); 3128 return idetape_position_tape(drive, mt_count * tape->user_bs_factor, tape->partition, 0); 3129 case MTSETPART: 3130 idetape_discard_read_pipeline(drive, 0); 3131 return (idetape_position_tape(drive, 0, mt_count, 0)); 3132 case MTFSR: 3133 case MTBSR: 3134 case MTLOCK: 3135 if (!idetape_create_prevent_cmd(drive, &pc, 1)) 3136 return 0; 3137 retval = idetape_queue_pc_tail(drive, &pc); 3138 if (retval) return retval; 3139 tape->door_locked = DOOR_EXPLICITLY_LOCKED; 3140 return 0; 3141 case MTUNLOCK: 3142 if (!idetape_create_prevent_cmd(drive, &pc, 0)) 3143 return 0; 3144 retval = idetape_queue_pc_tail(drive, &pc); 3145 if (retval) return retval; 3146 tape->door_locked = DOOR_UNLOCKED; 3147 return 0; 3148 default: 3149 printk(KERN_ERR "ide-tape: MTIO operation %d not " 3150 "supported\n", mt_op); 3151 return (-EIO); 3152 } 3153} 3154 3155/* 3156 * Our character device ioctls. General mtio.h magnetic io commands are 3157 * supported here, and not in the corresponding block interface. Our own 3158 * ide-tape ioctls are supported on both interfaces. 3159 */ 3160static int idetape_chrdev_ioctl(struct inode *inode, struct file *file, 3161 unsigned int cmd, unsigned long arg) 3162{ 3163 struct ide_tape_obj *tape = ide_tape_f(file); 3164 ide_drive_t *drive = tape->drive; 3165 struct mtop mtop; 3166 struct mtget mtget; 3167 struct mtpos mtpos; 3168 int block_offset = 0, position = tape->first_frame; 3169 void __user *argp = (void __user *)arg; 3170 3171 debug_log(DBG_CHRDEV, "Enter %s, cmd=%u\n", __func__, cmd); 3172 3173 tape->restart_speed_control_req = 1; 3174 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) { 3175 idetape_empty_write_pipeline(drive); 3176 idetape_flush_tape_buffers(drive); 3177 } 3178 if (cmd == MTIOCGET || cmd == MTIOCPOS) { 3179 block_offset = idetape_pipeline_size(drive) / 3180 (tape->blk_size * tape->user_bs_factor); 3181 if ((position = idetape_read_position(drive)) < 0) 3182 return -EIO; 3183 } 3184 switch (cmd) { 3185 case MTIOCTOP: 3186 if (copy_from_user(&mtop, argp, sizeof (struct mtop))) 3187 return -EFAULT; 3188 return (idetape_mtioctop(drive,mtop.mt_op,mtop.mt_count)); 3189 case MTIOCGET: 3190 memset(&mtget, 0, sizeof (struct mtget)); 3191 mtget.mt_type = MT_ISSCSI2; 3192 mtget.mt_blkno = position / tape->user_bs_factor - block_offset; 3193 mtget.mt_dsreg = 3194 ((tape->blk_size * tape->user_bs_factor) 3195 << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK; 3196 3197 if (tape->drv_write_prot) { 3198 mtget.mt_gstat |= GMT_WR_PROT(0xffffffff); 3199 } 3200 if (copy_to_user(argp, &mtget, sizeof(struct mtget))) 3201 return -EFAULT; 3202 return 0; 3203 case MTIOCPOS: 3204 mtpos.mt_blkno = position / tape->user_bs_factor - block_offset; 3205 if (copy_to_user(argp, &mtpos, sizeof(struct mtpos))) 3206 return -EFAULT; 3207 return 0; 3208 default: 3209 if (tape->chrdev_dir == IDETAPE_DIR_READ) 3210 idetape_discard_read_pipeline(drive, 1); 3211 return idetape_blkdev_ioctl(drive, cmd, arg); 3212 } 3213} 3214 3215/* 3216 * Do a mode sense page 0 with block descriptor and if it succeeds set the tape 3217 * block size with the reported value. 3218 */ 3219static void ide_tape_get_bsize_from_bdesc(ide_drive_t *drive) 3220{ 3221 idetape_tape_t *tape = drive->driver_data; 3222 idetape_pc_t pc; 3223 3224 idetape_create_mode_sense_cmd(&pc, IDETAPE_BLOCK_DESCRIPTOR); 3225 if (idetape_queue_pc_tail(drive, &pc)) { 3226 printk(KERN_ERR "ide-tape: Can't get block descriptor\n"); 3227 if (tape->blk_size == 0) { 3228 printk(KERN_WARNING "ide-tape: Cannot deal with zero " 3229 "block size, assuming 32k\n"); 3230 tape->blk_size = 32768; 3231 } 3232 return; 3233 } 3234 tape->blk_size = (pc.buffer[4 + 5] << 16) + 3235 (pc.buffer[4 + 6] << 8) + 3236 pc.buffer[4 + 7]; 3237 tape->drv_write_prot = (pc.buffer[2] & 0x80) >> 7; 3238} 3239 3240/* 3241 * Our character device open function. 3242 */ 3243static int idetape_chrdev_open (struct inode *inode, struct file *filp) 3244{ 3245 unsigned int minor = iminor(inode), i = minor & ~0xc0; 3246 ide_drive_t *drive; 3247 idetape_tape_t *tape; 3248 idetape_pc_t pc; 3249 int retval; 3250 3251 if (i >= MAX_HWIFS * MAX_DRIVES) 3252 return -ENXIO; 3253 3254 tape = ide_tape_chrdev_get(i); 3255 if (!tape) 3256 return -ENXIO; 3257 3258 debug_log(DBG_CHRDEV, "Enter %s\n", __func__); 3259 3260 /* 3261 * We really want to do nonseekable_open(inode, filp); here, but some 3262 * versions of tar incorrectly call lseek on tapes and bail out if that 3263 * fails. So we disallow pread() and pwrite(), but permit lseeks. 3264 */ 3265 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE); 3266 3267 drive = tape->drive; 3268 3269 filp->private_data = tape; 3270 3271 if (test_and_set_bit(IDETAPE_BUSY, &tape->flags)) { 3272 retval = -EBUSY; 3273 goto out_put_tape; 3274 } 3275 3276 retval = idetape_wait_ready(drive, 60 * HZ); 3277 if (retval) { 3278 clear_bit(IDETAPE_BUSY, &tape->flags); 3279 printk(KERN_ERR "ide-tape: %s: drive not ready\n", tape->name); 3280 goto out_put_tape; 3281 } 3282 3283 idetape_read_position(drive); 3284 if (!test_bit(IDETAPE_ADDRESS_VALID, &tape->flags)) 3285 (void)idetape_rewind_tape(drive); 3286 3287 if (tape->chrdev_dir != IDETAPE_DIR_READ) 3288 clear_bit(IDETAPE_PIPELINE_ERROR, &tape->flags); 3289 3290 /* Read block size and write protect status from drive. */ 3291 ide_tape_get_bsize_from_bdesc(drive); 3292 3293 /* Set write protect flag if device is opened as read-only. */ 3294 if ((filp->f_flags & O_ACCMODE) == O_RDONLY) 3295 tape->write_prot = 1; 3296 else 3297 tape->write_prot = tape->drv_write_prot; 3298 3299 /* Make sure drive isn't write protected if user wants to write. */ 3300 if (tape->write_prot) { 3301 if ((filp->f_flags & O_ACCMODE) == O_WRONLY || 3302 (filp->f_flags & O_ACCMODE) == O_RDWR) { 3303 clear_bit(IDETAPE_BUSY, &tape->flags); 3304 retval = -EROFS; 3305 goto out_put_tape; 3306 } 3307 } 3308 3309 /* 3310 * Lock the tape drive door so user can't eject. 3311 */ 3312 if (tape->chrdev_dir == IDETAPE_DIR_NONE) { 3313 if (idetape_create_prevent_cmd(drive, &pc, 1)) { 3314 if (!idetape_queue_pc_tail(drive, &pc)) { 3315 if (tape->door_locked != DOOR_EXPLICITLY_LOCKED) 3316 tape->door_locked = DOOR_LOCKED; 3317 } 3318 } 3319 } 3320 idetape_restart_speed_control(drive); 3321 tape->restart_speed_control_req = 0; 3322 return 0; 3323 3324out_put_tape: 3325 ide_tape_put(tape); 3326 return retval; 3327} 3328 3329static void idetape_write_release (ide_drive_t *drive, unsigned int minor) 3330{ 3331 idetape_tape_t *tape = drive->driver_data; 3332 3333 idetape_empty_write_pipeline(drive); 3334 tape->merge_stage = __idetape_kmalloc_stage(tape, 1, 0); 3335 if (tape->merge_stage != NULL) { 3336 idetape_pad_zeros(drive, tape->blk_size * 3337 (tape->user_bs_factor - 1)); 3338 __idetape_kfree_stage(tape->merge_stage); 3339 tape->merge_stage = NULL; 3340 } 3341 idetape_write_filemark(drive); 3342 idetape_flush_tape_buffers(drive); 3343 idetape_flush_tape_buffers(drive); 3344} 3345 3346/* 3347 * Our character device release function. 3348 */ 3349static int idetape_chrdev_release (struct inode *inode, struct file *filp) 3350{ 3351 struct ide_tape_obj *tape = ide_tape_f(filp); 3352 ide_drive_t *drive = tape->drive; 3353 idetape_pc_t pc; 3354 unsigned int minor = iminor(inode); 3355 3356 lock_kernel(); 3357 tape = drive->driver_data; 3358 3359 debug_log(DBG_CHRDEV, "Enter %s\n", __func__); 3360 3361 if (tape->chrdev_dir == IDETAPE_DIR_WRITE) 3362 idetape_write_release(drive, minor); 3363 if (tape->chrdev_dir == IDETAPE_DIR_READ) { 3364 if (minor < 128) 3365 idetape_discard_read_pipeline(drive, 1); 3366 else 3367 idetape_wait_for_pipeline(drive); 3368 } 3369 if (tape->cache_stage != NULL) { 3370 __idetape_kfree_stage(tape->cache_stage); 3371 tape->cache_stage = NULL; 3372 } 3373 if (minor < 128 && test_bit(IDETAPE_MEDIUM_PRESENT, &tape->flags)) 3374 (void) idetape_rewind_tape(drive); 3375 if (tape->chrdev_dir == IDETAPE_DIR_NONE) { 3376 if (tape->door_locked == DOOR_LOCKED) { 3377 if (idetape_create_prevent_cmd(drive, &pc, 0)) { 3378 if (!idetape_queue_pc_tail(drive, &pc)) 3379 tape->door_locked = DOOR_UNLOCKED; 3380 } 3381 } 3382 } 3383 clear_bit(IDETAPE_BUSY, &tape->flags); 3384 ide_tape_put(tape); 3385 unlock_kernel(); 3386 return 0; 3387} 3388 3389/* 3390 * idetape_identify_device is called to check the contents of the 3391 * ATAPI IDENTIFY command results. We return: 3392 * 3393 * 1 If the tape can be supported by us, based on the information 3394 * we have so far. 3395 * 3396 * 0 If this tape driver is not currently supported by us. 3397 */ 3398static int idetape_identify_device (ide_drive_t *drive) 3399{ 3400 struct idetape_id_gcw gcw; 3401 struct hd_driveid *id = drive->id; 3402 3403 if (drive->id_read == 0) 3404 return 1; 3405 3406 *((unsigned short *) &gcw) = id->config; 3407 3408 /* Check that we can support this device */ 3409 3410 if (gcw.protocol != 2) 3411 printk(KERN_ERR "ide-tape: Protocol (0x%02x) is not ATAPI\n", 3412 gcw.protocol); 3413 else if (gcw.device_type != 1) 3414 printk(KERN_ERR "ide-tape: Device type (0x%02x) is not set " 3415 "to tape\n", gcw.device_type); 3416 else if (!gcw.removable) 3417 printk(KERN_ERR "ide-tape: The removable flag is not set\n"); 3418 else if (gcw.packet_size != 0) { 3419 printk(KERN_ERR "ide-tape: Packet size (0x%02x) is not 12 " 3420 "bytes long\n", gcw.packet_size); 3421 } else 3422 return 1; 3423 return 0; 3424} 3425 3426static void idetape_get_inquiry_results(ide_drive_t *drive) 3427{ 3428 idetape_tape_t *tape = drive->driver_data; 3429 idetape_pc_t pc; 3430 char fw_rev[6], vendor_id[10], product_id[18]; 3431 3432 idetape_create_inquiry_cmd(&pc); 3433 if (idetape_queue_pc_tail(drive, &pc)) { 3434 printk(KERN_ERR "ide-tape: %s: can't get INQUIRY results\n", 3435 tape->name); 3436 return; 3437 } 3438 memcpy(vendor_id, &pc.buffer[8], 8); 3439 memcpy(product_id, &pc.buffer[16], 16); 3440 memcpy(fw_rev, &pc.buffer[32], 4); 3441 3442 ide_fixstring(vendor_id, 10, 0); 3443 ide_fixstring(product_id, 18, 0); 3444 ide_fixstring(fw_rev, 6, 0); 3445 3446 printk(KERN_INFO "ide-tape: %s <-> %s: %s %s rev %s\n", 3447 drive->name, tape->name, vendor_id, product_id, fw_rev); 3448} 3449 3450/* 3451 * Ask the tape about its various parameters. In particular, we will adjust our 3452 * data transfer buffer size to the recommended value as returned by the tape. 3453 */ 3454static void idetape_get_mode_sense_results (ide_drive_t *drive) 3455{ 3456 idetape_tape_t *tape = drive->driver_data; 3457 idetape_pc_t pc; 3458 u8 *caps; 3459 u8 speed, max_speed; 3460 3461 idetape_create_mode_sense_cmd(&pc, IDETAPE_CAPABILITIES_PAGE); 3462 if (idetape_queue_pc_tail(drive, &pc)) { 3463 printk(KERN_ERR "ide-tape: Can't get tape parameters - assuming" 3464 " some default values\n"); 3465 tape->blk_size = 512; 3466 put_unaligned(52, (u16 *)&tape->caps[12]); 3467 put_unaligned(540, (u16 *)&tape->caps[14]); 3468 put_unaligned(6*52, (u16 *)&tape->caps[16]); 3469 return; 3470 } 3471 caps = pc.buffer + 4 + pc.buffer[3]; 3472 3473 /* convert to host order and save for later use */ 3474 speed = be16_to_cpu(*(u16 *)&caps[14]); 3475 max_speed = be16_to_cpu(*(u16 *)&caps[8]); 3476 3477 put_unaligned(max_speed, (u16 *)&caps[8]); 3478 put_unaligned(be16_to_cpu(*(u16 *)&caps[12]), (u16 *)&caps[12]); 3479 put_unaligned(speed, (u16 *)&caps[14]); 3480 put_unaligned(be16_to_cpu(*(u16 *)&caps[16]), (u16 *)&caps[16]); 3481 3482 if (!speed) { 3483 printk(KERN_INFO "ide-tape: %s: invalid tape speed " 3484 "(assuming 650KB/sec)\n", drive->name); 3485 put_unaligned(650, (u16 *)&caps[14]); 3486 } 3487 if (!max_speed) { 3488 printk(KERN_INFO "ide-tape: %s: invalid max_speed " 3489 "(assuming 650KB/sec)\n", drive->name); 3490 put_unaligned(650, (u16 *)&caps[8]); 3491 } 3492 3493 memcpy(&tape->caps, caps, 20); 3494 if (caps[7] & 0x02) 3495 tape->blk_size = 512; 3496 else if (caps[7] & 0x04) 3497 tape->blk_size = 1024; 3498} 3499 3500#ifdef CONFIG_IDE_PROC_FS 3501static void idetape_add_settings (ide_drive_t *drive) 3502{ 3503 idetape_tape_t *tape = drive->driver_data; 3504 3505/* 3506 * drive setting name read/write data type min max mul_factor div_factor data pointer set function 3507 */ 3508 ide_add_setting(drive, "buffer", SETTING_READ, TYPE_SHORT, 0, 0xffff, 3509 1, 2, (u16 *)&tape->caps[16], NULL); 3510 ide_add_setting(drive, "pipeline_min", SETTING_RW, TYPE_INT, 1, 0xffff, tape->stage_size / 1024, 1, &tape->min_pipeline, NULL); 3511 ide_add_setting(drive, "pipeline", SETTING_RW, TYPE_INT, 1, 0xffff, tape->stage_size / 1024, 1, &tape->max_stages, NULL); 3512 ide_add_setting(drive, "pipeline_max", SETTING_RW, TYPE_INT, 1, 0xffff, tape->stage_size / 1024, 1, &tape->max_pipeline, NULL); 3513 ide_add_setting(drive, "pipeline_used", SETTING_READ, TYPE_INT, 0, 0xffff, tape->stage_size / 1024, 1, &tape->nr_stages, NULL); 3514 ide_add_setting(drive, "pipeline_pending", SETTING_READ, TYPE_INT, 0, 0xffff, tape->stage_size / 1024, 1, &tape->nr_pending_stages, NULL); 3515 ide_add_setting(drive, "speed", SETTING_READ, TYPE_SHORT, 0, 0xffff, 3516 1, 1, (u16 *)&tape->caps[14], NULL); 3517 ide_add_setting(drive, "stage", SETTING_READ, TYPE_INT, 0, 0xffff, 1, 3518 1024, &tape->stage_size, NULL); 3519 ide_add_setting(drive, "tdsc", SETTING_RW, TYPE_INT, IDETAPE_DSC_RW_MIN, 3520 IDETAPE_DSC_RW_MAX, 1000, HZ, &tape->best_dsc_rw_freq, 3521 NULL); 3522 ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL); 3523 ide_add_setting(drive, "pipeline_head_speed_c",SETTING_READ, TYPE_INT, 0, 0xffff, 1, 1, &tape->controlled_pipeline_head_speed, NULL); 3524 ide_add_setting(drive, "pipeline_head_speed_u",SETTING_READ, TYPE_INT, 0, 0xffff, 1, 1, &tape->uncontrolled_pipeline_head_speed,NULL); 3525 ide_add_setting(drive, "avg_speed", SETTING_READ, TYPE_INT, 0, 0xffff, 1, 1, &tape->avg_speed, NULL); 3526 ide_add_setting(drive, "debug_mask", SETTING_RW, TYPE_INT, 0, 0xffff, 1, 3527 1, &tape->debug_mask, NULL); 3528} 3529#else 3530static inline void idetape_add_settings(ide_drive_t *drive) { ; } 3531#endif 3532 3533/* 3534 * ide_setup is called to: 3535 * 3536 * 1. Initialize our various state variables. 3537 * 2. Ask the tape for its capabilities. 3538 * 3. Allocate a buffer which will be used for data 3539 * transfer. The buffer size is chosen based on 3540 * the recommendation which we received in step (2). 3541 * 3542 * Note that at this point ide.c already assigned us an irq, so that 3543 * we can queue requests here and wait for their completion. 3544 */ 3545static void idetape_setup (ide_drive_t *drive, idetape_tape_t *tape, int minor) 3546{ 3547 unsigned long t1, tmid, tn, t; 3548 int speed; 3549 struct idetape_id_gcw gcw; 3550 int stage_size; 3551 struct sysinfo si; 3552 u16 *ctl = (u16 *)&tape->caps[12]; 3553 3554 spin_lock_init(&tape->lock); 3555 drive->dsc_overlap = 1; 3556 if (drive->hwif->host_flags & IDE_HFLAG_NO_DSC) { 3557 printk(KERN_INFO "ide-tape: %s: disabling DSC overlap\n", 3558 tape->name); 3559 drive->dsc_overlap = 0; 3560 } 3561 /* Seagate Travan drives do not support DSC overlap. */ 3562 if (strstr(drive->id->model, "Seagate STT3401")) 3563 drive->dsc_overlap = 0; 3564 tape->minor = minor; 3565 tape->name[0] = 'h'; 3566 tape->name[1] = 't'; 3567 tape->name[2] = '0' + minor; 3568 tape->chrdev_dir = IDETAPE_DIR_NONE; 3569 tape->pc = tape->pc_stack; 3570 tape->max_insert_speed = 10000; 3571 tape->speed_control = 1; 3572 *((unsigned short *) &gcw) = drive->id->config; 3573 if (gcw.drq_type == 1) 3574 set_bit(IDETAPE_DRQ_INTERRUPT, &tape->flags); 3575 3576 tape->min_pipeline = tape->max_pipeline = tape->max_stages = 10; 3577 3578 idetape_get_inquiry_results(drive); 3579 idetape_get_mode_sense_results(drive); 3580 ide_tape_get_bsize_from_bdesc(drive); 3581 tape->user_bs_factor = 1; 3582 tape->stage_size = *ctl * tape->blk_size; 3583 while (tape->stage_size > 0xffff) { 3584 printk(KERN_NOTICE "ide-tape: decreasing stage size\n"); 3585 *ctl /= 2; 3586 tape->stage_size = *ctl * tape->blk_size; 3587 } 3588 stage_size = tape->stage_size; 3589 tape->pages_per_stage = stage_size / PAGE_SIZE; 3590 if (stage_size % PAGE_SIZE) { 3591 tape->pages_per_stage++; 3592 tape->excess_bh_size = PAGE_SIZE - stage_size % PAGE_SIZE; 3593 } 3594 3595 /* Select the "best" DSC read/write polling freq and pipeline size. */ 3596 speed = max(*(u16 *)&tape->caps[14], *(u16 *)&tape->caps[8]); 3597 3598 tape->max_stages = speed * 1000 * 10 / tape->stage_size; 3599 3600 /* 3601 * Limit memory use for pipeline to 10% of physical memory 3602 */ 3603 si_meminfo(&si); 3604 if (tape->max_stages * tape->stage_size > si.totalram * si.mem_unit / 10) 3605 tape->max_stages = si.totalram * si.mem_unit / (10 * tape->stage_size); 3606 tape->max_stages = min(tape->max_stages, IDETAPE_MAX_PIPELINE_STAGES); 3607 tape->min_pipeline = min(tape->max_stages, IDETAPE_MIN_PIPELINE_STAGES); 3608 tape->max_pipeline = min(tape->max_stages * 2, IDETAPE_MAX_PIPELINE_STAGES); 3609 if (tape->max_stages == 0) 3610 tape->max_stages = tape->min_pipeline = tape->max_pipeline = 1; 3611 3612 t1 = (tape->stage_size * HZ) / (speed * 1000); 3613 tmid = (*(u16 *)&tape->caps[16] * 32 * HZ) / (speed * 125); 3614 tn = (IDETAPE_FIFO_THRESHOLD * tape->stage_size * HZ) / (speed * 1000); 3615 3616 if (tape->max_stages) 3617 t = tn; 3618 else 3619 t = t1; 3620 3621 /* 3622 * Ensure that the number we got makes sense; limit 3623 * it within IDETAPE_DSC_RW_MIN and IDETAPE_DSC_RW_MAX. 3624 */ 3625 tape->best_dsc_rw_freq = max_t(unsigned long, 3626 min_t(unsigned long, t, IDETAPE_DSC_RW_MAX), 3627 IDETAPE_DSC_RW_MIN); 3628 printk(KERN_INFO "ide-tape: %s <-> %s: %dKBps, %d*%dkB buffer, " 3629 "%dkB pipeline, %lums tDSC%s\n", 3630 drive->name, tape->name, *(u16 *)&tape->caps[14], 3631 (*(u16 *)&tape->caps[16] * 512) / tape->stage_size, 3632 tape->stage_size / 1024, 3633 tape->max_stages * tape->stage_size / 1024, 3634 tape->best_dsc_rw_freq * 1000 / HZ, 3635 drive->using_dma ? ", DMA":""); 3636 3637 idetape_add_settings(drive); 3638} 3639 3640static void ide_tape_remove(ide_drive_t *drive) 3641{ 3642 idetape_tape_t *tape = drive->driver_data; 3643 3644 ide_proc_unregister_driver(drive, tape->driver); 3645 3646 ide_unregister_region(tape->disk); 3647 3648 ide_tape_put(tape); 3649} 3650 3651static void ide_tape_release(struct kref *kref) 3652{ 3653 struct ide_tape_obj *tape = to_ide_tape(kref); 3654 ide_drive_t *drive = tape->drive; 3655 struct gendisk *g = tape->disk; 3656 3657 BUG_ON(tape->first_stage != NULL || tape->merge_stage_size); 3658 3659 drive->dsc_overlap = 0; 3660 drive->driver_data = NULL; 3661 device_destroy(idetape_sysfs_class, MKDEV(IDETAPE_MAJOR, tape->minor)); 3662 device_destroy(idetape_sysfs_class, MKDEV(IDETAPE_MAJOR, tape->minor + 128)); 3663 idetape_devs[tape->minor] = NULL; 3664 g->private_data = NULL; 3665 put_disk(g); 3666 kfree(tape); 3667} 3668 3669#ifdef CONFIG_IDE_PROC_FS 3670static int proc_idetape_read_name 3671 (char *page, char **start, off_t off, int count, int *eof, void *data) 3672{ 3673 ide_drive_t *drive = (ide_drive_t *) data; 3674 idetape_tape_t *tape = drive->driver_data; 3675 char *out = page; 3676 int len; 3677 3678 len = sprintf(out, "%s\n", tape->name); 3679 PROC_IDE_READ_RETURN(page, start, off, count, eof, len); 3680} 3681 3682static ide_proc_entry_t idetape_proc[] = { 3683 { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL }, 3684 { "name", S_IFREG|S_IRUGO, proc_idetape_read_name, NULL }, 3685 { NULL, 0, NULL, NULL } 3686}; 3687#endif 3688 3689static int ide_tape_probe(ide_drive_t *); 3690 3691static ide_driver_t idetape_driver = { 3692 .gen_driver = { 3693 .owner = THIS_MODULE, 3694 .name = "ide-tape", 3695 .bus = &ide_bus_type, 3696 }, 3697 .probe = ide_tape_probe, 3698 .remove = ide_tape_remove, 3699 .version = IDETAPE_VERSION, 3700 .media = ide_tape, 3701 .supports_dsc_overlap = 1, 3702 .do_request = idetape_do_request, 3703 .end_request = idetape_end_request, 3704 .error = __ide_error, 3705 .abort = __ide_abort, 3706#ifdef CONFIG_IDE_PROC_FS 3707 .proc = idetape_proc, 3708#endif 3709}; 3710 3711/* 3712 * Our character device supporting functions, passed to register_chrdev. 3713 */ 3714static const struct file_operations idetape_fops = { 3715 .owner = THIS_MODULE, 3716 .read = idetape_chrdev_read, 3717 .write = idetape_chrdev_write, 3718 .ioctl = idetape_chrdev_ioctl, 3719 .open = idetape_chrdev_open, 3720 .release = idetape_chrdev_release, 3721}; 3722 3723static int idetape_open(struct inode *inode, struct file *filp) 3724{ 3725 struct gendisk *disk = inode->i_bdev->bd_disk; 3726 struct ide_tape_obj *tape; 3727 3728 if (!(tape = ide_tape_get(disk))) 3729 return -ENXIO; 3730 3731 return 0; 3732} 3733 3734static int idetape_release(struct inode *inode, struct file *filp) 3735{ 3736 struct gendisk *disk = inode->i_bdev->bd_disk; 3737 struct ide_tape_obj *tape = ide_tape_g(disk); 3738 3739 ide_tape_put(tape); 3740 3741 return 0; 3742} 3743 3744static int idetape_ioctl(struct inode *inode, struct file *file, 3745 unsigned int cmd, unsigned long arg) 3746{ 3747 struct block_device *bdev = inode->i_bdev; 3748 struct ide_tape_obj *tape = ide_tape_g(bdev->bd_disk); 3749 ide_drive_t *drive = tape->drive; 3750 int err = generic_ide_ioctl(drive, file, bdev, cmd, arg); 3751 if (err == -EINVAL) 3752 err = idetape_blkdev_ioctl(drive, cmd, arg); 3753 return err; 3754} 3755 3756static struct block_device_operations idetape_block_ops = { 3757 .owner = THIS_MODULE, 3758 .open = idetape_open, 3759 .release = idetape_release, 3760 .ioctl = idetape_ioctl, 3761}; 3762 3763static int ide_tape_probe(ide_drive_t *drive) 3764{ 3765 idetape_tape_t *tape; 3766 struct gendisk *g; 3767 int minor; 3768 3769 if (!strstr("ide-tape", drive->driver_req)) 3770 goto failed; 3771 if (!drive->present) 3772 goto failed; 3773 if (drive->media != ide_tape) 3774 goto failed; 3775 if (!idetape_identify_device (drive)) { 3776 printk(KERN_ERR "ide-tape: %s: not supported by this version of ide-tape\n", drive->name); 3777 goto failed; 3778 } 3779 if (drive->scsi) { 3780 printk("ide-tape: passing drive %s to ide-scsi emulation.\n", drive->name); 3781 goto failed; 3782 } 3783 if (strstr(drive->id->model, "OnStream DI-")) { 3784 printk(KERN_WARNING "ide-tape: Use drive %s with ide-scsi emulation and osst.\n", drive->name); 3785 printk(KERN_WARNING "ide-tape: OnStream support will be removed soon from ide-tape!\n"); 3786 } 3787 tape = kzalloc(sizeof (idetape_tape_t), GFP_KERNEL); 3788 if (tape == NULL) { 3789 printk(KERN_ERR "ide-tape: %s: Can't allocate a tape structure\n", drive->name); 3790 goto failed; 3791 } 3792 3793 g = alloc_disk(1 << PARTN_BITS); 3794 if (!g) 3795 goto out_free_tape; 3796 3797 ide_init_disk(g, drive); 3798 3799 ide_proc_register_driver(drive, &idetape_driver); 3800 3801 kref_init(&tape->kref); 3802 3803 tape->drive = drive; 3804 tape->driver = &idetape_driver; 3805 tape->disk = g; 3806 3807 g->private_data = &tape->driver; 3808 3809 drive->driver_data = tape; 3810 3811 mutex_lock(&idetape_ref_mutex); 3812 for (minor = 0; idetape_devs[minor]; minor++) 3813 ; 3814 idetape_devs[minor] = tape; 3815 mutex_unlock(&idetape_ref_mutex); 3816 3817 idetape_setup(drive, tape, minor); 3818 3819 device_create(idetape_sysfs_class, &drive->gendev, 3820 MKDEV(IDETAPE_MAJOR, minor), "%s", tape->name); 3821 device_create(idetape_sysfs_class, &drive->gendev, 3822 MKDEV(IDETAPE_MAJOR, minor + 128), "n%s", tape->name); 3823 3824 g->fops = &idetape_block_ops; 3825 ide_register_region(g); 3826 3827 return 0; 3828 3829out_free_tape: 3830 kfree(tape); 3831failed: 3832 return -ENODEV; 3833} 3834 3835MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver"); 3836MODULE_LICENSE("GPL"); 3837 3838static void __exit idetape_exit (void) 3839{ 3840 driver_unregister(&idetape_driver.gen_driver); 3841 class_destroy(idetape_sysfs_class); 3842 unregister_chrdev(IDETAPE_MAJOR, "ht"); 3843} 3844 3845static int __init idetape_init(void) 3846{ 3847 int error = 1; 3848 idetape_sysfs_class = class_create(THIS_MODULE, "ide_tape"); 3849 if (IS_ERR(idetape_sysfs_class)) { 3850 idetape_sysfs_class = NULL; 3851 printk(KERN_ERR "Unable to create sysfs class for ide tapes\n"); 3852 error = -EBUSY; 3853 goto out; 3854 } 3855 3856 if (register_chrdev(IDETAPE_MAJOR, "ht", &idetape_fops)) { 3857 printk(KERN_ERR "ide-tape: Failed to register character device interface\n"); 3858 error = -EBUSY; 3859 goto out_free_class; 3860 } 3861 3862 error = driver_register(&idetape_driver.gen_driver); 3863 if (error) 3864 goto out_free_driver; 3865 3866 return 0; 3867 3868out_free_driver: 3869 driver_unregister(&idetape_driver.gen_driver); 3870out_free_class: 3871 class_destroy(idetape_sysfs_class); 3872out: 3873 return error; 3874} 3875 3876MODULE_ALIAS("ide:*m-tape*"); 3877module_init(idetape_init); 3878module_exit(idetape_exit); 3879MODULE_ALIAS_CHARDEV_MAJOR(IDETAPE_MAJOR); 3880