16f05e69eSGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * basic function of the tape device driver
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * S390 and zSeries version
63ef32e62SFrank Munzert * Copyright IBM Corp. 2001, 2009
71da177e4SLinus Torvalds * Author(s): Carsten Otte <cotte@de.ibm.com>
81da177e4SLinus Torvalds * Michael Holzheu <holzheu@de.ibm.com>
91da177e4SLinus Torvalds * Tuan Ngo-Anh <ngoanh@de.ibm.com>
101da177e4SLinus Torvalds * Martin Schwidefsky <schwidefsky@de.ibm.com>
114111796dSStefan Bader * Stefan Bader <shbader@de.ibm.com>
121da177e4SLinus Torvalds */
131da177e4SLinus Torvalds
14ab640db0SCarsten Otte #define KMSG_COMPONENT "tape"
15bb509912SMichael Holzheu #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
16bb509912SMichael Holzheu
171da177e4SLinus Torvalds #include <linux/module.h>
181da177e4SLinus Torvalds #include <linux/init.h> // for kernel parameters
191da177e4SLinus Torvalds #include <linux/kmod.h> // for requesting modules
201da177e4SLinus Torvalds #include <linux/spinlock.h> // for locks
211da177e4SLinus Torvalds #include <linux/vmalloc.h>
221da177e4SLinus Torvalds #include <linux/list.h>
235a0e3ad6STejun Heo #include <linux/slab.h>
241da177e4SLinus Torvalds
251da177e4SLinus Torvalds #include <asm/types.h> // for variable types
261da177e4SLinus Torvalds
271da177e4SLinus Torvalds #define TAPE_DBF_AREA tape_core_dbf
281da177e4SLinus Torvalds
291da177e4SLinus Torvalds #include "tape.h"
301da177e4SLinus Torvalds #include "tape_std.h"
311da177e4SLinus Torvalds
32cced1dd4SMichael Holzheu #define LONG_BUSY_TIMEOUT 180 /* seconds */
331da177e4SLinus Torvalds
341da177e4SLinus Torvalds static void __tape_do_irq (struct ccw_device *, unsigned long, struct irb *);
35c1637532SMartin Schwidefsky static void tape_delayed_next_request(struct work_struct *);
36c9602ee7SKees Cook static void tape_long_busy_timeout(struct timer_list *t);
371da177e4SLinus Torvalds
381da177e4SLinus Torvalds /*
391da177e4SLinus Torvalds * One list to contain all tape devices of all disciplines, so
401da177e4SLinus Torvalds * we can assign the devices to minor numbers of the same major
411da177e4SLinus Torvalds * The list is protected by the rwlock
421da177e4SLinus Torvalds */
43c11ca97eSDenis Cheng static LIST_HEAD(tape_device_list);
441da177e4SLinus Torvalds static DEFINE_RWLOCK(tape_device_lock);
451da177e4SLinus Torvalds
461da177e4SLinus Torvalds /*
471da177e4SLinus Torvalds * Pointer to debug area.
481da177e4SLinus Torvalds */
491da177e4SLinus Torvalds debug_info_t *TAPE_DBF_AREA = NULL;
501da177e4SLinus Torvalds EXPORT_SYMBOL(TAPE_DBF_AREA);
511da177e4SLinus Torvalds
521da177e4SLinus Torvalds /*
531da177e4SLinus Torvalds * Printable strings for tape enumerations.
541da177e4SLinus Torvalds */
551da177e4SLinus Torvalds const char *tape_state_verbose[TS_SIZE] =
561da177e4SLinus Torvalds {
571da177e4SLinus Torvalds [TS_UNUSED] = "UNUSED",
581da177e4SLinus Torvalds [TS_IN_USE] = "IN_USE",
591da177e4SLinus Torvalds [TS_BLKUSE] = "BLKUSE",
601da177e4SLinus Torvalds [TS_INIT] = "INIT ",
611da177e4SLinus Torvalds [TS_NOT_OPER] = "NOT_OP"
621da177e4SLinus Torvalds };
631da177e4SLinus Torvalds
641da177e4SLinus Torvalds const char *tape_op_verbose[TO_SIZE] =
651da177e4SLinus Torvalds {
661da177e4SLinus Torvalds [TO_BLOCK] = "BLK", [TO_BSB] = "BSB",
671da177e4SLinus Torvalds [TO_BSF] = "BSF", [TO_DSE] = "DSE",
681da177e4SLinus Torvalds [TO_FSB] = "FSB", [TO_FSF] = "FSF",
691da177e4SLinus Torvalds [TO_LBL] = "LBL", [TO_NOP] = "NOP",
701da177e4SLinus Torvalds [TO_RBA] = "RBA", [TO_RBI] = "RBI",
711da177e4SLinus Torvalds [TO_RFO] = "RFO", [TO_REW] = "REW",
721da177e4SLinus Torvalds [TO_RUN] = "RUN", [TO_WRI] = "WRI",
731da177e4SLinus Torvalds [TO_WTM] = "WTM", [TO_MSEN] = "MSN",
741da177e4SLinus Torvalds [TO_LOAD] = "LOA", [TO_READ_CONFIG] = "RCF",
751da177e4SLinus Torvalds [TO_READ_ATTMSG] = "RAT",
761da177e4SLinus Torvalds [TO_DIS] = "DIS", [TO_ASSIGN] = "ASS",
77cced1dd4SMichael Holzheu [TO_UNASSIGN] = "UAS", [TO_CRYPT_ON] = "CON",
78cced1dd4SMichael Holzheu [TO_CRYPT_OFF] = "COF", [TO_KEKL_SET] = "KLS",
79e2963062SMichael Holzheu [TO_KEKL_QUERY] = "KLQ",[TO_RDC] = "RDC",
801da177e4SLinus Torvalds };
811da177e4SLinus Torvalds
devid_to_int(struct ccw_dev_id * dev_id)82f455adcfSCornelia Huck static int devid_to_int(struct ccw_dev_id *dev_id)
831da177e4SLinus Torvalds {
84f455adcfSCornelia Huck return dev_id->devno + (dev_id->ssid << 16);
851da177e4SLinus Torvalds }
861da177e4SLinus Torvalds
871da177e4SLinus Torvalds /*
881da177e4SLinus Torvalds * Some channel attached tape specific attributes.
891da177e4SLinus Torvalds *
901da177e4SLinus Torvalds * FIXME: In the future the first_minor and blocksize attribute should be
911da177e4SLinus Torvalds * replaced by a link to the cdev tree.
921da177e4SLinus Torvalds */
931da177e4SLinus Torvalds static ssize_t
tape_medium_state_show(struct device * dev,struct device_attribute * attr,char * buf)943fd3c0a5SYani Ioannou tape_medium_state_show(struct device *dev, struct device_attribute *attr, char *buf)
951da177e4SLinus Torvalds {
961da177e4SLinus Torvalds struct tape_device *tdev;
971da177e4SLinus Torvalds
98dff59b64SGreg Kroah-Hartman tdev = dev_get_drvdata(dev);
991da177e4SLinus Torvalds return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->medium_state);
1001da177e4SLinus Torvalds }
1011da177e4SLinus Torvalds
1021da177e4SLinus Torvalds static
1031da177e4SLinus Torvalds DEVICE_ATTR(medium_state, 0444, tape_medium_state_show, NULL);
1041da177e4SLinus Torvalds
1051da177e4SLinus Torvalds static ssize_t
tape_first_minor_show(struct device * dev,struct device_attribute * attr,char * buf)1063fd3c0a5SYani Ioannou tape_first_minor_show(struct device *dev, struct device_attribute *attr, char *buf)
1071da177e4SLinus Torvalds {
1081da177e4SLinus Torvalds struct tape_device *tdev;
1091da177e4SLinus Torvalds
110dff59b64SGreg Kroah-Hartman tdev = dev_get_drvdata(dev);
1111da177e4SLinus Torvalds return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->first_minor);
1121da177e4SLinus Torvalds }
1131da177e4SLinus Torvalds
1141da177e4SLinus Torvalds static
1151da177e4SLinus Torvalds DEVICE_ATTR(first_minor, 0444, tape_first_minor_show, NULL);
1161da177e4SLinus Torvalds
1171da177e4SLinus Torvalds static ssize_t
tape_state_show(struct device * dev,struct device_attribute * attr,char * buf)1183fd3c0a5SYani Ioannou tape_state_show(struct device *dev, struct device_attribute *attr, char *buf)
1191da177e4SLinus Torvalds {
1201da177e4SLinus Torvalds struct tape_device *tdev;
1211da177e4SLinus Torvalds
122dff59b64SGreg Kroah-Hartman tdev = dev_get_drvdata(dev);
1231da177e4SLinus Torvalds return scnprintf(buf, PAGE_SIZE, "%s\n", (tdev->first_minor < 0) ?
1241da177e4SLinus Torvalds "OFFLINE" : tape_state_verbose[tdev->tape_state]);
1251da177e4SLinus Torvalds }
1261da177e4SLinus Torvalds
1271da177e4SLinus Torvalds static
1281da177e4SLinus Torvalds DEVICE_ATTR(state, 0444, tape_state_show, NULL);
1291da177e4SLinus Torvalds
1301da177e4SLinus Torvalds static ssize_t
tape_operation_show(struct device * dev,struct device_attribute * attr,char * buf)1313fd3c0a5SYani Ioannou tape_operation_show(struct device *dev, struct device_attribute *attr, char *buf)
1321da177e4SLinus Torvalds {
1331da177e4SLinus Torvalds struct tape_device *tdev;
1341da177e4SLinus Torvalds ssize_t rc;
1351da177e4SLinus Torvalds
136dff59b64SGreg Kroah-Hartman tdev = dev_get_drvdata(dev);
1371da177e4SLinus Torvalds if (tdev->first_minor < 0)
1381da177e4SLinus Torvalds return scnprintf(buf, PAGE_SIZE, "N/A\n");
1391da177e4SLinus Torvalds
1401da177e4SLinus Torvalds spin_lock_irq(get_ccwdev_lock(tdev->cdev));
1411da177e4SLinus Torvalds if (list_empty(&tdev->req_queue))
1421da177e4SLinus Torvalds rc = scnprintf(buf, PAGE_SIZE, "---\n");
1431da177e4SLinus Torvalds else {
1441da177e4SLinus Torvalds struct tape_request *req;
1451da177e4SLinus Torvalds
1461da177e4SLinus Torvalds req = list_entry(tdev->req_queue.next, struct tape_request,
1471da177e4SLinus Torvalds list);
1481da177e4SLinus Torvalds rc = scnprintf(buf,PAGE_SIZE, "%s\n", tape_op_verbose[req->op]);
1491da177e4SLinus Torvalds }
1501da177e4SLinus Torvalds spin_unlock_irq(get_ccwdev_lock(tdev->cdev));
1511da177e4SLinus Torvalds return rc;
1521da177e4SLinus Torvalds }
1531da177e4SLinus Torvalds
1541da177e4SLinus Torvalds static
1551da177e4SLinus Torvalds DEVICE_ATTR(operation, 0444, tape_operation_show, NULL);
1561da177e4SLinus Torvalds
1571da177e4SLinus Torvalds static ssize_t
tape_blocksize_show(struct device * dev,struct device_attribute * attr,char * buf)1583fd3c0a5SYani Ioannou tape_blocksize_show(struct device *dev, struct device_attribute *attr, char *buf)
1591da177e4SLinus Torvalds {
1601da177e4SLinus Torvalds struct tape_device *tdev;
1611da177e4SLinus Torvalds
162dff59b64SGreg Kroah-Hartman tdev = dev_get_drvdata(dev);
1631da177e4SLinus Torvalds
1641da177e4SLinus Torvalds return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->char_data.block_size);
1651da177e4SLinus Torvalds }
1661da177e4SLinus Torvalds
1671da177e4SLinus Torvalds static
1681da177e4SLinus Torvalds DEVICE_ATTR(blocksize, 0444, tape_blocksize_show, NULL);
1691da177e4SLinus Torvalds
1701da177e4SLinus Torvalds static struct attribute *tape_attrs[] = {
1711da177e4SLinus Torvalds &dev_attr_medium_state.attr,
1721da177e4SLinus Torvalds &dev_attr_first_minor.attr,
1731da177e4SLinus Torvalds &dev_attr_state.attr,
1741da177e4SLinus Torvalds &dev_attr_operation.attr,
1751da177e4SLinus Torvalds &dev_attr_blocksize.attr,
1761da177e4SLinus Torvalds NULL
1771da177e4SLinus Torvalds };
1781da177e4SLinus Torvalds
179fc2b0f52SArvind Yadav static const struct attribute_group tape_attr_group = {
1801da177e4SLinus Torvalds .attrs = tape_attrs,
1811da177e4SLinus Torvalds };
1821da177e4SLinus Torvalds
1831da177e4SLinus Torvalds /*
1841da177e4SLinus Torvalds * Tape state functions
1851da177e4SLinus Torvalds */
1861da177e4SLinus Torvalds void
tape_state_set(struct tape_device * device,enum tape_state newstate)1871da177e4SLinus Torvalds tape_state_set(struct tape_device *device, enum tape_state newstate)
1881da177e4SLinus Torvalds {
1891da177e4SLinus Torvalds const char *str;
1901da177e4SLinus Torvalds
1911da177e4SLinus Torvalds if (device->tape_state == TS_NOT_OPER) {
1921da177e4SLinus Torvalds DBF_EVENT(3, "ts_set err: not oper\n");
1931da177e4SLinus Torvalds return;
1941da177e4SLinus Torvalds }
1951da177e4SLinus Torvalds DBF_EVENT(4, "ts. dev: %x\n", device->first_minor);
196f976069aSPeter Oberparleiter DBF_EVENT(4, "old ts:\t\n");
197f976069aSPeter Oberparleiter if (device->tape_state < TS_SIZE && device->tape_state >=0 )
1981da177e4SLinus Torvalds str = tape_state_verbose[device->tape_state];
1991da177e4SLinus Torvalds else
2001da177e4SLinus Torvalds str = "UNKNOWN TS";
2011da177e4SLinus Torvalds DBF_EVENT(4, "%s\n", str);
2021da177e4SLinus Torvalds DBF_EVENT(4, "new ts:\t\n");
203f976069aSPeter Oberparleiter if (newstate < TS_SIZE && newstate >= 0)
2041da177e4SLinus Torvalds str = tape_state_verbose[newstate];
2051da177e4SLinus Torvalds else
2061da177e4SLinus Torvalds str = "UNKNOWN TS";
2071da177e4SLinus Torvalds DBF_EVENT(4, "%s\n", str);
2081da177e4SLinus Torvalds device->tape_state = newstate;
2091da177e4SLinus Torvalds wake_up(&device->state_change_wq);
2101da177e4SLinus Torvalds }
2111da177e4SLinus Torvalds
2123b210e76SMartin Schwidefsky struct tape_med_state_work_data {
2133b210e76SMartin Schwidefsky struct tape_device *device;
2143b210e76SMartin Schwidefsky enum tape_medium_state state;
2153b210e76SMartin Schwidefsky struct work_struct work;
2163b210e76SMartin Schwidefsky };
2173b210e76SMartin Schwidefsky
2183b210e76SMartin Schwidefsky static void
tape_med_state_work_handler(struct work_struct * work)2193b210e76SMartin Schwidefsky tape_med_state_work_handler(struct work_struct *work)
2203b210e76SMartin Schwidefsky {
2213b210e76SMartin Schwidefsky static char env_state_loaded[] = "MEDIUM_STATE=LOADED";
2223b210e76SMartin Schwidefsky static char env_state_unloaded[] = "MEDIUM_STATE=UNLOADED";
2233b210e76SMartin Schwidefsky struct tape_med_state_work_data *p =
2243b210e76SMartin Schwidefsky container_of(work, struct tape_med_state_work_data, work);
2253b210e76SMartin Schwidefsky struct tape_device *device = p->device;
2263b210e76SMartin Schwidefsky char *envp[] = { NULL, NULL };
2273b210e76SMartin Schwidefsky
2283b210e76SMartin Schwidefsky switch (p->state) {
2293b210e76SMartin Schwidefsky case MS_UNLOADED:
2303b210e76SMartin Schwidefsky pr_info("%s: The tape cartridge has been successfully "
2313b210e76SMartin Schwidefsky "unloaded\n", dev_name(&device->cdev->dev));
2323b210e76SMartin Schwidefsky envp[0] = env_state_unloaded;
2333b210e76SMartin Schwidefsky kobject_uevent_env(&device->cdev->dev.kobj, KOBJ_CHANGE, envp);
2343b210e76SMartin Schwidefsky break;
2353b210e76SMartin Schwidefsky case MS_LOADED:
2363b210e76SMartin Schwidefsky pr_info("%s: A tape cartridge has been mounted\n",
2373b210e76SMartin Schwidefsky dev_name(&device->cdev->dev));
2383b210e76SMartin Schwidefsky envp[0] = env_state_loaded;
2393b210e76SMartin Schwidefsky kobject_uevent_env(&device->cdev->dev.kobj, KOBJ_CHANGE, envp);
2403b210e76SMartin Schwidefsky break;
2413b210e76SMartin Schwidefsky default:
2423b210e76SMartin Schwidefsky break;
2433b210e76SMartin Schwidefsky }
2443b210e76SMartin Schwidefsky tape_put_device(device);
2453b210e76SMartin Schwidefsky kfree(p);
2463b210e76SMartin Schwidefsky }
2473b210e76SMartin Schwidefsky
2483b210e76SMartin Schwidefsky static void
tape_med_state_work(struct tape_device * device,enum tape_medium_state state)2493b210e76SMartin Schwidefsky tape_med_state_work(struct tape_device *device, enum tape_medium_state state)
2503b210e76SMartin Schwidefsky {
2513b210e76SMartin Schwidefsky struct tape_med_state_work_data *p;
2523b210e76SMartin Schwidefsky
2533b210e76SMartin Schwidefsky p = kzalloc(sizeof(*p), GFP_ATOMIC);
2543b210e76SMartin Schwidefsky if (p) {
2553b210e76SMartin Schwidefsky INIT_WORK(&p->work, tape_med_state_work_handler);
2563b210e76SMartin Schwidefsky p->device = tape_get_device(device);
2573b210e76SMartin Schwidefsky p->state = state;
2583b210e76SMartin Schwidefsky schedule_work(&p->work);
2593b210e76SMartin Schwidefsky }
2603b210e76SMartin Schwidefsky }
2613b210e76SMartin Schwidefsky
2621da177e4SLinus Torvalds void
tape_med_state_set(struct tape_device * device,enum tape_medium_state newstate)2631da177e4SLinus Torvalds tape_med_state_set(struct tape_device *device, enum tape_medium_state newstate)
2641da177e4SLinus Torvalds {
2653b210e76SMartin Schwidefsky enum tape_medium_state oldstate;
2663b210e76SMartin Schwidefsky
2673b210e76SMartin Schwidefsky oldstate = device->medium_state;
2683b210e76SMartin Schwidefsky if (oldstate == newstate)
2691da177e4SLinus Torvalds return;
2703b210e76SMartin Schwidefsky device->medium_state = newstate;
2711da177e4SLinus Torvalds switch(newstate){
2721da177e4SLinus Torvalds case MS_UNLOADED:
2731da177e4SLinus Torvalds device->tape_generic_status |= GMT_DR_OPEN(~0);
2743b210e76SMartin Schwidefsky if (oldstate == MS_LOADED)
2753b210e76SMartin Schwidefsky tape_med_state_work(device, MS_UNLOADED);
2761da177e4SLinus Torvalds break;
2771da177e4SLinus Torvalds case MS_LOADED:
2781da177e4SLinus Torvalds device->tape_generic_status &= ~GMT_DR_OPEN(~0);
2793b210e76SMartin Schwidefsky if (oldstate == MS_UNLOADED)
2803b210e76SMartin Schwidefsky tape_med_state_work(device, MS_LOADED);
2811da177e4SLinus Torvalds break;
2821da177e4SLinus Torvalds default:
2831da177e4SLinus Torvalds break;
2841da177e4SLinus Torvalds }
2851da177e4SLinus Torvalds wake_up(&device->state_change_wq);
2861da177e4SLinus Torvalds }
2871da177e4SLinus Torvalds
2881da177e4SLinus Torvalds /*
2891da177e4SLinus Torvalds * Stop running ccw. Has to be called with the device lock held.
2901da177e4SLinus Torvalds */
2914d284cacSHeiko Carstens static int
__tape_cancel_io(struct tape_device * device,struct tape_request * request)2924111796dSStefan Bader __tape_cancel_io(struct tape_device *device, struct tape_request *request)
2931da177e4SLinus Torvalds {
2941da177e4SLinus Torvalds int retries;
2951da177e4SLinus Torvalds int rc;
2961da177e4SLinus Torvalds
2971da177e4SLinus Torvalds /* Check if interrupt has already been processed */
2981da177e4SLinus Torvalds if (request->callback == NULL)
2991da177e4SLinus Torvalds return 0;
3001da177e4SLinus Torvalds
3011da177e4SLinus Torvalds rc = 0;
3021da177e4SLinus Torvalds for (retries = 0; retries < 5; retries++) {
3031da177e4SLinus Torvalds rc = ccw_device_clear(device->cdev, (long) request);
3041da177e4SLinus Torvalds
3054111796dSStefan Bader switch (rc) {
3064111796dSStefan Bader case 0:
3071da177e4SLinus Torvalds request->status = TAPE_REQUEST_DONE;
3081da177e4SLinus Torvalds return 0;
3094111796dSStefan Bader case -EBUSY:
3104111796dSStefan Bader request->status = TAPE_REQUEST_CANCEL;
311c1637532SMartin Schwidefsky schedule_delayed_work(&device->tape_dnr, 0);
3124111796dSStefan Bader return 0;
3134111796dSStefan Bader case -ENODEV:
3141da177e4SLinus Torvalds DBF_EXCEPTION(2, "device gone, retry\n");
3154111796dSStefan Bader break;
3164111796dSStefan Bader case -EIO:
3171da177e4SLinus Torvalds DBF_EXCEPTION(2, "I/O error, retry\n");
3184111796dSStefan Bader break;
3194111796dSStefan Bader default:
3201da177e4SLinus Torvalds BUG();
3211da177e4SLinus Torvalds }
3224111796dSStefan Bader }
3231da177e4SLinus Torvalds
3241da177e4SLinus Torvalds return rc;
3251da177e4SLinus Torvalds }
3261da177e4SLinus Torvalds
3271da177e4SLinus Torvalds /*
3281da177e4SLinus Torvalds * Add device into the sorted list, giving it the first
3291da177e4SLinus Torvalds * available minor number.
3301da177e4SLinus Torvalds */
3311da177e4SLinus Torvalds static int
tape_assign_minor(struct tape_device * device)3321da177e4SLinus Torvalds tape_assign_minor(struct tape_device *device)
3331da177e4SLinus Torvalds {
3341da177e4SLinus Torvalds struct tape_device *tmp;
3351da177e4SLinus Torvalds int minor;
3361da177e4SLinus Torvalds
3371da177e4SLinus Torvalds minor = 0;
3381da177e4SLinus Torvalds write_lock(&tape_device_lock);
3391da177e4SLinus Torvalds list_for_each_entry(tmp, &tape_device_list, node) {
3401da177e4SLinus Torvalds if (minor < tmp->first_minor)
3411da177e4SLinus Torvalds break;
3421da177e4SLinus Torvalds minor += TAPE_MINORS_PER_DEV;
3431da177e4SLinus Torvalds }
3441da177e4SLinus Torvalds if (minor >= 256) {
3451da177e4SLinus Torvalds write_unlock(&tape_device_lock);
3461da177e4SLinus Torvalds return -ENODEV;
3471da177e4SLinus Torvalds }
3481da177e4SLinus Torvalds device->first_minor = minor;
3491da177e4SLinus Torvalds list_add_tail(&device->node, &tmp->node);
3501da177e4SLinus Torvalds write_unlock(&tape_device_lock);
3511da177e4SLinus Torvalds return 0;
3521da177e4SLinus Torvalds }
3531da177e4SLinus Torvalds
3541da177e4SLinus Torvalds /* remove device from the list */
3551da177e4SLinus Torvalds static void
tape_remove_minor(struct tape_device * device)3561da177e4SLinus Torvalds tape_remove_minor(struct tape_device *device)
3571da177e4SLinus Torvalds {
3581da177e4SLinus Torvalds write_lock(&tape_device_lock);
3591da177e4SLinus Torvalds list_del_init(&device->node);
3601da177e4SLinus Torvalds device->first_minor = -1;
3611da177e4SLinus Torvalds write_unlock(&tape_device_lock);
3621da177e4SLinus Torvalds }
3631da177e4SLinus Torvalds
3641da177e4SLinus Torvalds /*
3651da177e4SLinus Torvalds * Set a device online.
3661da177e4SLinus Torvalds *
3671da177e4SLinus Torvalds * This function is called by the common I/O layer to move a device from the
3681da177e4SLinus Torvalds * detected but offline into the online state.
3691da177e4SLinus Torvalds * If we return an error (RC < 0) the device remains in the offline state. This
3701da177e4SLinus Torvalds * can happen if the device is assigned somewhere else, for example.
3711da177e4SLinus Torvalds */
3721da177e4SLinus Torvalds int
tape_generic_online(struct tape_device * device,struct tape_discipline * discipline)3731da177e4SLinus Torvalds tape_generic_online(struct tape_device *device,
3741da177e4SLinus Torvalds struct tape_discipline *discipline)
3751da177e4SLinus Torvalds {
3761da177e4SLinus Torvalds int rc;
3771da177e4SLinus Torvalds
3781da177e4SLinus Torvalds DBF_LH(6, "tape_enable_device(%p, %p)\n", device, discipline);
3791da177e4SLinus Torvalds
3801da177e4SLinus Torvalds if (device->tape_state != TS_INIT) {
3811da177e4SLinus Torvalds DBF_LH(3, "Tapestate not INIT (%d)\n", device->tape_state);
3821da177e4SLinus Torvalds return -EINVAL;
3831da177e4SLinus Torvalds }
3841da177e4SLinus Torvalds
385c9602ee7SKees Cook timer_setup(&device->lb_timeout, tape_long_busy_timeout, 0);
386cced1dd4SMichael Holzheu
3871da177e4SLinus Torvalds /* Let the discipline have a go at the device. */
3881da177e4SLinus Torvalds device->discipline = discipline;
3891da177e4SLinus Torvalds if (!try_module_get(discipline->owner)) {
3901da177e4SLinus Torvalds return -EINVAL;
3911da177e4SLinus Torvalds }
3921da177e4SLinus Torvalds
3931da177e4SLinus Torvalds rc = discipline->setup_device(device);
3941da177e4SLinus Torvalds if (rc)
3951da177e4SLinus Torvalds goto out;
3961da177e4SLinus Torvalds rc = tape_assign_minor(device);
3971da177e4SLinus Torvalds if (rc)
3981da177e4SLinus Torvalds goto out_discipline;
3991da177e4SLinus Torvalds
4001da177e4SLinus Torvalds rc = tapechar_setup_device(device);
4011da177e4SLinus Torvalds if (rc)
4021da177e4SLinus Torvalds goto out_minor;
4031da177e4SLinus Torvalds
4041da177e4SLinus Torvalds tape_state_set(device, TS_UNUSED);
4051da177e4SLinus Torvalds
4061da177e4SLinus Torvalds DBF_LH(3, "(%08x): Drive set online\n", device->cdev_id);
4071da177e4SLinus Torvalds
4081da177e4SLinus Torvalds return 0;
4091da177e4SLinus Torvalds
41068d36bdbSRoel Kluin out_minor:
41168d36bdbSRoel Kluin tape_remove_minor(device);
4121da177e4SLinus Torvalds out_discipline:
4131da177e4SLinus Torvalds device->discipline->cleanup_device(device);
4141da177e4SLinus Torvalds device->discipline = NULL;
4151da177e4SLinus Torvalds out:
4161da177e4SLinus Torvalds module_put(discipline->owner);
4171da177e4SLinus Torvalds return rc;
4181da177e4SLinus Torvalds }
4191da177e4SLinus Torvalds
4204d284cacSHeiko Carstens static void
tape_cleanup_device(struct tape_device * device)4211da177e4SLinus Torvalds tape_cleanup_device(struct tape_device *device)
4221da177e4SLinus Torvalds {
4231da177e4SLinus Torvalds tapechar_cleanup_device(device);
4241da177e4SLinus Torvalds device->discipline->cleanup_device(device);
4251da177e4SLinus Torvalds module_put(device->discipline->owner);
4261da177e4SLinus Torvalds tape_remove_minor(device);
4271da177e4SLinus Torvalds tape_med_state_set(device, MS_UNKNOWN);
4281da177e4SLinus Torvalds }
4291da177e4SLinus Torvalds
4301da177e4SLinus Torvalds /*
4311da177e4SLinus Torvalds * Set device offline.
4321da177e4SLinus Torvalds *
4331da177e4SLinus Torvalds * Called by the common I/O layer if the drive should set offline on user
4341da177e4SLinus Torvalds * request. We may prevent this by returning an error.
4351da177e4SLinus Torvalds * Manual offline is only allowed while the drive is not in use.
4361da177e4SLinus Torvalds */
4371da177e4SLinus Torvalds int
tape_generic_offline(struct ccw_device * cdev)4384d7a3cdfSFrank Munzert tape_generic_offline(struct ccw_device *cdev)
4391da177e4SLinus Torvalds {
4404d7a3cdfSFrank Munzert struct tape_device *device;
4414d7a3cdfSFrank Munzert
442dff59b64SGreg Kroah-Hartman device = dev_get_drvdata(&cdev->dev);
4431da177e4SLinus Torvalds if (!device) {
4441da177e4SLinus Torvalds return -ENODEV;
4451da177e4SLinus Torvalds }
4461da177e4SLinus Torvalds
4471da177e4SLinus Torvalds DBF_LH(3, "(%08x): tape_generic_offline(%p)\n",
4481da177e4SLinus Torvalds device->cdev_id, device);
4491da177e4SLinus Torvalds
4501da177e4SLinus Torvalds spin_lock_irq(get_ccwdev_lock(device->cdev));
4511da177e4SLinus Torvalds switch (device->tape_state) {
4521da177e4SLinus Torvalds case TS_INIT:
4531da177e4SLinus Torvalds case TS_NOT_OPER:
4541da177e4SLinus Torvalds spin_unlock_irq(get_ccwdev_lock(device->cdev));
4551da177e4SLinus Torvalds break;
4561da177e4SLinus Torvalds case TS_UNUSED:
4571da177e4SLinus Torvalds tape_state_set(device, TS_INIT);
4581da177e4SLinus Torvalds spin_unlock_irq(get_ccwdev_lock(device->cdev));
4591da177e4SLinus Torvalds tape_cleanup_device(device);
4601da177e4SLinus Torvalds break;
4611da177e4SLinus Torvalds default:
4621da177e4SLinus Torvalds DBF_EVENT(3, "(%08x): Set offline failed "
4631da177e4SLinus Torvalds "- drive in use.\n",
4641da177e4SLinus Torvalds device->cdev_id);
4651da177e4SLinus Torvalds spin_unlock_irq(get_ccwdev_lock(device->cdev));
4661da177e4SLinus Torvalds return -EBUSY;
4671da177e4SLinus Torvalds }
4681da177e4SLinus Torvalds
4691da177e4SLinus Torvalds DBF_LH(3, "(%08x): Drive set offline.\n", device->cdev_id);
4701da177e4SLinus Torvalds return 0;
4711da177e4SLinus Torvalds }
4721da177e4SLinus Torvalds
4731da177e4SLinus Torvalds /*
4741da177e4SLinus Torvalds * Allocate memory for a new device structure.
4751da177e4SLinus Torvalds */
4761da177e4SLinus Torvalds static struct tape_device *
tape_alloc_device(void)4771da177e4SLinus Torvalds tape_alloc_device(void)
4781da177e4SLinus Torvalds {
4791da177e4SLinus Torvalds struct tape_device *device;
4801da177e4SLinus Torvalds
48188abaab4SEric Sesterhenn device = kzalloc(sizeof(struct tape_device), GFP_KERNEL);
4821da177e4SLinus Torvalds if (device == NULL) {
4831da177e4SLinus Torvalds DBF_EXCEPTION(2, "ti:no mem\n");
4841da177e4SLinus Torvalds return ERR_PTR(-ENOMEM);
4851da177e4SLinus Torvalds }
48688abaab4SEric Sesterhenn device->modeset_byte = kmalloc(1, GFP_KERNEL | GFP_DMA);
4871da177e4SLinus Torvalds if (device->modeset_byte == NULL) {
4881da177e4SLinus Torvalds DBF_EXCEPTION(2, "ti:no mem\n");
4891da177e4SLinus Torvalds kfree(device);
4901da177e4SLinus Torvalds return ERR_PTR(-ENOMEM);
4911da177e4SLinus Torvalds }
492369a4632SMartin Schwidefsky mutex_init(&device->mutex);
4931da177e4SLinus Torvalds INIT_LIST_HEAD(&device->req_queue);
4941da177e4SLinus Torvalds INIT_LIST_HEAD(&device->node);
4951da177e4SLinus Torvalds init_waitqueue_head(&device->state_change_wq);
4964657fb8aSMartin Schwidefsky init_waitqueue_head(&device->wait_queue);
4971da177e4SLinus Torvalds device->tape_state = TS_INIT;
4981da177e4SLinus Torvalds device->medium_state = MS_UNKNOWN;
4991da177e4SLinus Torvalds *device->modeset_byte = 0;
5001da177e4SLinus Torvalds device->first_minor = -1;
5011da177e4SLinus Torvalds atomic_set(&device->ref_count, 1);
502c1637532SMartin Schwidefsky INIT_DELAYED_WORK(&device->tape_dnr, tape_delayed_next_request);
5031da177e4SLinus Torvalds
5041da177e4SLinus Torvalds return device;
5051da177e4SLinus Torvalds }
5061da177e4SLinus Torvalds
5071da177e4SLinus Torvalds /*
5081da177e4SLinus Torvalds * Get a reference to an existing device structure. This will automatically
5091da177e4SLinus Torvalds * increment the reference count.
5101da177e4SLinus Torvalds */
5111da177e4SLinus Torvalds struct tape_device *
tape_get_device(struct tape_device * device)5128fd138c3SMartin Schwidefsky tape_get_device(struct tape_device *device)
5131da177e4SLinus Torvalds {
5148fd138c3SMartin Schwidefsky int count;
5151da177e4SLinus Torvalds
5168fd138c3SMartin Schwidefsky count = atomic_inc_return(&device->ref_count);
5178fd138c3SMartin Schwidefsky DBF_EVENT(4, "tape_get_device(%p) = %i\n", device, count);
5181da177e4SLinus Torvalds return device;
5191da177e4SLinus Torvalds }
5201da177e4SLinus Torvalds
5211da177e4SLinus Torvalds /*
5221da177e4SLinus Torvalds * Decrease the reference counter of a devices structure. If the
5231da177e4SLinus Torvalds * reference counter reaches zero free the device structure.
5241da177e4SLinus Torvalds * The function returns a NULL pointer to be used by the caller
5251da177e4SLinus Torvalds * for clearing reference pointers.
5261da177e4SLinus Torvalds */
5278fd138c3SMartin Schwidefsky void
tape_put_device(struct tape_device * device)5281da177e4SLinus Torvalds tape_put_device(struct tape_device *device)
5291da177e4SLinus Torvalds {
5308fd138c3SMartin Schwidefsky int count;
5311da177e4SLinus Torvalds
5328fd138c3SMartin Schwidefsky count = atomic_dec_return(&device->ref_count);
5338fd138c3SMartin Schwidefsky DBF_EVENT(4, "tape_put_device(%p) -> %i\n", device, count);
5348fd138c3SMartin Schwidefsky BUG_ON(count < 0);
5358fd138c3SMartin Schwidefsky if (count == 0) {
5361da177e4SLinus Torvalds kfree(device->modeset_byte);
5371da177e4SLinus Torvalds kfree(device);
5381da177e4SLinus Torvalds }
5391da177e4SLinus Torvalds }
5401da177e4SLinus Torvalds
5411da177e4SLinus Torvalds /*
5421da177e4SLinus Torvalds * Find tape device by a device index.
5431da177e4SLinus Torvalds */
5441da177e4SLinus Torvalds struct tape_device *
tape_find_device(int devindex)5458fd138c3SMartin Schwidefsky tape_find_device(int devindex)
5461da177e4SLinus Torvalds {
5471da177e4SLinus Torvalds struct tape_device *device, *tmp;
5481da177e4SLinus Torvalds
5491da177e4SLinus Torvalds device = ERR_PTR(-ENODEV);
5501da177e4SLinus Torvalds read_lock(&tape_device_lock);
5511da177e4SLinus Torvalds list_for_each_entry(tmp, &tape_device_list, node) {
5521da177e4SLinus Torvalds if (tmp->first_minor / TAPE_MINORS_PER_DEV == devindex) {
5538fd138c3SMartin Schwidefsky device = tape_get_device(tmp);
5541da177e4SLinus Torvalds break;
5551da177e4SLinus Torvalds }
5561da177e4SLinus Torvalds }
5571da177e4SLinus Torvalds read_unlock(&tape_device_lock);
5581da177e4SLinus Torvalds return device;
5591da177e4SLinus Torvalds }
5601da177e4SLinus Torvalds
5611da177e4SLinus Torvalds /*
5621da177e4SLinus Torvalds * Driverfs tape probe function.
5631da177e4SLinus Torvalds */
5641da177e4SLinus Torvalds int
tape_generic_probe(struct ccw_device * cdev)5651da177e4SLinus Torvalds tape_generic_probe(struct ccw_device *cdev)
5661da177e4SLinus Torvalds {
5671da177e4SLinus Torvalds struct tape_device *device;
568d7cf0d57SHeiko Carstens int ret;
569f455adcfSCornelia Huck struct ccw_dev_id dev_id;
5701da177e4SLinus Torvalds
5711da177e4SLinus Torvalds device = tape_alloc_device();
5721da177e4SLinus Torvalds if (IS_ERR(device))
5731da177e4SLinus Torvalds return -ENODEV;
574454e1fa1SPeter Oberparleiter ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP |
575454e1fa1SPeter Oberparleiter CCWDEV_DO_MULTIPATH);
576d7cf0d57SHeiko Carstens ret = sysfs_create_group(&cdev->dev.kobj, &tape_attr_group);
577d7cf0d57SHeiko Carstens if (ret) {
578d7cf0d57SHeiko Carstens tape_put_device(device);
579d7cf0d57SHeiko Carstens return ret;
580d7cf0d57SHeiko Carstens }
581dff59b64SGreg Kroah-Hartman dev_set_drvdata(&cdev->dev, device);
582d7cf0d57SHeiko Carstens cdev->handler = __tape_do_irq;
5831da177e4SLinus Torvalds device->cdev = cdev;
584f455adcfSCornelia Huck ccw_device_get_id(cdev, &dev_id);
585f455adcfSCornelia Huck device->cdev_id = devid_to_int(&dev_id);
586d7cf0d57SHeiko Carstens return ret;
5871da177e4SLinus Torvalds }
5881da177e4SLinus Torvalds
5894d284cacSHeiko Carstens static void
__tape_discard_requests(struct tape_device * device)5901da177e4SLinus Torvalds __tape_discard_requests(struct tape_device *device)
5911da177e4SLinus Torvalds {
5921da177e4SLinus Torvalds struct tape_request * request;
5931da177e4SLinus Torvalds struct list_head * l, *n;
5941da177e4SLinus Torvalds
5951da177e4SLinus Torvalds list_for_each_safe(l, n, &device->req_queue) {
5961da177e4SLinus Torvalds request = list_entry(l, struct tape_request, list);
5971da177e4SLinus Torvalds if (request->status == TAPE_REQUEST_IN_IO)
5981da177e4SLinus Torvalds request->status = TAPE_REQUEST_DONE;
5991da177e4SLinus Torvalds list_del(&request->list);
6001da177e4SLinus Torvalds
6011da177e4SLinus Torvalds /* Decrease ref_count for removed request. */
6028fd138c3SMartin Schwidefsky request->device = NULL;
6038fd138c3SMartin Schwidefsky tape_put_device(device);
6041da177e4SLinus Torvalds request->rc = -EIO;
6051da177e4SLinus Torvalds if (request->callback != NULL)
6061da177e4SLinus Torvalds request->callback(request, request->callback_data);
6071da177e4SLinus Torvalds }
6081da177e4SLinus Torvalds }
6091da177e4SLinus Torvalds
6101da177e4SLinus Torvalds /*
6111da177e4SLinus Torvalds * Driverfs tape remove function.
6121da177e4SLinus Torvalds *
6131da177e4SLinus Torvalds * This function is called whenever the common I/O layer detects the device
6141da177e4SLinus Torvalds * gone. This can happen at any time and we cannot refuse.
6151da177e4SLinus Torvalds */
6161da177e4SLinus Torvalds void
tape_generic_remove(struct ccw_device * cdev)6171da177e4SLinus Torvalds tape_generic_remove(struct ccw_device *cdev)
6181da177e4SLinus Torvalds {
6191da177e4SLinus Torvalds struct tape_device * device;
6201da177e4SLinus Torvalds
621dff59b64SGreg Kroah-Hartman device = dev_get_drvdata(&cdev->dev);
6221da177e4SLinus Torvalds if (!device) {
6231da177e4SLinus Torvalds return;
6241da177e4SLinus Torvalds }
6251da177e4SLinus Torvalds DBF_LH(3, "(%08x): tape_generic_remove(%p)\n", device->cdev_id, cdev);
6261da177e4SLinus Torvalds
6271da177e4SLinus Torvalds spin_lock_irq(get_ccwdev_lock(device->cdev));
6281da177e4SLinus Torvalds switch (device->tape_state) {
6291da177e4SLinus Torvalds case TS_INIT:
6301da177e4SLinus Torvalds tape_state_set(device, TS_NOT_OPER);
631*2c7749b9SJoe Perches fallthrough;
6321da177e4SLinus Torvalds case TS_NOT_OPER:
6331da177e4SLinus Torvalds /*
6341da177e4SLinus Torvalds * Nothing to do.
6351da177e4SLinus Torvalds */
6361da177e4SLinus Torvalds spin_unlock_irq(get_ccwdev_lock(device->cdev));
6371da177e4SLinus Torvalds break;
6381da177e4SLinus Torvalds case TS_UNUSED:
6391da177e4SLinus Torvalds /*
6401da177e4SLinus Torvalds * Need only to release the device.
6411da177e4SLinus Torvalds */
6421da177e4SLinus Torvalds tape_state_set(device, TS_NOT_OPER);
6431da177e4SLinus Torvalds spin_unlock_irq(get_ccwdev_lock(device->cdev));
6441da177e4SLinus Torvalds tape_cleanup_device(device);
6451da177e4SLinus Torvalds break;
6461da177e4SLinus Torvalds default:
6471da177e4SLinus Torvalds /*
6481da177e4SLinus Torvalds * There may be requests on the queue. We will not get
6491da177e4SLinus Torvalds * an interrupt for a request that was running. So we
6501da177e4SLinus Torvalds * just post them all as I/O errors.
6511da177e4SLinus Torvalds */
6521da177e4SLinus Torvalds DBF_EVENT(3, "(%08x): Drive in use vanished!\n",
6531da177e4SLinus Torvalds device->cdev_id);
654baebc70aSJoe Perches pr_warn("%s: A tape unit was detached while in use\n",
655baebc70aSJoe Perches dev_name(&device->cdev->dev));
6561da177e4SLinus Torvalds tape_state_set(device, TS_NOT_OPER);
6571da177e4SLinus Torvalds __tape_discard_requests(device);
6581da177e4SLinus Torvalds spin_unlock_irq(get_ccwdev_lock(device->cdev));
6591da177e4SLinus Torvalds tape_cleanup_device(device);
6601da177e4SLinus Torvalds }
6611da177e4SLinus Torvalds
6628fd138c3SMartin Schwidefsky device = dev_get_drvdata(&cdev->dev);
6638fd138c3SMartin Schwidefsky if (device) {
6641da177e4SLinus Torvalds sysfs_remove_group(&cdev->dev.kobj, &tape_attr_group);
6658fd138c3SMartin Schwidefsky dev_set_drvdata(&cdev->dev, NULL);
6668fd138c3SMartin Schwidefsky tape_put_device(device);
6671da177e4SLinus Torvalds }
6681da177e4SLinus Torvalds }
6691da177e4SLinus Torvalds
6701da177e4SLinus Torvalds /*
6711da177e4SLinus Torvalds * Allocate a new tape ccw request
6721da177e4SLinus Torvalds */
6731da177e4SLinus Torvalds struct tape_request *
tape_alloc_request(int cplength,int datasize)6741da177e4SLinus Torvalds tape_alloc_request(int cplength, int datasize)
6751da177e4SLinus Torvalds {
6761da177e4SLinus Torvalds struct tape_request *request;
6771da177e4SLinus Torvalds
6786aa0d3a9SStoyan Gaydarov BUG_ON(datasize > PAGE_SIZE || (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
6791da177e4SLinus Torvalds
6801da177e4SLinus Torvalds DBF_LH(6, "tape_alloc_request(%d, %d)\n", cplength, datasize);
6811da177e4SLinus Torvalds
68288abaab4SEric Sesterhenn request = kzalloc(sizeof(struct tape_request), GFP_KERNEL);
6831da177e4SLinus Torvalds if (request == NULL) {
6841da177e4SLinus Torvalds DBF_EXCEPTION(1, "cqra nomem\n");
6851da177e4SLinus Torvalds return ERR_PTR(-ENOMEM);
6861da177e4SLinus Torvalds }
6871da177e4SLinus Torvalds /* allocate channel program */
6881da177e4SLinus Torvalds if (cplength > 0) {
68988abaab4SEric Sesterhenn request->cpaddr = kcalloc(cplength, sizeof(struct ccw1),
6901da177e4SLinus Torvalds GFP_ATOMIC | GFP_DMA);
6911da177e4SLinus Torvalds if (request->cpaddr == NULL) {
6921da177e4SLinus Torvalds DBF_EXCEPTION(1, "cqra nomem\n");
6931da177e4SLinus Torvalds kfree(request);
6941da177e4SLinus Torvalds return ERR_PTR(-ENOMEM);
6951da177e4SLinus Torvalds }
6961da177e4SLinus Torvalds }
6971da177e4SLinus Torvalds /* alloc small kernel buffer */
6981da177e4SLinus Torvalds if (datasize > 0) {
69988abaab4SEric Sesterhenn request->cpdata = kzalloc(datasize, GFP_KERNEL | GFP_DMA);
7001da177e4SLinus Torvalds if (request->cpdata == NULL) {
7011da177e4SLinus Torvalds DBF_EXCEPTION(1, "cqra nomem\n");
7021da177e4SLinus Torvalds kfree(request->cpaddr);
7031da177e4SLinus Torvalds kfree(request);
7041da177e4SLinus Torvalds return ERR_PTR(-ENOMEM);
7051da177e4SLinus Torvalds }
7061da177e4SLinus Torvalds }
7071da177e4SLinus Torvalds DBF_LH(6, "New request %p(%p/%p)\n", request, request->cpaddr,
7081da177e4SLinus Torvalds request->cpdata);
7091da177e4SLinus Torvalds
7101da177e4SLinus Torvalds return request;
7111da177e4SLinus Torvalds }
7121da177e4SLinus Torvalds
7131da177e4SLinus Torvalds /*
7141da177e4SLinus Torvalds * Free tape ccw request
7151da177e4SLinus Torvalds */
7161da177e4SLinus Torvalds void
tape_free_request(struct tape_request * request)7171da177e4SLinus Torvalds tape_free_request (struct tape_request * request)
7181da177e4SLinus Torvalds {
7191da177e4SLinus Torvalds DBF_LH(6, "Free request %p\n", request);
7201da177e4SLinus Torvalds
7218fd138c3SMartin Schwidefsky if (request->device)
7228fd138c3SMartin Schwidefsky tape_put_device(request->device);
7231da177e4SLinus Torvalds kfree(request->cpdata);
7241da177e4SLinus Torvalds kfree(request->cpaddr);
7251da177e4SLinus Torvalds kfree(request);
7261da177e4SLinus Torvalds }
7271da177e4SLinus Torvalds
7284d284cacSHeiko Carstens static int
__tape_start_io(struct tape_device * device,struct tape_request * request)7294111796dSStefan Bader __tape_start_io(struct tape_device *device, struct tape_request *request)
7304111796dSStefan Bader {
7314111796dSStefan Bader int rc;
7324111796dSStefan Bader
7334111796dSStefan Bader rc = ccw_device_start(
7344111796dSStefan Bader device->cdev,
7354111796dSStefan Bader request->cpaddr,
7364111796dSStefan Bader (unsigned long) request,
7374111796dSStefan Bader 0x00,
7384111796dSStefan Bader request->options
7394111796dSStefan Bader );
7404111796dSStefan Bader if (rc == 0) {
7414111796dSStefan Bader request->status = TAPE_REQUEST_IN_IO;
7424111796dSStefan Bader } else if (rc == -EBUSY) {
7434111796dSStefan Bader /* The common I/O subsystem is currently busy. Retry later. */
7444111796dSStefan Bader request->status = TAPE_REQUEST_QUEUED;
745c1637532SMartin Schwidefsky schedule_delayed_work(&device->tape_dnr, 0);
7464111796dSStefan Bader rc = 0;
7474111796dSStefan Bader } else {
7484111796dSStefan Bader /* Start failed. Remove request and indicate failure. */
7494111796dSStefan Bader DBF_EVENT(1, "tape: start request failed with RC = %i\n", rc);
7504111796dSStefan Bader }
7514111796dSStefan Bader return rc;
7524111796dSStefan Bader }
7534111796dSStefan Bader
7544d284cacSHeiko Carstens static void
__tape_start_next_request(struct tape_device * device)7554111796dSStefan Bader __tape_start_next_request(struct tape_device *device)
7561da177e4SLinus Torvalds {
7571da177e4SLinus Torvalds struct list_head *l, *n;
7581da177e4SLinus Torvalds struct tape_request *request;
7591da177e4SLinus Torvalds int rc;
7601da177e4SLinus Torvalds
7614111796dSStefan Bader DBF_LH(6, "__tape_start_next_request(%p)\n", device);
7621da177e4SLinus Torvalds /*
7631da177e4SLinus Torvalds * Try to start each request on request queue until one is
7641da177e4SLinus Torvalds * started successful.
7651da177e4SLinus Torvalds */
7661da177e4SLinus Torvalds list_for_each_safe(l, n, &device->req_queue) {
7671da177e4SLinus Torvalds request = list_entry(l, struct tape_request, list);
7681da177e4SLinus Torvalds
7694111796dSStefan Bader /*
7704111796dSStefan Bader * Avoid race condition if bottom-half was triggered more than
7714111796dSStefan Bader * once.
7724111796dSStefan Bader */
7734111796dSStefan Bader if (request->status == TAPE_REQUEST_IN_IO)
7744111796dSStefan Bader return;
7755f384338SMichael Holzheu /*
7765f384338SMichael Holzheu * Request has already been stopped. We have to wait until
7775f384338SMichael Holzheu * the request is removed from the queue in the interrupt
7785f384338SMichael Holzheu * handling.
7795f384338SMichael Holzheu */
7805f384338SMichael Holzheu if (request->status == TAPE_REQUEST_DONE)
7815f384338SMichael Holzheu return;
7824111796dSStefan Bader
7834111796dSStefan Bader /*
7844111796dSStefan Bader * We wanted to cancel the request but the common I/O layer
7854111796dSStefan Bader * was busy at that time. This can only happen if this
7864111796dSStefan Bader * function is called by delayed_next_request.
7874111796dSStefan Bader * Otherwise we start the next request on the queue.
7884111796dSStefan Bader */
7894111796dSStefan Bader if (request->status == TAPE_REQUEST_CANCEL) {
7904111796dSStefan Bader rc = __tape_cancel_io(device, request);
7914111796dSStefan Bader } else {
7924111796dSStefan Bader rc = __tape_start_io(device, request);
7934111796dSStefan Bader }
7944111796dSStefan Bader if (rc == 0)
7954111796dSStefan Bader return;
7964111796dSStefan Bader
7974111796dSStefan Bader /* Set ending status. */
7981da177e4SLinus Torvalds request->rc = rc;
7991da177e4SLinus Torvalds request->status = TAPE_REQUEST_DONE;
8001da177e4SLinus Torvalds
8011da177e4SLinus Torvalds /* Remove from request queue. */
8021da177e4SLinus Torvalds list_del(&request->list);
8031da177e4SLinus Torvalds
8041da177e4SLinus Torvalds /* Do callback. */
8051da177e4SLinus Torvalds if (request->callback != NULL)
8061da177e4SLinus Torvalds request->callback(request, request->callback_data);
8074111796dSStefan Bader }
8084111796dSStefan Bader }
8094111796dSStefan Bader
8104111796dSStefan Bader static void
tape_delayed_next_request(struct work_struct * work)811c1637532SMartin Schwidefsky tape_delayed_next_request(struct work_struct *work)
8124111796dSStefan Bader {
813c1637532SMartin Schwidefsky struct tape_device *device =
814c1637532SMartin Schwidefsky container_of(work, struct tape_device, tape_dnr.work);
8154111796dSStefan Bader
8164111796dSStefan Bader DBF_LH(6, "tape_delayed_next_request(%p)\n", device);
8174111796dSStefan Bader spin_lock_irq(get_ccwdev_lock(device->cdev));
8184111796dSStefan Bader __tape_start_next_request(device);
8194111796dSStefan Bader spin_unlock_irq(get_ccwdev_lock(device->cdev));
8204111796dSStefan Bader }
8214111796dSStefan Bader
tape_long_busy_timeout(struct timer_list * t)822c9602ee7SKees Cook static void tape_long_busy_timeout(struct timer_list *t)
823cced1dd4SMichael Holzheu {
824c9602ee7SKees Cook struct tape_device *device = from_timer(device, t, lb_timeout);
825cced1dd4SMichael Holzheu struct tape_request *request;
826cced1dd4SMichael Holzheu
827cced1dd4SMichael Holzheu spin_lock_irq(get_ccwdev_lock(device->cdev));
828cced1dd4SMichael Holzheu request = list_entry(device->req_queue.next, struct tape_request, list);
8296aa0d3a9SStoyan Gaydarov BUG_ON(request->status != TAPE_REQUEST_LONG_BUSY);
830cced1dd4SMichael Holzheu DBF_LH(6, "%08x: Long busy timeout.\n", device->cdev_id);
831cced1dd4SMichael Holzheu __tape_start_next_request(device);
8328fd138c3SMartin Schwidefsky tape_put_device(device);
833cced1dd4SMichael Holzheu spin_unlock_irq(get_ccwdev_lock(device->cdev));
834cced1dd4SMichael Holzheu }
835cced1dd4SMichael Holzheu
8364d284cacSHeiko Carstens static void
__tape_end_request(struct tape_device * device,struct tape_request * request,int rc)8374111796dSStefan Bader __tape_end_request(
8384111796dSStefan Bader struct tape_device * device,
8394111796dSStefan Bader struct tape_request * request,
8404111796dSStefan Bader int rc)
8414111796dSStefan Bader {
8424111796dSStefan Bader DBF_LH(6, "__tape_end_request(%p, %p, %i)\n", device, request, rc);
8434111796dSStefan Bader if (request) {
8444111796dSStefan Bader request->rc = rc;
8454111796dSStefan Bader request->status = TAPE_REQUEST_DONE;
8464111796dSStefan Bader
8474111796dSStefan Bader /* Remove from request queue. */
8484111796dSStefan Bader list_del(&request->list);
8494111796dSStefan Bader
8504111796dSStefan Bader /* Do callback. */
8514111796dSStefan Bader if (request->callback != NULL)
8524111796dSStefan Bader request->callback(request, request->callback_data);
8534111796dSStefan Bader }
8541da177e4SLinus Torvalds
8551da177e4SLinus Torvalds /* Start next request. */
8561da177e4SLinus Torvalds if (!list_empty(&device->req_queue))
8574111796dSStefan Bader __tape_start_next_request(device);
8581da177e4SLinus Torvalds }
8591da177e4SLinus Torvalds
8601da177e4SLinus Torvalds /*
8611da177e4SLinus Torvalds * Write sense data to dbf
8621da177e4SLinus Torvalds */
8631da177e4SLinus Torvalds void
tape_dump_sense_dbf(struct tape_device * device,struct tape_request * request,struct irb * irb)8641da177e4SLinus Torvalds tape_dump_sense_dbf(struct tape_device *device, struct tape_request *request,
8651da177e4SLinus Torvalds struct irb *irb)
8661da177e4SLinus Torvalds {
8671da177e4SLinus Torvalds unsigned int *sptr;
8681da177e4SLinus Torvalds const char* op;
8691da177e4SLinus Torvalds
8701da177e4SLinus Torvalds if (request != NULL)
8711da177e4SLinus Torvalds op = tape_op_verbose[request->op];
8721da177e4SLinus Torvalds else
8731da177e4SLinus Torvalds op = "---";
8741da177e4SLinus Torvalds DBF_EVENT(3, "DSTAT : %02x CSTAT: %02x\n",
87523d805b6SPeter Oberparleiter irb->scsw.cmd.dstat, irb->scsw.cmd.cstat);
8761da177e4SLinus Torvalds DBF_EVENT(3, "DEVICE: %08x OP\t: %s\n", device->cdev_id, op);
8771da177e4SLinus Torvalds sptr = (unsigned int *) irb->ecw;
8781da177e4SLinus Torvalds DBF_EVENT(3, "%08x %08x\n", sptr[0], sptr[1]);
8791da177e4SLinus Torvalds DBF_EVENT(3, "%08x %08x\n", sptr[2], sptr[3]);
8801da177e4SLinus Torvalds DBF_EVENT(3, "%08x %08x\n", sptr[4], sptr[5]);
8811da177e4SLinus Torvalds DBF_EVENT(3, "%08x %08x\n", sptr[6], sptr[7]);
8821da177e4SLinus Torvalds }
8831da177e4SLinus Torvalds
8841da177e4SLinus Torvalds /*
8851da177e4SLinus Torvalds * I/O helper function. Adds the request to the request queue
8861da177e4SLinus Torvalds * and starts it if the tape is idle. Has to be called with
8871da177e4SLinus Torvalds * the device lock held.
8881da177e4SLinus Torvalds */
8894d284cacSHeiko Carstens static int
__tape_start_request(struct tape_device * device,struct tape_request * request)8904111796dSStefan Bader __tape_start_request(struct tape_device *device, struct tape_request *request)
8911da177e4SLinus Torvalds {
8921da177e4SLinus Torvalds int rc;
8931da177e4SLinus Torvalds
8941da177e4SLinus Torvalds switch (request->op) {
8951da177e4SLinus Torvalds case TO_MSEN:
8961da177e4SLinus Torvalds case TO_ASSIGN:
8971da177e4SLinus Torvalds case TO_UNASSIGN:
8981da177e4SLinus Torvalds case TO_READ_ATTMSG:
899e2963062SMichael Holzheu case TO_RDC:
9001da177e4SLinus Torvalds if (device->tape_state == TS_INIT)
9011da177e4SLinus Torvalds break;
9021da177e4SLinus Torvalds if (device->tape_state == TS_UNUSED)
9031da177e4SLinus Torvalds break;
904*2c7749b9SJoe Perches fallthrough;
9051da177e4SLinus Torvalds default:
9061da177e4SLinus Torvalds if (device->tape_state == TS_BLKUSE)
9071da177e4SLinus Torvalds break;
9081da177e4SLinus Torvalds if (device->tape_state != TS_IN_USE)
9091da177e4SLinus Torvalds return -ENODEV;
9101da177e4SLinus Torvalds }
9111da177e4SLinus Torvalds
9121da177e4SLinus Torvalds /* Increase use count of device for the added request. */
9138fd138c3SMartin Schwidefsky request->device = tape_get_device(device);
9141da177e4SLinus Torvalds
9151da177e4SLinus Torvalds if (list_empty(&device->req_queue)) {
9161da177e4SLinus Torvalds /* No other requests are on the queue. Start this one. */
9174111796dSStefan Bader rc = __tape_start_io(device, request);
9184111796dSStefan Bader if (rc)
9191da177e4SLinus Torvalds return rc;
9204111796dSStefan Bader
9211da177e4SLinus Torvalds DBF_LH(5, "Request %p added for execution.\n", request);
9221da177e4SLinus Torvalds list_add(&request->list, &device->req_queue);
9231da177e4SLinus Torvalds } else {
9241da177e4SLinus Torvalds DBF_LH(5, "Request %p add to queue.\n", request);
9251da177e4SLinus Torvalds request->status = TAPE_REQUEST_QUEUED;
9264111796dSStefan Bader list_add_tail(&request->list, &device->req_queue);
9271da177e4SLinus Torvalds }
9281da177e4SLinus Torvalds return 0;
9291da177e4SLinus Torvalds }
9301da177e4SLinus Torvalds
9311da177e4SLinus Torvalds /*
9321da177e4SLinus Torvalds * Add the request to the request queue, try to start it if the
9331da177e4SLinus Torvalds * tape is idle. Return without waiting for end of i/o.
9341da177e4SLinus Torvalds */
9351da177e4SLinus Torvalds int
tape_do_io_async(struct tape_device * device,struct tape_request * request)9361da177e4SLinus Torvalds tape_do_io_async(struct tape_device *device, struct tape_request *request)
9371da177e4SLinus Torvalds {
9381da177e4SLinus Torvalds int rc;
9391da177e4SLinus Torvalds
9401da177e4SLinus Torvalds DBF_LH(6, "tape_do_io_async(%p, %p)\n", device, request);
9411da177e4SLinus Torvalds
9421da177e4SLinus Torvalds spin_lock_irq(get_ccwdev_lock(device->cdev));
9431da177e4SLinus Torvalds /* Add request to request queue and try to start it. */
9444111796dSStefan Bader rc = __tape_start_request(device, request);
9451da177e4SLinus Torvalds spin_unlock_irq(get_ccwdev_lock(device->cdev));
9461da177e4SLinus Torvalds return rc;
9471da177e4SLinus Torvalds }
9481da177e4SLinus Torvalds
9491da177e4SLinus Torvalds /*
9501da177e4SLinus Torvalds * tape_do_io/__tape_wake_up
9511da177e4SLinus Torvalds * Add the request to the request queue, try to start it if the
9521da177e4SLinus Torvalds * tape is idle and wait uninterruptible for its completion.
9531da177e4SLinus Torvalds */
9541da177e4SLinus Torvalds static void
__tape_wake_up(struct tape_request * request,void * data)9551da177e4SLinus Torvalds __tape_wake_up(struct tape_request *request, void *data)
9561da177e4SLinus Torvalds {
9571da177e4SLinus Torvalds request->callback = NULL;
9581da177e4SLinus Torvalds wake_up((wait_queue_head_t *) data);
9591da177e4SLinus Torvalds }
9601da177e4SLinus Torvalds
9611da177e4SLinus Torvalds int
tape_do_io(struct tape_device * device,struct tape_request * request)9621da177e4SLinus Torvalds tape_do_io(struct tape_device *device, struct tape_request *request)
9631da177e4SLinus Torvalds {
9641da177e4SLinus Torvalds int rc;
9651da177e4SLinus Torvalds
9661da177e4SLinus Torvalds spin_lock_irq(get_ccwdev_lock(device->cdev));
9671da177e4SLinus Torvalds /* Setup callback */
9681da177e4SLinus Torvalds request->callback = __tape_wake_up;
9694657fb8aSMartin Schwidefsky request->callback_data = &device->wait_queue;
9701da177e4SLinus Torvalds /* Add request to request queue and try to start it. */
9714111796dSStefan Bader rc = __tape_start_request(device, request);
9721da177e4SLinus Torvalds spin_unlock_irq(get_ccwdev_lock(device->cdev));
9731da177e4SLinus Torvalds if (rc)
9741da177e4SLinus Torvalds return rc;
9751da177e4SLinus Torvalds /* Request added to the queue. Wait for its completion. */
9764657fb8aSMartin Schwidefsky wait_event(device->wait_queue, (request->callback == NULL));
9771da177e4SLinus Torvalds /* Get rc from request */
9781da177e4SLinus Torvalds return request->rc;
9791da177e4SLinus Torvalds }
9801da177e4SLinus Torvalds
9811da177e4SLinus Torvalds /*
9821da177e4SLinus Torvalds * tape_do_io_interruptible/__tape_wake_up_interruptible
9831da177e4SLinus Torvalds * Add the request to the request queue, try to start it if the
9841da177e4SLinus Torvalds * tape is idle and wait uninterruptible for its completion.
9851da177e4SLinus Torvalds */
9861da177e4SLinus Torvalds static void
__tape_wake_up_interruptible(struct tape_request * request,void * data)9871da177e4SLinus Torvalds __tape_wake_up_interruptible(struct tape_request *request, void *data)
9881da177e4SLinus Torvalds {
9891da177e4SLinus Torvalds request->callback = NULL;
9901da177e4SLinus Torvalds wake_up_interruptible((wait_queue_head_t *) data);
9911da177e4SLinus Torvalds }
9921da177e4SLinus Torvalds
9931da177e4SLinus Torvalds int
tape_do_io_interruptible(struct tape_device * device,struct tape_request * request)9941da177e4SLinus Torvalds tape_do_io_interruptible(struct tape_device *device,
9951da177e4SLinus Torvalds struct tape_request *request)
9961da177e4SLinus Torvalds {
9971da177e4SLinus Torvalds int rc;
9981da177e4SLinus Torvalds
9991da177e4SLinus Torvalds spin_lock_irq(get_ccwdev_lock(device->cdev));
10001da177e4SLinus Torvalds /* Setup callback */
10011da177e4SLinus Torvalds request->callback = __tape_wake_up_interruptible;
10024657fb8aSMartin Schwidefsky request->callback_data = &device->wait_queue;
10034111796dSStefan Bader rc = __tape_start_request(device, request);
10041da177e4SLinus Torvalds spin_unlock_irq(get_ccwdev_lock(device->cdev));
10051da177e4SLinus Torvalds if (rc)
10061da177e4SLinus Torvalds return rc;
10071da177e4SLinus Torvalds /* Request added to the queue. Wait for its completion. */
10084657fb8aSMartin Schwidefsky rc = wait_event_interruptible(device->wait_queue,
10094657fb8aSMartin Schwidefsky (request->callback == NULL));
10101da177e4SLinus Torvalds if (rc != -ERESTARTSYS)
10111da177e4SLinus Torvalds /* Request finished normally. */
10121da177e4SLinus Torvalds return request->rc;
10134111796dSStefan Bader
10141da177e4SLinus Torvalds /* Interrupted by a signal. We have to stop the current request. */
10151da177e4SLinus Torvalds spin_lock_irq(get_ccwdev_lock(device->cdev));
10164111796dSStefan Bader rc = __tape_cancel_io(device, request);
10174111796dSStefan Bader spin_unlock_irq(get_ccwdev_lock(device->cdev));
10181da177e4SLinus Torvalds if (rc == 0) {
10194111796dSStefan Bader /* Wait for the interrupt that acknowledges the halt. */
10204111796dSStefan Bader do {
10214111796dSStefan Bader rc = wait_event_interruptible(
10224657fb8aSMartin Schwidefsky device->wait_queue,
10234111796dSStefan Bader (request->callback == NULL)
10244111796dSStefan Bader );
10254cd190a7SMichael Holzheu } while (rc == -ERESTARTSYS);
10264111796dSStefan Bader
10271da177e4SLinus Torvalds DBF_EVENT(3, "IO stopped on %08x\n", device->cdev_id);
10281da177e4SLinus Torvalds rc = -ERESTARTSYS;
10291da177e4SLinus Torvalds }
10301da177e4SLinus Torvalds return rc;
10311da177e4SLinus Torvalds }
10321da177e4SLinus Torvalds
10331da177e4SLinus Torvalds /*
10345f384338SMichael Holzheu * Stop running ccw.
10355f384338SMichael Holzheu */
10365f384338SMichael Holzheu int
tape_cancel_io(struct tape_device * device,struct tape_request * request)10375f384338SMichael Holzheu tape_cancel_io(struct tape_device *device, struct tape_request *request)
10385f384338SMichael Holzheu {
10395f384338SMichael Holzheu int rc;
10405f384338SMichael Holzheu
10415f384338SMichael Holzheu spin_lock_irq(get_ccwdev_lock(device->cdev));
10425f384338SMichael Holzheu rc = __tape_cancel_io(device, request);
10435f384338SMichael Holzheu spin_unlock_irq(get_ccwdev_lock(device->cdev));
10445f384338SMichael Holzheu return rc;
10455f384338SMichael Holzheu }
10465f384338SMichael Holzheu
10475f384338SMichael Holzheu /*
10481da177e4SLinus Torvalds * Tape interrupt routine, called from the ccw_device layer
10491da177e4SLinus Torvalds */
10501da177e4SLinus Torvalds static void
__tape_do_irq(struct ccw_device * cdev,unsigned long intparm,struct irb * irb)10511da177e4SLinus Torvalds __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
10521da177e4SLinus Torvalds {
10531da177e4SLinus Torvalds struct tape_device *device;
10541da177e4SLinus Torvalds struct tape_request *request;
10551da177e4SLinus Torvalds int rc;
10561da177e4SLinus Torvalds
1057dff59b64SGreg Kroah-Hartman device = dev_get_drvdata(&cdev->dev);
10581da177e4SLinus Torvalds if (device == NULL) {
10591da177e4SLinus Torvalds return;
10601da177e4SLinus Torvalds }
10611da177e4SLinus Torvalds request = (struct tape_request *) intparm;
10621da177e4SLinus Torvalds
10631da177e4SLinus Torvalds DBF_LH(6, "__tape_do_irq(device=%p, request=%p)\n", device, request);
10641da177e4SLinus Torvalds
10651da177e4SLinus Torvalds /* On special conditions irb is an error pointer */
10661da177e4SLinus Torvalds if (IS_ERR(irb)) {
10674111796dSStefan Bader /* FIXME: What to do with the request? */
10681da177e4SLinus Torvalds switch (PTR_ERR(irb)) {
10691da177e4SLinus Torvalds case -ETIMEDOUT:
1070f2166bb1SSebastian Ott DBF_LH(1, "(%08x): Request timed out\n",
1071f2166bb1SSebastian Ott device->cdev_id);
1072*2c7749b9SJoe Perches fallthrough;
10731da177e4SLinus Torvalds case -EIO:
10744111796dSStefan Bader __tape_end_request(device, request, -EIO);
10751da177e4SLinus Torvalds break;
10761da177e4SLinus Torvalds default:
1077f2166bb1SSebastian Ott DBF_LH(1, "(%08x): Unexpected i/o error %li\n",
1078f2166bb1SSebastian Ott device->cdev_id, PTR_ERR(irb));
10791da177e4SLinus Torvalds }
10801da177e4SLinus Torvalds return;
10811da177e4SLinus Torvalds }
10821da177e4SLinus Torvalds
10834111796dSStefan Bader /*
10844111796dSStefan Bader * If the condition code is not zero and the start function bit is
10854111796dSStefan Bader * still set, this is an deferred error and the last start I/O did
1086842d3fbaSStefan Bader * not succeed. At this point the condition that caused the deferred
1087842d3fbaSStefan Bader * error might still apply. So we just schedule the request to be
1088842d3fbaSStefan Bader * started later.
10894111796dSStefan Bader */
109023d805b6SPeter Oberparleiter if (irb->scsw.cmd.cc != 0 &&
109123d805b6SPeter Oberparleiter (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
10925f384338SMichael Holzheu (request->status == TAPE_REQUEST_IN_IO)) {
10935f384338SMichael Holzheu DBF_EVENT(3,"(%08x): deferred cc=%i, fctl=%i. restarting\n",
109423d805b6SPeter Oberparleiter device->cdev_id, irb->scsw.cmd.cc, irb->scsw.cmd.fctl);
1095842d3fbaSStefan Bader request->status = TAPE_REQUEST_QUEUED;
10965f384338SMichael Holzheu schedule_delayed_work(&device->tape_dnr, HZ);
10974111796dSStefan Bader return;
10984111796dSStefan Bader }
10994111796dSStefan Bader
11001da177e4SLinus Torvalds /* May be an unsolicited irq */
11011da177e4SLinus Torvalds if(request != NULL)
110223d805b6SPeter Oberparleiter request->rescnt = irb->scsw.cmd.count;
110323d805b6SPeter Oberparleiter else if ((irb->scsw.cmd.dstat == 0x85 || irb->scsw.cmd.dstat == 0x80) &&
1104cced1dd4SMichael Holzheu !list_empty(&device->req_queue)) {
1105cced1dd4SMichael Holzheu /* Not Ready to Ready after long busy ? */
1106cced1dd4SMichael Holzheu struct tape_request *req;
1107cced1dd4SMichael Holzheu req = list_entry(device->req_queue.next,
1108cced1dd4SMichael Holzheu struct tape_request, list);
1109cced1dd4SMichael Holzheu if (req->status == TAPE_REQUEST_LONG_BUSY) {
1110cced1dd4SMichael Holzheu DBF_EVENT(3, "(%08x): del timer\n", device->cdev_id);
1111cced1dd4SMichael Holzheu if (del_timer(&device->lb_timeout)) {
1112cced1dd4SMichael Holzheu tape_put_device(device);
1113cced1dd4SMichael Holzheu __tape_start_next_request(device);
1114cced1dd4SMichael Holzheu }
1115cced1dd4SMichael Holzheu return;
1116cced1dd4SMichael Holzheu }
1117cced1dd4SMichael Holzheu }
111823d805b6SPeter Oberparleiter if (irb->scsw.cmd.dstat != 0x0c) {
11191da177e4SLinus Torvalds /* Set the 'ONLINE' flag depending on sense byte 1 */
11201da177e4SLinus Torvalds if(*(((__u8 *) irb->ecw) + 1) & SENSE_DRIVE_ONLINE)
11211da177e4SLinus Torvalds device->tape_generic_status |= GMT_ONLINE(~0);
11221da177e4SLinus Torvalds else
11231da177e4SLinus Torvalds device->tape_generic_status &= ~GMT_ONLINE(~0);
11241da177e4SLinus Torvalds
11251da177e4SLinus Torvalds /*
11261da177e4SLinus Torvalds * Any request that does not come back with channel end
11271da177e4SLinus Torvalds * and device end is unusual. Log the sense data.
11281da177e4SLinus Torvalds */
11291da177e4SLinus Torvalds DBF_EVENT(3,"-- Tape Interrupthandler --\n");
11301da177e4SLinus Torvalds tape_dump_sense_dbf(device, request, irb);
11311da177e4SLinus Torvalds } else {
11321da177e4SLinus Torvalds /* Upon normal completion the device _is_ online */
11331da177e4SLinus Torvalds device->tape_generic_status |= GMT_ONLINE(~0);
11341da177e4SLinus Torvalds }
11351da177e4SLinus Torvalds if (device->tape_state == TS_NOT_OPER) {
11361da177e4SLinus Torvalds DBF_EVENT(6, "tape:device is not operational\n");
11371da177e4SLinus Torvalds return;
11381da177e4SLinus Torvalds }
11391da177e4SLinus Torvalds
11401da177e4SLinus Torvalds /*
11411da177e4SLinus Torvalds * Request that were canceled still come back with an interrupt.
11421da177e4SLinus Torvalds * To detect these request the state will be set to TAPE_REQUEST_DONE.
11431da177e4SLinus Torvalds */
11441da177e4SLinus Torvalds if(request != NULL && request->status == TAPE_REQUEST_DONE) {
11454111796dSStefan Bader __tape_end_request(device, request, -EIO);
11461da177e4SLinus Torvalds return;
11471da177e4SLinus Torvalds }
11481da177e4SLinus Torvalds
11491da177e4SLinus Torvalds rc = device->discipline->irq(device, request, irb);
11501da177e4SLinus Torvalds /*
11511da177e4SLinus Torvalds * rc < 0 : request finished unsuccessfully.
11521da177e4SLinus Torvalds * rc == TAPE_IO_SUCCESS: request finished successfully.
11531da177e4SLinus Torvalds * rc == TAPE_IO_PENDING: request is still running. Ignore rc.
11541da177e4SLinus Torvalds * rc == TAPE_IO_RETRY: request finished but needs another go.
11551da177e4SLinus Torvalds * rc == TAPE_IO_STOP: request needs to get terminated.
11561da177e4SLinus Torvalds */
11571da177e4SLinus Torvalds switch (rc) {
11581da177e4SLinus Torvalds case TAPE_IO_SUCCESS:
11591da177e4SLinus Torvalds /* Upon normal completion the device _is_ online */
11601da177e4SLinus Torvalds device->tape_generic_status |= GMT_ONLINE(~0);
11614111796dSStefan Bader __tape_end_request(device, request, rc);
11621da177e4SLinus Torvalds break;
11631da177e4SLinus Torvalds case TAPE_IO_PENDING:
11641da177e4SLinus Torvalds break;
1165cced1dd4SMichael Holzheu case TAPE_IO_LONG_BUSY:
1166cced1dd4SMichael Holzheu device->lb_timeout.expires = jiffies +
1167cced1dd4SMichael Holzheu LONG_BUSY_TIMEOUT * HZ;
1168cced1dd4SMichael Holzheu DBF_EVENT(3, "(%08x): add timer\n", device->cdev_id);
1169cced1dd4SMichael Holzheu add_timer(&device->lb_timeout);
1170cced1dd4SMichael Holzheu request->status = TAPE_REQUEST_LONG_BUSY;
1171cced1dd4SMichael Holzheu break;
11721da177e4SLinus Torvalds case TAPE_IO_RETRY:
11734111796dSStefan Bader rc = __tape_start_io(device, request);
11744111796dSStefan Bader if (rc)
11754111796dSStefan Bader __tape_end_request(device, request, rc);
11761da177e4SLinus Torvalds break;
11771da177e4SLinus Torvalds case TAPE_IO_STOP:
11784111796dSStefan Bader rc = __tape_cancel_io(device, request);
11794111796dSStefan Bader if (rc)
11804111796dSStefan Bader __tape_end_request(device, request, rc);
11811da177e4SLinus Torvalds break;
11821da177e4SLinus Torvalds default:
11831da177e4SLinus Torvalds if (rc > 0) {
11841da177e4SLinus Torvalds DBF_EVENT(6, "xunknownrc\n");
11854111796dSStefan Bader __tape_end_request(device, request, -EIO);
11861da177e4SLinus Torvalds } else {
11874111796dSStefan Bader __tape_end_request(device, request, rc);
11881da177e4SLinus Torvalds }
11894111796dSStefan Bader break;
11901da177e4SLinus Torvalds }
11911da177e4SLinus Torvalds }
11921da177e4SLinus Torvalds
11931da177e4SLinus Torvalds /*
1194161beff8SHeiko Carstens * Tape device open function used by tape_char frontend.
11951da177e4SLinus Torvalds */
11961da177e4SLinus Torvalds int
tape_open(struct tape_device * device)11971da177e4SLinus Torvalds tape_open(struct tape_device *device)
11981da177e4SLinus Torvalds {
11991da177e4SLinus Torvalds int rc;
12001da177e4SLinus Torvalds
1201b3c21e49SFrank Munzert spin_lock_irq(get_ccwdev_lock(device->cdev));
12021da177e4SLinus Torvalds if (device->tape_state == TS_NOT_OPER) {
12031da177e4SLinus Torvalds DBF_EVENT(6, "TAPE:nodev\n");
12041da177e4SLinus Torvalds rc = -ENODEV;
12051da177e4SLinus Torvalds } else if (device->tape_state == TS_IN_USE) {
12061da177e4SLinus Torvalds DBF_EVENT(6, "TAPE:dbusy\n");
12071da177e4SLinus Torvalds rc = -EBUSY;
12081da177e4SLinus Torvalds } else if (device->tape_state == TS_BLKUSE) {
12091da177e4SLinus Torvalds DBF_EVENT(6, "TAPE:dbusy\n");
12101da177e4SLinus Torvalds rc = -EBUSY;
12111da177e4SLinus Torvalds } else if (device->discipline != NULL &&
12121da177e4SLinus Torvalds !try_module_get(device->discipline->owner)) {
12131da177e4SLinus Torvalds DBF_EVENT(6, "TAPE:nodisc\n");
12141da177e4SLinus Torvalds rc = -ENODEV;
12151da177e4SLinus Torvalds } else {
12161da177e4SLinus Torvalds tape_state_set(device, TS_IN_USE);
12171da177e4SLinus Torvalds rc = 0;
12181da177e4SLinus Torvalds }
1219b3c21e49SFrank Munzert spin_unlock_irq(get_ccwdev_lock(device->cdev));
12201da177e4SLinus Torvalds return rc;
12211da177e4SLinus Torvalds }
12221da177e4SLinus Torvalds
12231da177e4SLinus Torvalds /*
1224161beff8SHeiko Carstens * Tape device release function used by tape_char frontend.
12251da177e4SLinus Torvalds */
12261da177e4SLinus Torvalds int
tape_release(struct tape_device * device)12271da177e4SLinus Torvalds tape_release(struct tape_device *device)
12281da177e4SLinus Torvalds {
1229b3c21e49SFrank Munzert spin_lock_irq(get_ccwdev_lock(device->cdev));
12301da177e4SLinus Torvalds if (device->tape_state == TS_IN_USE)
12311da177e4SLinus Torvalds tape_state_set(device, TS_UNUSED);
12321da177e4SLinus Torvalds module_put(device->discipline->owner);
1233b3c21e49SFrank Munzert spin_unlock_irq(get_ccwdev_lock(device->cdev));
12341da177e4SLinus Torvalds return 0;
12351da177e4SLinus Torvalds }
12361da177e4SLinus Torvalds
12371da177e4SLinus Torvalds /*
12381da177e4SLinus Torvalds * Execute a magnetic tape command a number of times.
12391da177e4SLinus Torvalds */
12401da177e4SLinus Torvalds int
tape_mtop(struct tape_device * device,int mt_op,int mt_count)12411da177e4SLinus Torvalds tape_mtop(struct tape_device *device, int mt_op, int mt_count)
12421da177e4SLinus Torvalds {
12431da177e4SLinus Torvalds tape_mtop_fn fn;
12441da177e4SLinus Torvalds int rc;
12451da177e4SLinus Torvalds
12461da177e4SLinus Torvalds DBF_EVENT(6, "TAPE:mtio\n");
12471da177e4SLinus Torvalds DBF_EVENT(6, "TAPE:ioop: %x\n", mt_op);
12481da177e4SLinus Torvalds DBF_EVENT(6, "TAPE:arg: %x\n", mt_count);
12491da177e4SLinus Torvalds
12501da177e4SLinus Torvalds if (mt_op < 0 || mt_op >= TAPE_NR_MTOPS)
12511da177e4SLinus Torvalds return -EINVAL;
12521da177e4SLinus Torvalds fn = device->discipline->mtop_array[mt_op];
12531da177e4SLinus Torvalds if (fn == NULL)
12541da177e4SLinus Torvalds return -EINVAL;
12551da177e4SLinus Torvalds
12561da177e4SLinus Torvalds /* We assume that the backends can handle count up to 500. */
12571da177e4SLinus Torvalds if (mt_op == MTBSR || mt_op == MTFSR || mt_op == MTFSF ||
12581da177e4SLinus Torvalds mt_op == MTBSF || mt_op == MTFSFM || mt_op == MTBSFM) {
12591da177e4SLinus Torvalds rc = 0;
12601da177e4SLinus Torvalds for (; mt_count > 500; mt_count -= 500)
12611da177e4SLinus Torvalds if ((rc = fn(device, 500)) != 0)
12621da177e4SLinus Torvalds break;
12631da177e4SLinus Torvalds if (rc == 0)
12641da177e4SLinus Torvalds rc = fn(device, mt_count);
12651da177e4SLinus Torvalds } else
12661da177e4SLinus Torvalds rc = fn(device, mt_count);
12671da177e4SLinus Torvalds return rc;
12681da177e4SLinus Torvalds
12691da177e4SLinus Torvalds }
12701da177e4SLinus Torvalds
12711da177e4SLinus Torvalds /*
12721da177e4SLinus Torvalds * Tape init function.
12731da177e4SLinus Torvalds */
12741da177e4SLinus Torvalds static int
tape_init(void)12751da177e4SLinus Torvalds tape_init (void)
12761da177e4SLinus Torvalds {
127766a464dbSMichael Holzheu TAPE_DBF_AREA = debug_register ( "tape", 2, 2, 4*sizeof(long));
12781da177e4SLinus Torvalds debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
12791da177e4SLinus Torvalds #ifdef DBF_LIKE_HELL
12801da177e4SLinus Torvalds debug_set_level(TAPE_DBF_AREA, 6);
12811da177e4SLinus Torvalds #endif
1282e018ba1fSHeiko Carstens DBF_EVENT(3, "tape init\n");
12831da177e4SLinus Torvalds tape_proc_init();
12841da177e4SLinus Torvalds tapechar_init ();
12851da177e4SLinus Torvalds return 0;
12861da177e4SLinus Torvalds }
12871da177e4SLinus Torvalds
12881da177e4SLinus Torvalds /*
12891da177e4SLinus Torvalds * Tape exit function.
12901da177e4SLinus Torvalds */
12911da177e4SLinus Torvalds static void
tape_exit(void)12921da177e4SLinus Torvalds tape_exit(void)
12931da177e4SLinus Torvalds {
12941da177e4SLinus Torvalds DBF_EVENT(6, "tape exit\n");
12951da177e4SLinus Torvalds
12961da177e4SLinus Torvalds /* Get rid of the frontends */
12971da177e4SLinus Torvalds tapechar_exit();
12981da177e4SLinus Torvalds tape_proc_cleanup();
12991da177e4SLinus Torvalds debug_unregister (TAPE_DBF_AREA);
13001da177e4SLinus Torvalds }
13011da177e4SLinus Torvalds
13021da177e4SLinus Torvalds MODULE_AUTHOR("(C) 2001 IBM Deutschland Entwicklung GmbH by Carsten Otte and "
13031da177e4SLinus Torvalds "Michael Holzheu (cotte@de.ibm.com,holzheu@de.ibm.com)");
1304e018ba1fSHeiko Carstens MODULE_DESCRIPTION("Linux on zSeries channel attached tape device driver");
13051da177e4SLinus Torvalds MODULE_LICENSE("GPL");
13061da177e4SLinus Torvalds
13071da177e4SLinus Torvalds module_init(tape_init);
13081da177e4SLinus Torvalds module_exit(tape_exit);
13091da177e4SLinus Torvalds
13101da177e4SLinus Torvalds EXPORT_SYMBOL(tape_generic_remove);
13111da177e4SLinus Torvalds EXPORT_SYMBOL(tape_generic_probe);
13121da177e4SLinus Torvalds EXPORT_SYMBOL(tape_generic_online);
13131da177e4SLinus Torvalds EXPORT_SYMBOL(tape_generic_offline);
13141da177e4SLinus Torvalds EXPORT_SYMBOL(tape_put_device);
13158fd138c3SMartin Schwidefsky EXPORT_SYMBOL(tape_get_device);
13161da177e4SLinus Torvalds EXPORT_SYMBOL(tape_state_verbose);
13171da177e4SLinus Torvalds EXPORT_SYMBOL(tape_op_verbose);
13181da177e4SLinus Torvalds EXPORT_SYMBOL(tape_state_set);
13191da177e4SLinus Torvalds EXPORT_SYMBOL(tape_med_state_set);
13201da177e4SLinus Torvalds EXPORT_SYMBOL(tape_alloc_request);
13211da177e4SLinus Torvalds EXPORT_SYMBOL(tape_free_request);
13221da177e4SLinus Torvalds EXPORT_SYMBOL(tape_dump_sense_dbf);
13231da177e4SLinus Torvalds EXPORT_SYMBOL(tape_do_io);
13241da177e4SLinus Torvalds EXPORT_SYMBOL(tape_do_io_async);
13251da177e4SLinus Torvalds EXPORT_SYMBOL(tape_do_io_interruptible);
13265f384338SMichael Holzheu EXPORT_SYMBOL(tape_cancel_io);
13271da177e4SLinus Torvalds EXPORT_SYMBOL(tape_mtop);
1328