[S390] Remove tape block device driver.

Remove the tape block device driver. It's not of real use but has
already created some confusion when users wanted to access tape devices
and used the block device nodes instead of the character device nodes.

Also remove the whole tape documentation since it's completely outdated
and we have the device drivers book which is the place where everything
is properly documented.

Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

3 files changed, 0 insertions, 457 deletions

diff --git a/drivers/s390/char/Kconfig b/drivers/s390/char/Kconfig
index dcee3c5c8954..a4f117d9fdc6 100644
--- a/drivers/s390/char/Kconfig
+++ b/drivers/s390/char/Kconfig
@@ -119,18 +119,6 @@ config S390_TAPE
 comment "S/390 tape interface support"
         depends on S390_TAPE
 
-config S390_TAPE_BLOCK
-        def_bool y
-        prompt "Support for tape block devices"
-        depends on S390_TAPE && BLOCK
-        help
-          Select this option if you want to access your channel-attached tape
-          devices using the block device interface.  This interface is similar
-          to CD-ROM devices on other platforms.  The tapes can only be
-          accessed read-only when using this interface.  Have a look at
-          <file:Documentation/s390/TAPE> for further information about creating
-          volumes for and using this interface.  It is safe to say "Y" here.
-
 comment "S/390 tape hardware support"
         depends on S390_TAPE
 
diff --git a/drivers/s390/char/Makefile b/drivers/s390/char/Makefile
index efb500ab66c0..af01b5abd069 100644
--- a/drivers/s390/char/Makefile
+++ b/drivers/s390/char/Makefile
@@ -22,7 +22,6 @@ obj-$(CONFIG_ZVM_WATCHDOG) += vmwatchdog.o
 obj-$(CONFIG_VMLOGRDR) += vmlogrdr.o
 obj-$(CONFIG_VMCP) += vmcp.o
 
-tape-$(CONFIG_S390_TAPE_BLOCK) += tape_block.o
 tape-$(CONFIG_PROC_FS) += tape_proc.o
 tape-objs := tape_core.o tape_std.o tape_char.o $(tape-y)
 obj-$(CONFIG_S390_TAPE) += tape.o tape_class.o
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
deleted file mode 100644
index 1b3924c2fffd..000000000000
--- a/drivers/s390/char/tape_block.c
+++ /dev/null
@@ -1,444 +0,0 @@
-/*
- *  drivers/s390/char/tape_block.c
- *    block device frontend for tape device driver
- *
- *  S390 and zSeries version
- *    Copyright (C) 2001,2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
- *    Author(s): Carsten Otte <cotte@de.ibm.com>
- *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
- *               Martin Schwidefsky <schwidefsky@de.ibm.com>
- *               Stefan Bader <shbader@de.ibm.com>
- */
-
-#define KMSG_COMPONENT "tape"
-#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
-
-#include <linux/fs.h>
-#include <linux/module.h>
-#include <linux/blkdev.h>
-#include <linux/mutex.h>
-#include <linux/interrupt.h>
-#include <linux/buffer_head.h>
-#include <linux/kernel.h>
-
-#include <asm/debug.h>
-
-#define TAPE_DBF_AREA   tape_core_dbf
-
-#include "tape.h"
-
-#define TAPEBLOCK_MAX_SEC       100
-#define TAPEBLOCK_MIN_REQUEUE   3
-
-/*
- * 2003/11/25  Stefan Bader <shbader@de.ibm.com>
- *
- * In 2.5/2.6 the block device request function is very likely to be called
- * with disabled interrupts (e.g. generic_unplug_device). So the driver can't
- * just call any function that tries to allocate CCW requests from that con-
- * text since it might sleep. There are two choices to work around this:
- *      a) do not allocate with kmalloc but use its own memory pool
- *      b) take requests from the queue outside that context, knowing that
- *         allocation might sleep
- */
-
-/*
- * file operation structure for tape block frontend
- */
-static DEFINE_MUTEX(tape_block_mutex);
-static int tapeblock_open(struct block_device *, fmode_t);
-static int tapeblock_release(struct gendisk *, fmode_t);
-static unsigned int tapeblock_check_events(struct gendisk *, unsigned int);
-static int tapeblock_revalidate_disk(struct gendisk *);
-
-static const struct block_device_operations tapeblock_fops = {
-        .owner           = THIS_MODULE,
-        .open            = tapeblock_open,
-        .release         = tapeblock_release,
-        .check_events    = tapeblock_check_events,
-        .revalidate_disk = tapeblock_revalidate_disk,
-};
-
-static int tapeblock_major = 0;
-
-static void
-tapeblock_trigger_requeue(struct tape_device *device)
-{
-        /* Protect against rescheduling. */
-        if (atomic_cmpxchg(&device->blk_data.requeue_scheduled, 0, 1) != 0)
-                return;
-        schedule_work(&device->blk_data.requeue_task);
-}
-
-/*
- * Post finished request.
- */
-static void
-__tapeblock_end_request(struct tape_request *ccw_req, void *data)
-{
-        struct tape_device *device;
-        struct request *req;
-
-        DBF_LH(6, "__tapeblock_end_request()\n");
-
-        device = ccw_req->device;
-        req = (struct request *) data;
-        blk_end_request_all(req, (ccw_req->rc == 0) ? 0 : -EIO);
-        if (ccw_req->rc == 0)
-                /* Update position. */
-                device->blk_data.block_position =
-                  (blk_rq_pos(req) + blk_rq_sectors(req)) >> TAPEBLOCK_HSEC_S2B;
-        else
-                /* We lost the position information due to an error. */
-                device->blk_data.block_position = -1;
-        device->discipline->free_bread(ccw_req);
-        if (!list_empty(&device->req_queue) ||
-            blk_peek_request(device->blk_data.request_queue))
-                tapeblock_trigger_requeue(device);
-}
-
-/*
- * Feed the tape device CCW queue with requests supplied in a list.
- */
-static int
-tapeblock_start_request(struct tape_device *device, struct request *req)
-{
-        struct tape_request *   ccw_req;
-        int                     rc;
-
-        DBF_LH(6, "tapeblock_start_request(%p, %p)\n", device, req);
-
-        ccw_req = device->discipline->bread(device, req);
-        if (IS_ERR(ccw_req)) {
-                DBF_EVENT(1, "TBLOCK: bread failed\n");
-                blk_end_request_all(req, -EIO);
-                return PTR_ERR(ccw_req);
-        }
-        ccw_req->callback = __tapeblock_end_request;
-        ccw_req->callback_data = (void *) req;
-        ccw_req->retries = TAPEBLOCK_RETRIES;
-
-        rc = tape_do_io_async(device, ccw_req);
-        if (rc) {
-                /*
-                 * Start/enqueueing failed. No retries in
-                 * this case.
-                 */
-                blk_end_request_all(req, -EIO);
-                device->discipline->free_bread(ccw_req);
-        }
-
-        return rc;
-}
-
-/*
- * Move requests from the block device request queue to the tape device ccw
- * queue.
- */
-static void
-tapeblock_requeue(struct work_struct *work) {
-        struct tape_blk_data *  blkdat;
-        struct tape_device *    device;
-        struct request_queue *  queue;
-        int                     nr_queued;
-        struct request *        req;
-        struct list_head *      l;
-        int                     rc;
-
-        blkdat = container_of(work, struct tape_blk_data, requeue_task);
-        device = blkdat->device;
-        if (!device)
-                return;
-
-        spin_lock_irq(get_ccwdev_lock(device->cdev));
-        queue  = device->blk_data.request_queue;
-
-        /* Count number of requests on ccw queue. */
-        nr_queued = 0;
-        list_for_each(l, &device->req_queue)
-                nr_queued++;
-        spin_unlock(get_ccwdev_lock(device->cdev));
-
-        spin_lock_irq(&device->blk_data.request_queue_lock);
-        while (
-                blk_peek_request(queue) &&
-                nr_queued < TAPEBLOCK_MIN_REQUEUE
-        ) {
-                req = blk_fetch_request(queue);
-                if (rq_data_dir(req) == WRITE) {
-                        DBF_EVENT(1, "TBLOCK: Rejecting write request\n");
-                        spin_unlock_irq(&device->blk_data.request_queue_lock);
-                        blk_end_request_all(req, -EIO);
-                        spin_lock_irq(&device->blk_data.request_queue_lock);
-                        continue;
-                }
-                nr_queued++;
-                spin_unlock_irq(&device->blk_data.request_queue_lock);
-                rc = tapeblock_start_request(device, req);
-                spin_lock_irq(&device->blk_data.request_queue_lock);
-        }
-        spin_unlock_irq(&device->blk_data.request_queue_lock);
-        atomic_set(&device->blk_data.requeue_scheduled, 0);
-}
-
-/*
- * Tape request queue function. Called from ll_rw_blk.c
- */
-static void
-tapeblock_request_fn(struct request_queue *queue)
-{
-        struct tape_device *device;
-
-        device = (struct tape_device *) queue->queuedata;
-        DBF_LH(6, "tapeblock_request_fn(device=%p)\n", device);
-        BUG_ON(device == NULL);
-        tapeblock_trigger_requeue(device);
-}
-
-/*
- * This function is called for every new tapedevice
- */
-int
-tapeblock_setup_device(struct tape_device * device)
-{
-        struct tape_blk_data *  blkdat;
-        struct gendisk *        disk;
-        int                     rc;
-
-        blkdat = &device->blk_data;
-        blkdat->device = device;
-        spin_lock_init(&blkdat->request_queue_lock);
-        atomic_set(&blkdat->requeue_scheduled, 0);
-
-        blkdat->request_queue = blk_init_queue(
-                tapeblock_request_fn,
-                &blkdat->request_queue_lock
-        );
-        if (!blkdat->request_queue)
-                return -ENOMEM;
-
-        rc = elevator_change(blkdat->request_queue, "noop");
-        if (rc)
-                goto cleanup_queue;
-
-        blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
-        blk_queue_max_hw_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
-        blk_queue_max_segments(blkdat->request_queue, -1L);
-        blk_queue_max_segment_size(blkdat->request_queue, -1L);
-        blk_queue_segment_boundary(blkdat->request_queue, -1L);
-
-        disk = alloc_disk(1);
-        if (!disk) {
-                rc = -ENOMEM;
-                goto cleanup_queue;
-        }
-
-        disk->major = tapeblock_major;
-        disk->first_minor = device->first_minor;
-        disk->fops = &tapeblock_fops;
-        disk->private_data = tape_get_device(device);
-        disk->queue = blkdat->request_queue;
-        set_capacity(disk, 0);
-        sprintf(disk->disk_name, "btibm%d",
-                device->first_minor / TAPE_MINORS_PER_DEV);
-
-        blkdat->disk = disk;
-        blkdat->medium_changed = 1;
-        blkdat->request_queue->queuedata = tape_get_device(device);
-
-        add_disk(disk);
-
-        tape_get_device(device);
-        INIT_WORK(&blkdat->requeue_task, tapeblock_requeue);
-
-        return 0;
-
-cleanup_queue:
-        blk_cleanup_queue(blkdat->request_queue);
-        blkdat->request_queue = NULL;
-
-        return rc;
-}
-
-void
-tapeblock_cleanup_device(struct tape_device *device)
-{
-        flush_work_sync(&device->blk_data.requeue_task);
-        tape_put_device(device);
-
-        if (!device->blk_data.disk) {
-                goto cleanup_queue;
-        }
-
-        del_gendisk(device->blk_data.disk);
-        device->blk_data.disk->private_data = NULL;
-        tape_put_device(device);
-        put_disk(device->blk_data.disk);
-
-        device->blk_data.disk = NULL;
-cleanup_queue:
-        device->blk_data.request_queue->queuedata = NULL;
-        tape_put_device(device);
-
-        blk_cleanup_queue(device->blk_data.request_queue);
-        device->blk_data.request_queue = NULL;
-}
-
-/*
- * Detect number of blocks of the tape.
- * FIXME: can we extent this to detect the blocks size as well ?
- */
-static int
-tapeblock_revalidate_disk(struct gendisk *disk)
-{
-        struct tape_device *    device;
-        unsigned int            nr_of_blks;
-        int                     rc;
-
-        device = (struct tape_device *) disk->private_data;
-        BUG_ON(!device);
-
-        if (!device->blk_data.medium_changed)
-                return 0;
-
-        rc = tape_mtop(device, MTFSFM, 1);
-        if (rc)
-                return rc;
-
-        rc = tape_mtop(device, MTTELL, 1);
-        if (rc < 0)
-                return rc;
-
-        pr_info("%s: Determining the size of the recorded area...\n",
-                dev_name(&device->cdev->dev));
-        DBF_LH(3, "Image file ends at %d\n", rc);
-        nr_of_blks = rc;
-
-        /* This will fail for the first file. Catch the error by checking the
-         * position. */
-        tape_mtop(device, MTBSF, 1);
-
-        rc = tape_mtop(device, MTTELL, 1);
-        if (rc < 0)
-                return rc;
-
-        if (rc > nr_of_blks)
-                return -EINVAL;
-
-        DBF_LH(3, "Image file starts at %d\n", rc);
-        device->bof = rc;
-        nr_of_blks -= rc;
-
-        pr_info("%s: The size of the recorded area is %i blocks\n",
-                dev_name(&device->cdev->dev), nr_of_blks);
-        set_capacity(device->blk_data.disk,
-                nr_of_blks*(TAPEBLOCK_HSEC_SIZE/512));
-
-        device->blk_data.block_position = 0;
-        device->blk_data.medium_changed = 0;
-        return 0;
-}
-
-static unsigned int
-tapeblock_check_events(struct gendisk *disk, unsigned int clearing)
-{
-        struct tape_device *device;
-
-        device = (struct tape_device *) disk->private_data;
-        DBF_LH(6, "tapeblock_medium_changed(%p) = %d\n",
-                device, device->blk_data.medium_changed);
-
-        return device->blk_data.medium_changed ? DISK_EVENT_MEDIA_CHANGE : 0;
-}
-
-/*
- * Block frontend tape device open function.
- */
-static int
-tapeblock_open(struct block_device *bdev, fmode_t mode)
-{
-        struct gendisk *        disk = bdev->bd_disk;
-        struct tape_device *    device;
-        int                     rc;
-
-        mutex_lock(&tape_block_mutex);
-        device = tape_get_device(disk->private_data);
-
-        if (device->required_tapemarks) {
-                DBF_EVENT(2, "TBLOCK: missing tapemarks\n");
-                pr_warning("%s: Opening the tape failed because of missing "
-                           "end-of-file marks\n", dev_name(&device->cdev->dev));
-                rc = -EPERM;
-                goto put_device;
-        }
-
-        rc = tape_open(device);
-        if (rc)
-                goto put_device;
-
-        rc = tapeblock_revalidate_disk(disk);
-        if (rc)
-                goto release;
-
-        /*
-         * Note: The reference to <device> is hold until the release function
-         *       is called.
-         */
-        tape_state_set(device, TS_BLKUSE);
-        mutex_unlock(&tape_block_mutex);
-        return 0;
-
-release:
-        tape_release(device);
- put_device:
-        tape_put_device(device);
-        mutex_unlock(&tape_block_mutex);
-        return rc;
-}
-
-/*
- * Block frontend tape device release function.
- *
- * Note: One reference to the tape device was made by the open function. So
- *       we just get the pointer here and release the reference.
- */
-static int
-tapeblock_release(struct gendisk *disk, fmode_t mode)
-{
-        struct tape_device *device = disk->private_data;
- 
-        mutex_lock(&tape_block_mutex);
-        tape_state_set(device, TS_IN_USE);
-        tape_release(device);
-        tape_put_device(device);
-        mutex_unlock(&tape_block_mutex);
-
-        return 0;
-}
-
-/*
- * Initialize block device frontend.
- */
-int
-tapeblock_init(void)
-{
-        int rc;
-
-        /* Register the tape major number to the kernel */
-        rc = register_blkdev(tapeblock_major, "tBLK");
-        if (rc < 0)
-                return rc;
-
-        if (tapeblock_major == 0)
-                tapeblock_major = rc;
-        return 0;
-}
-
-/*
- * Deregister major for block device frontend
- */
-void
-tapeblock_exit(void)
-{
-        unregister_blkdev(tapeblock_major, "tBLK");
-}