xref: /linux/drivers/s390/char/tape_core.c (revision fcc8487d477a3452a1d0ccbdd4c5e0e1e3cb8bed)
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);
1380