drivers/s390/char/tape_core.c

   1 /*
   2  *  drivers/s390/char/tape_core.c
   3  *    basic function of the tape device driver
   4  *
   5  *  S390 and zSeries version
   6  *    Copyright IBM Corp. 2001, 2009
   7  *    Author(s): Carsten Otte <cotte@de.ibm.com>
   8  *               Michael Holzheu <holzheu@de.ibm.com>
   9  *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
  10  *               Martin Schwidefsky <schwidefsky@de.ibm.com>
  11  *               Stefan Bader <shbader@de.ibm.com>
  12  */
  13
  14 #define KMSG_COMPONENT "tape"
  15 #include <linux/module.h>
  16 #include <linux/init.h>      // for kernel parameters
  17 #include <linux/kmod.h>      // for requesting modules
  18 #include <linux/spinlock.h>  // for locks
  19 #include <linux/vmalloc.h>
  20 #include <linux/list.h>
  21
  22 #include <asm/types.h>       // for variable types
  23
  24 #define TAPE_DBF_AREA   tape_core_dbf
  25
  26 #include "tape.h"
  27 #include "tape_std.h"
  28
  29 #define LONG_BUSY_TIMEOUT 180 /* seconds */
  30
  31 static void __tape_do_irq (struct ccw_device *, unsigned long, struct irb *);
  32 static void tape_delayed_next_request(struct work_struct *);
  33 static void tape_long_busy_timeout(unsigned long data);
  34
  35 /*
  36  * One list to contain all tape devices of all disciplines, so
  37  * we can assign the devices to minor numbers of the same major
  38  * The list is protected by the rwlock
  39  */
  40 static LIST_HEAD(tape_device_list);
  41 static DEFINE_RWLOCK(tape_device_lock);
  42
  43 /*
  44  * Pointer to debug area.
  45  */
  46 debug_info_t *TAPE_DBF_AREA = NULL;
  47 EXPORT_SYMBOL(TAPE_DBF_AREA);
  48
  49 /*
  50  * Printable strings for tape enumerations.
  51  */
  52 const char *tape_state_verbose[TS_SIZE] =
  53 {
  54         [TS_UNUSED]   = "UNUSED",
  55         [TS_IN_USE]   = "IN_USE",
  56         [TS_BLKUSE]   = "BLKUSE",
  57         [TS_INIT]     = "INIT  ",
  58         [TS_NOT_OPER] = "NOT_OP"
  59 };
  60
  61 const char *tape_op_verbose[TO_SIZE] =
  62 {
  63         [TO_BLOCK] = "BLK",     [TO_BSB] = "BSB",
  64         [TO_BSF] = "BSF",       [TO_DSE] = "DSE",
  65         [TO_FSB] = "FSB",       [TO_FSF] = "FSF",
  66         [TO_LBL] = "LBL",       [TO_NOP] = "NOP",
  67         [TO_RBA] = "RBA",       [TO_RBI] = "RBI",
  68         [TO_RFO] = "RFO",       [TO_REW] = "REW",
  69         [TO_RUN] = "RUN",       [TO_WRI] = "WRI",
  70         [TO_WTM] = "WTM",       [TO_MSEN] = "MSN",
  71         [TO_LOAD] = "LOA",      [TO_READ_CONFIG] = "RCF",
  72         [TO_READ_ATTMSG] = "RAT",
  73         [TO_DIS] = "DIS",       [TO_ASSIGN] = "ASS",
  74         [TO_UNASSIGN] = "UAS",  [TO_CRYPT_ON] = "CON",
  75         [TO_CRYPT_OFF] = "COF", [TO_KEKL_SET] = "KLS",
  76         [TO_KEKL_QUERY] = "KLQ",[TO_RDC] = "RDC",
  77 };
  78
  79 static int devid_to_int(struct ccw_dev_id *dev_id)
  80 {
  81         return dev_id->devno + (dev_id->ssid << 16);
  82 }
  83
  84 /*
  85  * Some channel attached tape specific attributes.
  86  *
  87  * FIXME: In the future the first_minor and blocksize attribute should be
  88  *        replaced by a link to the cdev tree.
  89  */
  90 static ssize_t
  91 tape_medium_state_show(struct device *dev, struct device_attribute *attr, char *buf)
  92 {
  93         struct tape_device *tdev;
  94
  95         tdev = dev_get_drvdata(dev);
  96         return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->medium_state);
  97 }
  98
  99 static
 100 DEVICE_ATTR(medium_state, 0444, tape_medium_state_show, NULL);
 101
 102 static ssize_t
 103 tape_first_minor_show(struct device *dev, struct device_attribute *attr, char *buf)
 104 {
 105         struct tape_device *tdev;
 106
 107         tdev = dev_get_drvdata(dev);
 108         return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->first_minor);
 109 }
 110
 111 static
 112 DEVICE_ATTR(first_minor, 0444, tape_first_minor_show, NULL);
 113
 114 static ssize_t
 115 tape_state_show(struct device *dev, struct device_attribute *attr, char *buf)
 116 {
 117         struct tape_device *tdev;
 118
 119         tdev = dev_get_drvdata(dev);
 120         return scnprintf(buf, PAGE_SIZE, "%s\n", (tdev->first_minor < 0) ?
 121                 "OFFLINE" : tape_state_verbose[tdev->tape_state]);
 122 }
 123
 124 static
 125 DEVICE_ATTR(state, 0444, tape_state_show, NULL);
 126
 127 static ssize_t
 128 tape_operation_show(struct device *dev, struct device_attribute *attr, char *buf)
 129 {
 130         struct tape_device *tdev;
 131         ssize_t rc;
 132
 133         tdev = dev_get_drvdata(dev);
 134         if (tdev->first_minor < 0)
 135                 return scnprintf(buf, PAGE_SIZE, "N/A\n");
 136
 137         spin_lock_irq(get_ccwdev_lock(tdev->cdev));
 138         if (list_empty(&tdev->req_queue))
 139                 rc = scnprintf(buf, PAGE_SIZE, "---\n");
 140         else {
 141                 struct tape_request *req;
 142
 143                 req = list_entry(tdev->req_queue.next, struct tape_request,
 144                         list);
 145                 rc = scnprintf(buf,PAGE_SIZE, "%s\n", tape_op_verbose[req->op]);
 146         }
 147         spin_unlock_irq(get_ccwdev_lock(tdev->cdev));
 148         return rc;
 149 }
 150
 151 static
 152 DEVICE_ATTR(operation, 0444, tape_operation_show, NULL);
 153
 154 static ssize_t
 155 tape_blocksize_show(struct device *dev, struct device_attribute *attr, char *buf)
 156 {
 157         struct tape_device *tdev;
 158
 159         tdev = dev_get_drvdata(dev);
 160
 161         return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->char_data.block_size);
 162 }
 163
 164 static
 165 DEVICE_ATTR(blocksize, 0444, tape_blocksize_show, NULL);
 166
 167 static struct attribute *tape_attrs[] = {
 168         &dev_attr_medium_state.attr,
 169         &dev_attr_first_minor.attr,
 170         &dev_attr_state.attr,
 171         &dev_attr_operation.attr,
 172         &dev_attr_blocksize.attr,
 173         NULL
 174 };
 175
 176 static struct attribute_group tape_attr_group = {
 177         .attrs = tape_attrs,
 178 };
 179
 180 /*
 181  * Tape state functions
 182  */
 183 void
 184 tape_state_set(struct tape_device *device, enum tape_state newstate)
 185 {
 186         const char *str;
 187
 188         if (device->tape_state == TS_NOT_OPER) {
 189                 DBF_EVENT(3, "ts_set err: not oper\n");
 190                 return;
 191         }
 192         DBF_EVENT(4, "ts. dev:  %x\n", device->first_minor);
 193         DBF_EVENT(4, "old ts:\t\n");
 194         if (device->tape_state < TS_SIZE && device->tape_state >=0 )
 195                 str = tape_state_verbose[device->tape_state];
 196         else
 197                 str = "UNKNOWN TS";
 198         DBF_EVENT(4, "%s\n", str);
 199         DBF_EVENT(4, "new ts:\t\n");
 200         if (newstate < TS_SIZE && newstate >= 0)
 201                 str = tape_state_verbose[newstate];
 202         else
 203                 str = "UNKNOWN TS";
 204         DBF_EVENT(4, "%s\n", str);
 205         device->tape_state = newstate;
 206         wake_up(&device->state_change_wq);
 207 }
 208
 209 void
 210 tape_med_state_set(struct tape_device *device, enum tape_medium_state newstate)
 211 {
 212         if (device->medium_state == newstate)
 213                 return;
 214         switch(newstate){
 215         case MS_UNLOADED:
 216                 device->tape_generic_status |= GMT_DR_OPEN(~0);
 217                 dev_info(&device->cdev->dev, "The tape cartridge has been "
 218                         "successfully unloaded\n");
 219                 break;
 220         case MS_LOADED:
 221                 device->tape_generic_status &= ~GMT_DR_OPEN(~0);
 222                 dev_info(&device->cdev->dev, "A tape cartridge has been "
 223                         "mounted\n");
 224                 break;
 225         default:
 226                 // print nothing
 227                 break;
 228         }
 229         device->medium_state = newstate;
 230         wake_up(&device->state_change_wq);
 231 }
 232
 233 /*
 234  * Stop running ccw. Has to be called with the device lock held.
 235  */
 236 static int
 237 __tape_cancel_io(struct tape_device *device, struct tape_request *request)
 238 {
 239         int retries;
 240         int rc;
 241
 242         /* Check if interrupt has already been processed */
 243         if (request->callback == NULL)
 244                 return 0;
 245
 246         rc = 0;
 247         for (retries = 0; retries < 5; retries++) {
 248                 rc = ccw_device_clear(device->cdev, (long) request);
 249
 250                 switch (rc) {
 251                         case 0:
 252                                 request->status = TAPE_REQUEST_DONE;
 253                                 return 0;
 254                         case -EBUSY:
 255                                 request->status = TAPE_REQUEST_CANCEL;
 256                                 schedule_delayed_work(&device->tape_dnr, 0);
 257                                 return 0;
 258                         case -ENODEV:
 259                                 DBF_EXCEPTION(2, "device gone, retry\n");
 260                                 break;
 261                         case -EIO:
 262                                 DBF_EXCEPTION(2, "I/O error, retry\n");
 263                                 break;
 264                         default:
 265                                 BUG();
 266                 }
 267         }
 268
 269         return rc;
 270 }
 271
 272 /*
 273  * Add device into the sorted list, giving it the first
 274  * available minor number.
 275  */
 276 static int
 277 tape_assign_minor(struct tape_device *device)
 278 {
 279         struct tape_device *tmp;
 280         int minor;
 281
 282         minor = 0;
 283         write_lock(&tape_device_lock);
 284         list_for_each_entry(tmp, &tape_device_list, node) {
 285                 if (minor < tmp->first_minor)
 286                         break;
 287                 minor += TAPE_MINORS_PER_DEV;
 288         }
 289         if (minor >= 256) {
 290                 write_unlock(&tape_device_lock);
 291                 return -ENODEV;
 292         }
 293         device->first_minor = minor;
 294         list_add_tail(&device->node, &tmp->node);
 295         write_unlock(&tape_device_lock);
 296         return 0;
 297 }
 298
 299 /* remove device from the list */
 300 static void
 301 tape_remove_minor(struct tape_device *device)
 302 {
 303         write_lock(&tape_device_lock);
 304         list_del_init(&device->node);
 305         device->first_minor = -1;
 306         write_unlock(&tape_device_lock);
 307 }
 308
 309 /*
 310  * Set a device online.
 311  *
 312  * This function is called by the common I/O layer to move a device from the
 313  * detected but offline into the online state.
 314  * If we return an error (RC < 0) the device remains in the offline state. This
 315  * can happen if the device is assigned somewhere else, for example.
 316  */
 317 int
 318 tape_generic_online(struct tape_device *device,
 319                    struct tape_discipline *discipline)
 320 {
 321         int rc;
 322
 323         DBF_LH(6, "tape_enable_device(%p, %p)\n", device, discipline);
 324
 325         if (device->tape_state != TS_INIT) {
 326                 DBF_LH(3, "Tapestate not INIT (%d)\n", device->tape_state);
 327                 return -EINVAL;
 328         }
 329
 330         init_timer(&device->lb_timeout);
 331         device->lb_timeout.function = tape_long_busy_timeout;
 332
 333         /* Let the discipline have a go at the device. */
 334         device->discipline = discipline;
 335         if (!try_module_get(discipline->owner)) {
 336                 return -EINVAL;
 337         }
 338
 339         rc = discipline->setup_device(device);
 340         if (rc)
 341                 goto out;
 342         rc = tape_assign_minor(device);
 343         if (rc)
 344                 goto out_discipline;
 345
 346         rc = tapechar_setup_device(device);
 347         if (rc)
 348                 goto out_minor;
 349         rc = tapeblock_setup_device(device);
 350         if (rc)
 351                 goto out_char;
 352
 353         tape_state_set(device, TS_UNUSED);
 354
 355         DBF_LH(3, "(%08x): Drive set online\n", device->cdev_id);
 356
 357         return 0;
 358
 359 out_char:
 360         tapechar_cleanup_device(device);
 361 out_discipline:
 362         device->discipline->cleanup_device(device);
 363         device->discipline = NULL;
 364 out_minor:
 365         tape_remove_minor(device);
 366 out:
 367         module_put(discipline->owner);
 368         return rc;
 369 }
 370
 371 static void
 372 tape_cleanup_device(struct tape_device *device)
 373 {
 374         tapeblock_cleanup_device(device);
 375         tapechar_cleanup_device(device);
 376         device->discipline->cleanup_device(device);
 377         module_put(device->discipline->owner);
 378         tape_remove_minor(device);
 379         tape_med_state_set(device, MS_UNKNOWN);
 380 }
 381
 382 /*
 383  * Suspend device.
 384  *
 385  * Called by the common I/O layer if the drive should be suspended on user
 386  * request. We refuse to suspend if the device is loaded or in use for the
 387  * following reason:
 388  * While the Linux guest is suspended, it might be logged off which causes
 389  * devices to be detached. Tape devices are automatically rewound and unloaded
 390  * during DETACH processing (unless the tape device was attached with the
 391  * NOASSIGN or MULTIUSER option). After rewind/unload, there is no way to
 392  * resume the original state of the tape device, since we would need to
 393  * manually re-load the cartridge which was active at suspend time.
 394  */
 395 int tape_generic_pm_suspend(struct ccw_device *cdev)
 396 {
 397         struct tape_device *device;
 398
 399         device = cdev->dev.driver_data;
 400         if (!device) {
 401                 return -ENODEV;
 402         }
 403
 404         DBF_LH(3, "(%08x): tape_generic_pm_suspend(%p)\n",
 405                 device->cdev_id, device);
 406
 407         if (device->medium_state != MS_UNLOADED) {
 408                 pr_err("A cartridge is loaded in tape device %s, "
 409                        "refusing to suspend\n", dev_name(&cdev->dev));
 410                 return -EBUSY;
 411         }
 412
 413         spin_lock_irq(get_ccwdev_lock(device->cdev));
 414         switch (device->tape_state) {
 415                 case TS_INIT:
 416                 case TS_NOT_OPER:
 417                 case TS_UNUSED:
 418                         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 419                         break;
 420                 default:
 421                         pr_err("Tape device %s is busy, refusing to "
 422                                "suspend\n", dev_name(&cdev->dev));
 423                         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 424                         return -EBUSY;
 425         }
 426
 427         DBF_LH(3, "(%08x): Drive suspended.\n", device->cdev_id);
 428         return 0;
 429 }
 430
 431 /*
 432  * Set device offline.
 433  *
 434  * Called by the common I/O layer if the drive should set offline on user
 435  * request. We may prevent this by returning an error.
 436  * Manual offline is only allowed while the drive is not in use.
 437  */
 438 int
 439 tape_generic_offline(struct ccw_device *cdev)
 440 {
 441         struct tape_device *device;
 442
 443         device = dev_get_drvdata(&cdev->dev);
 444         if (!device) {
 445                 return -ENODEV;
 446         }
 447
 448         DBF_LH(3, "(%08x): tape_generic_offline(%p)\n",
 449                 device->cdev_id, device);
 450
 451         spin_lock_irq(get_ccwdev_lock(device->cdev));
 452         switch (device->tape_state) {
 453                 case TS_INIT:
 454                 case TS_NOT_OPER:
 455                         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 456                         break;
 457                 case TS_UNUSED:
 458                         tape_state_set(device, TS_INIT);
 459                         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 460                         tape_cleanup_device(device);
 461                         break;
 462                 default:
 463                         DBF_EVENT(3, "(%08x): Set offline failed "
 464                                 "- drive in use.\n",
 465                                 device->cdev_id);
 466                         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 467                         return -EBUSY;
 468         }
 469
 470         DBF_LH(3, "(%08x): Drive set offline.\n", device->cdev_id);
 471         return 0;
 472 }
 473
 474 /*
 475  * Allocate memory for a new device structure.
 476  */
 477 static struct tape_device *
 478 tape_alloc_device(void)
 479 {
 480         struct tape_device *device;
 481
 482         device = kzalloc(sizeof(struct tape_device), GFP_KERNEL);
 483         if (device == NULL) {
 484                 DBF_EXCEPTION(2, "ti:no mem\n");
 485                 return ERR_PTR(-ENOMEM);
 486         }
 487         device->modeset_byte = kmalloc(1, GFP_KERNEL | GFP_DMA);
 488         if (device->modeset_byte == NULL) {
 489                 DBF_EXCEPTION(2, "ti:no mem\n");
 490                 kfree(device);
 491                 return ERR_PTR(-ENOMEM);
 492         }
 493         INIT_LIST_HEAD(&device->req_queue);
 494         INIT_LIST_HEAD(&device->node);
 495         init_waitqueue_head(&device->state_change_wq);
 496         init_waitqueue_head(&device->wait_queue);
 497         device->tape_state = TS_INIT;
 498         device->medium_state = MS_UNKNOWN;
 499         *device->modeset_byte = 0;
 500         device->first_minor = -1;
 501         atomic_set(&device->ref_count, 1);
 502         INIT_DELAYED_WORK(&device->tape_dnr, tape_delayed_next_request);
 503
 504         return device;
 505 }
 506
 507 /*
 508  * Get a reference to an existing device structure. This will automatically
 509  * increment the reference count.
 510  */
 511 struct tape_device *
 512 tape_get_device_reference(struct tape_device *device)
 513 {
 514         DBF_EVENT(4, "tape_get_device_reference(%p) = %i\n", device,
 515                 atomic_inc_return(&device->ref_count));
 516
 517         return device;
 518 }
 519
 520 /*
 521  * Decrease the reference counter of a devices structure. If the
 522  * reference counter reaches zero free the device structure.
 523  * The function returns a NULL pointer to be used by the caller
 524  * for clearing reference pointers.
 525  */
 526 struct tape_device *
 527 tape_put_device(struct tape_device *device)
 528 {
 529         int remain;
 530
 531         remain = atomic_dec_return(&device->ref_count);
 532         if (remain > 0) {
 533                 DBF_EVENT(4, "tape_put_device(%p) -> %i\n", device, remain);
 534         } else {
 535                 if (remain < 0) {
 536                         DBF_EVENT(4, "put device without reference\n");
 537                 } else {
 538                         DBF_EVENT(4, "tape_free_device(%p)\n", device);
 539                         kfree(device->modeset_byte);
 540                         kfree(device);
 541                 }
 542         }
 543
 544         return NULL;
 545 }
 546
 547 /*
 548  * Find tape device by a device index.
 549  */
 550 struct tape_device *
 551 tape_get_device(int devindex)
 552 {
 553         struct tape_device *device, *tmp;
 554
 555         device = ERR_PTR(-ENODEV);
 556         read_lock(&tape_device_lock);
 557         list_for_each_entry(tmp, &tape_device_list, node) {
 558                 if (tmp->first_minor / TAPE_MINORS_PER_DEV == devindex) {
 559                         device = tape_get_device_reference(tmp);
 560                         break;
 561                 }
 562         }
 563         read_unlock(&tape_device_lock);
 564         return device;
 565 }
 566
 567 /*
 568  * Driverfs tape probe function.
 569  */
 570 int
 571 tape_generic_probe(struct ccw_device *cdev)
 572 {
 573         struct tape_device *device;
 574         int ret;
 575         struct ccw_dev_id dev_id;
 576
 577         device = tape_alloc_device();
 578         if (IS_ERR(device))
 579                 return -ENODEV;
 580         ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP);
 581         ret = sysfs_create_group(&cdev->dev.kobj, &tape_attr_group);
 582         if (ret) {
 583                 tape_put_device(device);
 584                 return ret;
 585         }
 586         dev_set_drvdata(&cdev->dev, device);
 587         cdev->handler = __tape_do_irq;
 588         device->cdev = cdev;
 589         ccw_device_get_id(cdev, &dev_id);
 590         device->cdev_id = devid_to_int(&dev_id);
 591         return ret;
 592 }
 593
 594 static void
 595 __tape_discard_requests(struct tape_device *device)
 596 {
 597         struct tape_request *   request;
 598         struct list_head *      l, *n;
 599
 600         list_for_each_safe(l, n, &device->req_queue) {
 601                 request = list_entry(l, struct tape_request, list);
 602                 if (request->status == TAPE_REQUEST_IN_IO)
 603                         request->status = TAPE_REQUEST_DONE;
 604                 list_del(&request->list);
 605
 606                 /* Decrease ref_count for removed request. */
 607                 request->device = tape_put_device(device);
 608                 request->rc = -EIO;
 609                 if (request->callback != NULL)
 610                         request->callback(request, request->callback_data);
 611         }
 612 }
 613
 614 /*
 615  * Driverfs tape remove function.
 616  *
 617  * This function is called whenever the common I/O layer detects the device
 618  * gone. This can happen at any time and we cannot refuse.
 619  */
 620 void
 621 tape_generic_remove(struct ccw_device *cdev)
 622 {
 623         struct tape_device *    device;
 624
 625         device = dev_get_drvdata(&cdev->dev);
 626         if (!device) {
 627                 return;
 628         }
 629         DBF_LH(3, "(%08x): tape_generic_remove(%p)\n", device->cdev_id, cdev);
 630
 631         spin_lock_irq(get_ccwdev_lock(device->cdev));
 632         switch (device->tape_state) {
 633                 case TS_INIT:
 634                         tape_state_set(device, TS_NOT_OPER);
 635                 case TS_NOT_OPER:
 636                         /*
 637                          * Nothing to do.
 638                          */
 639                         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 640                         break;
 641                 case TS_UNUSED:
 642                         /*
 643                          * Need only to release the device.
 644                          */
 645                         tape_state_set(device, TS_NOT_OPER);
 646                         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 647                         tape_cleanup_device(device);
 648                         break;
 649                 default:
 650                         /*
 651                          * There may be requests on the queue. We will not get
 652                          * an interrupt for a request that was running. So we
 653                          * just post them all as I/O errors.
 654                          */
 655                         DBF_EVENT(3, "(%08x): Drive in use vanished!\n",
 656                                 device->cdev_id);
 657                         dev_warn(&device->cdev->dev, "A tape unit was detached"
 658                                 " while in use\n");
 659                         tape_state_set(device, TS_NOT_OPER);
 660                         __tape_discard_requests(device);
 661                         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 662                         tape_cleanup_device(device);
 663         }
 664
 665         if (!dev_get_drvdata(&cdev->dev)) {
 666                 sysfs_remove_group(&cdev->dev.kobj, &tape_attr_group);
 667                 dev_set_drvdata(&cdev->dev, tape_put_device(dev_get_drvdata(&cdev->dev)));
 668         }
 669 }
 670
 671 /*
 672  * Allocate a new tape ccw request
 673  */
 674 struct tape_request *
 675 tape_alloc_request(int cplength, int datasize)
 676 {
 677         struct tape_request *request;
 678
 679         BUG_ON(datasize > PAGE_SIZE || (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
 680
 681         DBF_LH(6, "tape_alloc_request(%d, %d)\n", cplength, datasize);
 682
 683         request = kzalloc(sizeof(struct tape_request), GFP_KERNEL);
 684         if (request == NULL) {
 685                 DBF_EXCEPTION(1, "cqra nomem\n");
 686                 return ERR_PTR(-ENOMEM);
 687         }
 688         /* allocate channel program */
 689         if (cplength > 0) {
 690                 request->cpaddr = kcalloc(cplength, sizeof(struct ccw1),
 691                                           GFP_ATOMIC | GFP_DMA);
 692                 if (request->cpaddr == NULL) {
 693                         DBF_EXCEPTION(1, "cqra nomem\n");
 694                         kfree(request);
 695                         return ERR_PTR(-ENOMEM);
 696                 }
 697         }
 698         /* alloc small kernel buffer */
 699         if (datasize > 0) {
 700                 request->cpdata = kzalloc(datasize, GFP_KERNEL | GFP_DMA);
 701                 if (request->cpdata == NULL) {
 702                         DBF_EXCEPTION(1, "cqra nomem\n");
 703                         kfree(request->cpaddr);
 704                         kfree(request);
 705                         return ERR_PTR(-ENOMEM);
 706                 }
 707         }
 708         DBF_LH(6, "New request %p(%p/%p)\n", request, request->cpaddr,
 709                 request->cpdata);
 710
 711         return request;
 712 }
 713
 714 /*
 715  * Free tape ccw request
 716  */
 717 void
 718 tape_free_request (struct tape_request * request)
 719 {
 720         DBF_LH(6, "Free request %p\n", request);
 721
 722         if (request->device != NULL) {
 723                 request->device = tape_put_device(request->device);
 724         }
 725         kfree(request->cpdata);
 726         kfree(request->cpaddr);
 727         kfree(request);
 728 }
 729
 730 static int
 731 __tape_start_io(struct tape_device *device, struct tape_request *request)
 732 {
 733         int rc;
 734
 735 #ifdef CONFIG_S390_TAPE_BLOCK
 736         if (request->op == TO_BLOCK)
 737                 device->discipline->check_locate(device, request);
 738 #endif
 739         rc = ccw_device_start(
 740                 device->cdev,
 741                 request->cpaddr,
 742                 (unsigned long) request,
 743                 0x00,
 744                 request->options
 745         );
 746         if (rc == 0) {
 747                 request->status = TAPE_REQUEST_IN_IO;
 748         } else if (rc == -EBUSY) {
 749                 /* The common I/O subsystem is currently busy. Retry later. */
 750                 request->status = TAPE_REQUEST_QUEUED;
 751                 schedule_delayed_work(&device->tape_dnr, 0);
 752                 rc = 0;
 753         } else {
 754                 /* Start failed. Remove request and indicate failure. */
 755                 DBF_EVENT(1, "tape: start request failed with RC = %i\n", rc);
 756         }
 757         return rc;
 758 }
 759
 760 static void
 761 __tape_start_next_request(struct tape_device *device)
 762 {
 763         struct list_head *l, *n;
 764         struct tape_request *request;
 765         int rc;
 766
 767         DBF_LH(6, "__tape_start_next_request(%p)\n", device);
 768         /*
 769          * Try to start each request on request queue until one is
 770          * started successful.
 771          */
 772         list_for_each_safe(l, n, &device->req_queue) {
 773                 request = list_entry(l, struct tape_request, list);
 774
 775                 /*
 776                  * Avoid race condition if bottom-half was triggered more than
 777                  * once.
 778                  */
 779                 if (request->status == TAPE_REQUEST_IN_IO)
 780                         return;
 781                 /*
 782                  * Request has already been stopped. We have to wait until
 783                  * the request is removed from the queue in the interrupt
 784                  * handling.
 785                  */
 786                 if (request->status == TAPE_REQUEST_DONE)
 787                         return;
 788
 789                 /*
 790                  * We wanted to cancel the request but the common I/O layer
 791                  * was busy at that time. This can only happen if this
 792                  * function is called by delayed_next_request.
 793                  * Otherwise we start the next request on the queue.
 794                  */
 795                 if (request->status == TAPE_REQUEST_CANCEL) {
 796                         rc = __tape_cancel_io(device, request);
 797                 } else {
 798                         rc = __tape_start_io(device, request);
 799                 }
 800                 if (rc == 0)
 801                         return;
 802
 803                 /* Set ending status. */
 804                 request->rc = rc;
 805                 request->status = TAPE_REQUEST_DONE;
 806
 807                 /* Remove from request queue. */
 808                 list_del(&request->list);
 809
 810                 /* Do callback. */
 811                 if (request->callback != NULL)
 812                         request->callback(request, request->callback_data);
 813         }
 814 }
 815
 816 static void
 817 tape_delayed_next_request(struct work_struct *work)
 818 {
 819         struct tape_device *device =
 820                 container_of(work, struct tape_device, tape_dnr.work);
 821
 822         DBF_LH(6, "tape_delayed_next_request(%p)\n", device);
 823         spin_lock_irq(get_ccwdev_lock(device->cdev));
 824         __tape_start_next_request(device);
 825         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 826 }
 827
 828 static void tape_long_busy_timeout(unsigned long data)
 829 {
 830         struct tape_request *request;
 831         struct tape_device *device;
 832
 833         device = (struct tape_device *) data;
 834         spin_lock_irq(get_ccwdev_lock(device->cdev));
 835         request = list_entry(device->req_queue.next, struct tape_request, list);
 836         BUG_ON(request->status != TAPE_REQUEST_LONG_BUSY);
 837         DBF_LH(6, "%08x: Long busy timeout.\n", device->cdev_id);
 838         __tape_start_next_request(device);
 839         device->lb_timeout.data = (unsigned long) tape_put_device(device);
 840         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 841 }
 842
 843 static void
 844 __tape_end_request(
 845         struct tape_device *    device,
 846         struct tape_request *   request,
 847         int                     rc)
 848 {
 849         DBF_LH(6, "__tape_end_request(%p, %p, %i)\n", device, request, rc);
 850         if (request) {
 851                 request->rc = rc;
 852                 request->status = TAPE_REQUEST_DONE;
 853
 854                 /* Remove from request queue. */
 855                 list_del(&request->list);
 856
 857                 /* Do callback. */
 858                 if (request->callback != NULL)
 859                         request->callback(request, request->callback_data);
 860         }
 861
 862         /* Start next request. */
 863         if (!list_empty(&device->req_queue))
 864                 __tape_start_next_request(device);
 865 }
 866
 867 /*
 868  * Write sense data to dbf
 869  */
 870 void
 871 tape_dump_sense_dbf(struct tape_device *device, struct tape_request *request,
 872                     struct irb *irb)
 873 {
 874         unsigned int *sptr;
 875         const char* op;
 876
 877         if (request != NULL)
 878                 op = tape_op_verbose[request->op];
 879         else
 880                 op = "---";
 881         DBF_EVENT(3, "DSTAT : %02x   CSTAT: %02x\n",
 882                   irb->scsw.cmd.dstat, irb->scsw.cmd.cstat);
 883         DBF_EVENT(3, "DEVICE: %08x OP\t: %s\n", device->cdev_id, op);
 884         sptr = (unsigned int *) irb->ecw;
 885         DBF_EVENT(3, "%08x %08x\n", sptr[0], sptr[1]);
 886         DBF_EVENT(3, "%08x %08x\n", sptr[2], sptr[3]);
 887         DBF_EVENT(3, "%08x %08x\n", sptr[4], sptr[5]);
 888         DBF_EVENT(3, "%08x %08x\n", sptr[6], sptr[7]);
 889 }
 890
 891 /*
 892  * I/O helper function. Adds the request to the request queue
 893  * and starts it if the tape is idle. Has to be called with
 894  * the device lock held.
 895  */
 896 static int
 897 __tape_start_request(struct tape_device *device, struct tape_request *request)
 898 {
 899         int rc;
 900
 901         switch (request->op) {
 902                 case TO_MSEN:
 903                 case TO_ASSIGN:
 904                 case TO_UNASSIGN:
 905                 case TO_READ_ATTMSG:
 906                 case TO_RDC:
 907                         if (device->tape_state == TS_INIT)
 908                                 break;
 909                         if (device->tape_state == TS_UNUSED)
 910                                 break;
 911                 default:
 912                         if (device->tape_state == TS_BLKUSE)
 913                                 break;
 914                         if (device->tape_state != TS_IN_USE)
 915                                 return -ENODEV;
 916         }
 917
 918         /* Increase use count of device for the added request. */
 919         request->device = tape_get_device_reference(device);
 920
 921         if (list_empty(&device->req_queue)) {
 922                 /* No other requests are on the queue. Start this one. */
 923                 rc = __tape_start_io(device, request);
 924                 if (rc)
 925                         return rc;
 926
 927                 DBF_LH(5, "Request %p added for execution.\n", request);
 928                 list_add(&request->list, &device->req_queue);
 929         } else {
 930                 DBF_LH(5, "Request %p add to queue.\n", request);
 931                 request->status = TAPE_REQUEST_QUEUED;
 932                 list_add_tail(&request->list, &device->req_queue);
 933         }
 934         return 0;
 935 }
 936
 937 /*
 938  * Add the request to the request queue, try to start it if the
 939  * tape is idle. Return without waiting for end of i/o.
 940  */
 941 int
 942 tape_do_io_async(struct tape_device *device, struct tape_request *request)
 943 {
 944         int rc;
 945
 946         DBF_LH(6, "tape_do_io_async(%p, %p)\n", device, request);
 947
 948         spin_lock_irq(get_ccwdev_lock(device->cdev));
 949         /* Add request to request queue and try to start it. */
 950         rc = __tape_start_request(device, request);
 951         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 952         return rc;
 953 }
 954
 955 /*
 956  * tape_do_io/__tape_wake_up
 957  * Add the request to the request queue, try to start it if the
 958  * tape is idle and wait uninterruptible for its completion.
 959  */
 960 static void
 961 __tape_wake_up(struct tape_request *request, void *data)
 962 {
 963         request->callback = NULL;
 964         wake_up((wait_queue_head_t *) data);
 965 }
 966
 967 int
 968 tape_do_io(struct tape_device *device, struct tape_request *request)
 969 {
 970         int rc;
 971
 972         spin_lock_irq(get_ccwdev_lock(device->cdev));
 973         /* Setup callback */
 974         request->callback = __tape_wake_up;
 975         request->callback_data = &device->wait_queue;
 976         /* Add request to request queue and try to start it. */
 977         rc = __tape_start_request(device, request);
 978         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 979         if (rc)
 980                 return rc;
 981         /* Request added to the queue. Wait for its completion. */
 982         wait_event(device->wait_queue, (request->callback == NULL));
 983         /* Get rc from request */
 984         return request->rc;
 985 }
 986
 987 /*
 988  * tape_do_io_interruptible/__tape_wake_up_interruptible
 989  * Add the request to the request queue, try to start it if the
 990  * tape is idle and wait uninterruptible for its completion.
 991  */
 992 static void
 993 __tape_wake_up_interruptible(struct tape_request *request, void *data)
 994 {
 995         request->callback = NULL;
 996         wake_up_interruptible((wait_queue_head_t *) data);
 997 }
 998
 999 int
1000 tape_do_io_interruptible(struct tape_device *device,
1001                          struct tape_request *request)
1002 {
1003         int rc;
1004
1005         spin_lock_irq(get_ccwdev_lock(device->cdev));
1006         /* Setup callback */
1007         request->callback = __tape_wake_up_interruptible;
1008         request->callback_data = &device->wait_queue;
1009         rc = __tape_start_request(device, request);
1010         spin_unlock_irq(get_ccwdev_lock(device->cdev));
1011         if (rc)
1012                 return rc;
1013         /* Request added to the queue. Wait for its completion. */
1014         rc = wait_event_interruptible(device->wait_queue,
1015                                       (request->callback == NULL));
1016         if (rc != -ERESTARTSYS)
1017                 /* Request finished normally. */
1018                 return request->rc;
1019
1020         /* Interrupted by a signal. We have to stop the current request. */
1021         spin_lock_irq(get_ccwdev_lock(device->cdev));
1022         rc = __tape_cancel_io(device, request);
1023         spin_unlock_irq(get_ccwdev_lock(device->cdev));
1024         if (rc == 0) {
1025                 /* Wait for the interrupt that acknowledges the halt. */
1026                 do {
1027                         rc = wait_event_interruptible(
1028                                 device->wait_queue,
1029                                 (request->callback == NULL)
1030                         );
1031                 } while (rc == -ERESTARTSYS);
1032
1033                 DBF_EVENT(3, "IO stopped on %08x\n", device->cdev_id);
1034                 rc = -ERESTARTSYS;
1035         }
1036         return rc;
1037 }
1038
1039 /*
1040  * Stop running ccw.
1041  */
1042 int
1043 tape_cancel_io(struct tape_device *device, struct tape_request *request)
1044 {
1045         int rc;
1046
1047         spin_lock_irq(get_ccwdev_lock(device->cdev));
1048         rc = __tape_cancel_io(device, request);
1049         spin_unlock_irq(get_ccwdev_lock(device->cdev));
1050         return rc;
1051 }
1052
1053 /*
1054  * Tape interrupt routine, called from the ccw_device layer
1055  */
1056 static void
1057 __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1058 {
1059         struct tape_device *device;
1060         struct tape_request *request;
1061         int rc;
1062
1063         device = dev_get_drvdata(&cdev->dev);
1064         if (device == NULL) {
1065                 return;
1066         }
1067         request = (struct tape_request *) intparm;
1068
1069         DBF_LH(6, "__tape_do_irq(device=%p, request=%p)\n", device, request);
1070
1071         /* On special conditions irb is an error pointer */
1072         if (IS_ERR(irb)) {
1073                 /* FIXME: What to do with the request? */
1074                 switch (PTR_ERR(irb)) {
1075                         case -ETIMEDOUT:
1076                                 DBF_LH(1, "(%s): Request timed out\n",
1077                                         dev_name(&cdev->dev));
1078                         case -EIO:
1079                                 __tape_end_request(device, request, -EIO);
1080                                 break;
1081                         default:
1082                                 DBF_LH(1, "(%s): Unexpected i/o error %li\n",
1083                                         dev_name(&cdev->dev),
1084                                         PTR_ERR(irb));
1085                 }
1086                 return;
1087         }
1088
1089         /*
1090          * If the condition code is not zero and the start function bit is
1091          * still set, this is an deferred error and the last start I/O did
1092          * not succeed. At this point the condition that caused the deferred
1093          * error might still apply. So we just schedule the request to be
1094          * started later.
1095          */
1096         if (irb->scsw.cmd.cc != 0 &&
1097             (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
1098             (request->status == TAPE_REQUEST_IN_IO)) {
1099                 DBF_EVENT(3,"(%08x): deferred cc=%i, fctl=%i. restarting\n",
1100                         device->cdev_id, irb->scsw.cmd.cc, irb->scsw.cmd.fctl);
1101                 request->status = TAPE_REQUEST_QUEUED;
1102                 schedule_delayed_work(&device->tape_dnr, HZ);
1103                 return;
1104         }
1105
1106         /* May be an unsolicited irq */
1107         if(request != NULL)
1108                 request->rescnt = irb->scsw.cmd.count;
1109         else if ((irb->scsw.cmd.dstat == 0x85 || irb->scsw.cmd.dstat == 0x80) &&
1110                  !list_empty(&device->req_queue)) {
1111                 /* Not Ready to Ready after long busy ? */
1112                 struct tape_request *req;
1113                 req = list_entry(device->req_queue.next,
1114                                  struct tape_request, list);
1115                 if (req->status == TAPE_REQUEST_LONG_BUSY) {
1116                         DBF_EVENT(3, "(%08x): del timer\n", device->cdev_id);
1117                         if (del_timer(&device->lb_timeout)) {
1118                                 device->lb_timeout.data = (unsigned long)
1119                                         tape_put_device(device);
1120                                 __tape_start_next_request(device);
1121                         }
1122                         return;
1123                 }
1124         }
1125         if (irb->scsw.cmd.dstat != 0x0c) {
1126                 /* Set the 'ONLINE' flag depending on sense byte 1 */
1127                 if(*(((__u8 *) irb->ecw) + 1) & SENSE_DRIVE_ONLINE)
1128                         device->tape_generic_status |= GMT_ONLINE(~0);
1129                 else
1130                         device->tape_generic_status &= ~GMT_ONLINE(~0);
1131
1132                 /*
1133                  * Any request that does not come back with channel end
1134                  * and device end is unusual. Log the sense data.
1135                  */
1136                 DBF_EVENT(3,"-- Tape Interrupthandler --\n");
1137                 tape_dump_sense_dbf(device, request, irb);
1138         } else {
1139                 /* Upon normal completion the device _is_ online */
1140                 device->tape_generic_status |= GMT_ONLINE(~0);
1141         }
1142         if (device->tape_state == TS_NOT_OPER) {
1143                 DBF_EVENT(6, "tape:device is not operational\n");
1144                 return;
1145         }
1146
1147         /*
1148          * Request that were canceled still come back with an interrupt.
1149          * To detect these request the state will be set to TAPE_REQUEST_DONE.
1150          */
1151         if(request != NULL && request->status == TAPE_REQUEST_DONE) {
1152                 __tape_end_request(device, request, -EIO);
1153                 return;
1154         }
1155
1156         rc = device->discipline->irq(device, request, irb);
1157         /*
1158          * rc < 0 : request finished unsuccessfully.
1159          * rc == TAPE_IO_SUCCESS: request finished successfully.
1160          * rc == TAPE_IO_PENDING: request is still running. Ignore rc.
1161          * rc == TAPE_IO_RETRY: request finished but needs another go.
1162          * rc == TAPE_IO_STOP: request needs to get terminated.
1163          */
1164         switch (rc) {
1165                 case TAPE_IO_SUCCESS:
1166                         /* Upon normal completion the device _is_ online */
1167                         device->tape_generic_status |= GMT_ONLINE(~0);
1168                         __tape_end_request(device, request, rc);
1169                         break;
1170                 case TAPE_IO_PENDING:
1171                         break;
1172                 case TAPE_IO_LONG_BUSY:
1173                         device->lb_timeout.data =
1174                                 (unsigned long)tape_get_device_reference(device);
1175                         device->lb_timeout.expires = jiffies +
1176                                 LONG_BUSY_TIMEOUT * HZ;
1177                         DBF_EVENT(3, "(%08x): add timer\n", device->cdev_id);
1178                         add_timer(&device->lb_timeout);
1179                         request->status = TAPE_REQUEST_LONG_BUSY;
1180                         break;
1181                 case TAPE_IO_RETRY:
1182                         rc = __tape_start_io(device, request);
1183                         if (rc)
1184                                 __tape_end_request(device, request, rc);
1185                         break;
1186                 case TAPE_IO_STOP:
1187                         rc = __tape_cancel_io(device, request);
1188                         if (rc)
1189                                 __tape_end_request(device, request, rc);
1190                         break;
1191                 default:
1192                         if (rc > 0) {
1193                                 DBF_EVENT(6, "xunknownrc\n");
1194                                 __tape_end_request(device, request, -EIO);
1195                         } else {
1196                                 __tape_end_request(device, request, rc);
1197                         }
1198                         break;
1199         }
1200 }
1201
1202 /*
1203  * Tape device open function used by tape_char & tape_block frontends.
1204  */
1205 int
1206 tape_open(struct tape_device *device)
1207 {
1208         int rc;
1209
1210         spin_lock_irq(get_ccwdev_lock(device->cdev));
1211         if (device->tape_state == TS_NOT_OPER) {
1212                 DBF_EVENT(6, "TAPE:nodev\n");
1213                 rc = -ENODEV;
1214         } else if (device->tape_state == TS_IN_USE) {
1215                 DBF_EVENT(6, "TAPE:dbusy\n");
1216                 rc = -EBUSY;
1217         } else if (device->tape_state == TS_BLKUSE) {
1218                 DBF_EVENT(6, "TAPE:dbusy\n");
1219                 rc = -EBUSY;
1220         } else if (device->discipline != NULL &&
1221                    !try_module_get(device->discipline->owner)) {
1222                 DBF_EVENT(6, "TAPE:nodisc\n");
1223                 rc = -ENODEV;
1224         } else {
1225                 tape_state_set(device, TS_IN_USE);
1226                 rc = 0;
1227         }
1228         spin_unlock_irq(get_ccwdev_lock(device->cdev));
1229         return rc;
1230 }
1231
1232 /*
1233  * Tape device release function used by tape_char & tape_block frontends.
1234  */
1235 int
1236 tape_release(struct tape_device *device)
1237 {
1238         spin_lock_irq(get_ccwdev_lock(device->cdev));
1239         if (device->tape_state == TS_IN_USE)
1240                 tape_state_set(device, TS_UNUSED);
1241         module_put(device->discipline->owner);
1242         spin_unlock_irq(get_ccwdev_lock(device->cdev));
1243         return 0;
1244 }
1245
1246 /*
1247  * Execute a magnetic tape command a number of times.
1248  */
1249 int
1250 tape_mtop(struct tape_device *device, int mt_op, int mt_count)
1251 {
1252         tape_mtop_fn fn;
1253         int rc;
1254
1255         DBF_EVENT(6, "TAPE:mtio\n");
1256         DBF_EVENT(6, "TAPE:ioop: %x\n", mt_op);
1257         DBF_EVENT(6, "TAPE:arg:  %x\n", mt_count);
1258
1259         if (mt_op < 0 || mt_op >= TAPE_NR_MTOPS)
1260                 return -EINVAL;
1261         fn = device->discipline->mtop_array[mt_op];
1262         if (fn == NULL)
1263                 return -EINVAL;
1264
1265         /* We assume that the backends can handle count up to 500. */
1266         if (mt_op == MTBSR  || mt_op == MTFSR  || mt_op == MTFSF  ||
1267             mt_op == MTBSF  || mt_op == MTFSFM || mt_op == MTBSFM) {
1268                 rc = 0;
1269                 for (; mt_count > 500; mt_count -= 500)
1270                         if ((rc = fn(device, 500)) != 0)
1271                                 break;
1272                 if (rc == 0)
1273                         rc = fn(device, mt_count);
1274         } else
1275                 rc = fn(device, mt_count);
1276         return rc;
1277
1278 }
1279
1280 /*
1281  * Tape init function.
1282  */
1283 static int
1284 tape_init (void)
1285 {
1286         TAPE_DBF_AREA = debug_register ( "tape", 2, 2, 4*sizeof(long));
1287         debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
1288 #ifdef DBF_LIKE_HELL
1289         debug_set_level(TAPE_DBF_AREA, 6);
1290 #endif
1291         DBF_EVENT(3, "tape init\n");
1292         tape_proc_init();
1293         tapechar_init ();
1294         tapeblock_init ();
1295         return 0;
1296 }
1297
1298 /*
1299  * Tape exit function.
1300  */
1301 static void
1302 tape_exit(void)
1303 {
1304         DBF_EVENT(6, "tape exit\n");
1305
1306         /* Get rid of the frontends */
1307         tapechar_exit();
1308         tapeblock_exit();
1309         tape_proc_cleanup();
1310         debug_unregister (TAPE_DBF_AREA);
1311 }
1312
1313 MODULE_AUTHOR("(C) 2001 IBM Deutschland Entwicklung GmbH by Carsten Otte and "
1314               "Michael Holzheu (cotte@de.ibm.com,holzheu@de.ibm.com)");
1315 MODULE_DESCRIPTION("Linux on zSeries channel attached tape device driver");
1316 MODULE_LICENSE("GPL");
1317
1318 module_init(tape_init);
1319 module_exit(tape_exit);
1320
1321 EXPORT_SYMBOL(tape_generic_remove);
1322 EXPORT_SYMBOL(tape_generic_probe);
1323 EXPORT_SYMBOL(tape_generic_online);
1324 EXPORT_SYMBOL(tape_generic_offline);
1325 EXPORT_SYMBOL(tape_generic_pm_suspend);
1326 EXPORT_SYMBOL(tape_put_device);
1327 EXPORT_SYMBOL(tape_get_device_reference);
1328 EXPORT_SYMBOL(tape_state_verbose);
1329 EXPORT_SYMBOL(tape_op_verbose);
1330 EXPORT_SYMBOL(tape_state_set);
1331 EXPORT_SYMBOL(tape_med_state_set);
1332 EXPORT_SYMBOL(tape_alloc_request);
1333 EXPORT_SYMBOL(tape_free_request);
1334 EXPORT_SYMBOL(tape_dump_sense_dbf);
1335 EXPORT_SYMBOL(tape_do_io);
1336 EXPORT_SYMBOL(tape_do_io_async);
1337 EXPORT_SYMBOL(tape_do_io_interruptible);
1338 EXPORT_SYMBOL(tape_cancel_io);
1339 EXPORT_SYMBOL(tape_mtop);