drivers/s390/char/tape_core.c

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