xref: /linux/drivers/s390/char/tape_34xx.c (revision 4f2c0a4acffbec01079c28f839422e64ddeff004)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *    tape device discipline for 3480/3490 tapes.
4  *
5  *    Copyright IBM Corp. 2001, 2009
6  *    Author(s): Carsten Otte <cotte@de.ibm.com>
7  *		 Tuan Ngo-Anh <ngoanh@de.ibm.com>
8  *		 Martin Schwidefsky <schwidefsky@de.ibm.com>
9  */
10 
11 #define KMSG_COMPONENT "tape_34xx"
12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/bio.h>
17 #include <linux/workqueue.h>
18 #include <linux/slab.h>
19 
20 #define TAPE_DBF_AREA	tape_34xx_dbf
21 
22 #include "tape.h"
23 #include "tape_std.h"
24 
25 /*
26  * Pointer to debug area.
27  */
28 debug_info_t *TAPE_DBF_AREA = NULL;
29 EXPORT_SYMBOL(TAPE_DBF_AREA);
30 
31 #define TAPE34XX_FMT_3480	0
32 #define TAPE34XX_FMT_3480_2_XF	1
33 #define TAPE34XX_FMT_3480_XF	2
34 
35 struct tape_34xx_block_id {
36 	unsigned int	wrap		: 1;
37 	unsigned int	segment		: 7;
38 	unsigned int	format		: 2;
39 	unsigned int	block		: 22;
40 };
41 
42 /*
43  * A list of block ID's is used to faster seek blocks.
44  */
45 struct tape_34xx_sbid {
46 	struct list_head		list;
47 	struct tape_34xx_block_id	bid;
48 };
49 
50 static void tape_34xx_delete_sbid_from(struct tape_device *, int);
51 
52 /*
53  * Medium sense for 34xx tapes. There is no 'real' medium sense call.
54  * So we just do a normal sense.
55  */
__tape_34xx_medium_sense(struct tape_request * request)56 static void __tape_34xx_medium_sense(struct tape_request *request)
57 {
58 	struct tape_device *device = request->device;
59 	unsigned char *sense;
60 
61 	if (request->rc == 0) {
62 		sense = request->cpdata;
63 
64 		/*
65 		 * This isn't quite correct. But since INTERVENTION_REQUIRED
66 		 * means that the drive is 'neither ready nor on-line' it is
67 		 * only slightly inaccurate to say there is no tape loaded if
68 		 * the drive isn't online...
69 		 */
70 		if (sense[0] & SENSE_INTERVENTION_REQUIRED)
71 			tape_med_state_set(device, MS_UNLOADED);
72 		else
73 			tape_med_state_set(device, MS_LOADED);
74 
75 		if (sense[1] & SENSE_WRITE_PROTECT)
76 			device->tape_generic_status |= GMT_WR_PROT(~0);
77 		else
78 			device->tape_generic_status &= ~GMT_WR_PROT(~0);
79 	} else
80 		DBF_EVENT(4, "tape_34xx: medium sense failed with rc=%d\n",
81 			request->rc);
82 	tape_free_request(request);
83 }
84 
tape_34xx_medium_sense(struct tape_device * device)85 static int tape_34xx_medium_sense(struct tape_device *device)
86 {
87 	struct tape_request *request;
88 	int rc;
89 
90 	request = tape_alloc_request(1, 32);
91 	if (IS_ERR(request)) {
92 		DBF_EXCEPTION(6, "MSEN fail\n");
93 		return PTR_ERR(request);
94 	}
95 
96 	request->op = TO_MSEN;
97 	tape_ccw_end(request->cpaddr, SENSE, 32, request->cpdata);
98 	rc = tape_do_io_interruptible(device, request);
99 	__tape_34xx_medium_sense(request);
100 	return rc;
101 }
102 
tape_34xx_medium_sense_async(struct tape_device * device)103 static void tape_34xx_medium_sense_async(struct tape_device *device)
104 {
105 	struct tape_request *request;
106 
107 	request = tape_alloc_request(1, 32);
108 	if (IS_ERR(request)) {
109 		DBF_EXCEPTION(6, "MSEN fail\n");
110 		return;
111 	}
112 
113 	request->op = TO_MSEN;
114 	tape_ccw_end(request->cpaddr, SENSE, 32, request->cpdata);
115 	request->callback = (void *) __tape_34xx_medium_sense;
116 	request->callback_data = NULL;
117 	tape_do_io_async(device, request);
118 }
119 
120 struct tape_34xx_work {
121 	struct tape_device	*device;
122 	enum tape_op		 op;
123 	struct work_struct	 work;
124 };
125 
126 /*
127  * These functions are currently used only to schedule a medium_sense for
128  * later execution. This is because we get an interrupt whenever a medium
129  * is inserted but cannot call tape_do_io* from an interrupt context.
130  * Maybe that's useful for other actions we want to start from the
131  * interrupt handler.
132  * Note: the work handler is called by the system work queue. The tape
133  * commands started by the handler need to be asynchrounous, otherwise
134  * a deadlock can occur e.g. in case of a deferred cc=1 (see __tape_do_irq).
135  */
136 static void
tape_34xx_work_handler(struct work_struct * work)137 tape_34xx_work_handler(struct work_struct *work)
138 {
139 	struct tape_34xx_work *p =
140 		container_of(work, struct tape_34xx_work, work);
141 	struct tape_device *device = p->device;
142 
143 	switch(p->op) {
144 		case TO_MSEN:
145 			tape_34xx_medium_sense_async(device);
146 			break;
147 		default:
148 			DBF_EVENT(3, "T34XX: internal error: unknown work\n");
149 	}
150 	tape_put_device(device);
151 	kfree(p);
152 }
153 
154 static int
tape_34xx_schedule_work(struct tape_device * device,enum tape_op op)155 tape_34xx_schedule_work(struct tape_device *device, enum tape_op op)
156 {
157 	struct tape_34xx_work *p;
158 
159 	if ((p = kzalloc(sizeof(*p), GFP_ATOMIC)) == NULL)
160 		return -ENOMEM;
161 
162 	INIT_WORK(&p->work, tape_34xx_work_handler);
163 
164 	p->device = tape_get_device(device);
165 	p->op     = op;
166 
167 	schedule_work(&p->work);
168 	return 0;
169 }
170 
171 /*
172  * Done Handler is called when dev stat = DEVICE-END (successful operation)
173  */
174 static inline int
tape_34xx_done(struct tape_request * request)175 tape_34xx_done(struct tape_request *request)
176 {
177 	DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
178 
179 	switch (request->op) {
180 		case TO_DSE:
181 		case TO_RUN:
182 		case TO_WRI:
183 		case TO_WTM:
184 		case TO_ASSIGN:
185 		case TO_UNASSIGN:
186 			tape_34xx_delete_sbid_from(request->device, 0);
187 			break;
188 		default:
189 			;
190 	}
191 	return TAPE_IO_SUCCESS;
192 }
193 
194 static inline int
tape_34xx_erp_failed(struct tape_request * request,int rc)195 tape_34xx_erp_failed(struct tape_request *request, int rc)
196 {
197 	DBF_EVENT(3, "Error recovery failed for %s (RC=%d)\n",
198 		  tape_op_verbose[request->op], rc);
199 	return rc;
200 }
201 
202 static inline int
tape_34xx_erp_succeeded(struct tape_request * request)203 tape_34xx_erp_succeeded(struct tape_request *request)
204 {
205 	DBF_EVENT(3, "Error Recovery successful for %s\n",
206 		  tape_op_verbose[request->op]);
207 	return tape_34xx_done(request);
208 }
209 
210 static inline int
tape_34xx_erp_retry(struct tape_request * request)211 tape_34xx_erp_retry(struct tape_request *request)
212 {
213 	DBF_EVENT(3, "xerp retr %s\n", tape_op_verbose[request->op]);
214 	return TAPE_IO_RETRY;
215 }
216 
217 /*
218  * This function is called, when no request is outstanding and we get an
219  * interrupt
220  */
221 static int
tape_34xx_unsolicited_irq(struct tape_device * device,struct irb * irb)222 tape_34xx_unsolicited_irq(struct tape_device *device, struct irb *irb)
223 {
224 	if (irb->scsw.cmd.dstat == 0x85) { /* READY */
225 		/* A medium was inserted in the drive. */
226 		DBF_EVENT(6, "xuud med\n");
227 		tape_34xx_delete_sbid_from(device, 0);
228 		tape_34xx_schedule_work(device, TO_MSEN);
229 	} else {
230 		DBF_EVENT(3, "unsol.irq! dev end: %08x\n", device->cdev_id);
231 		tape_dump_sense_dbf(device, NULL, irb);
232 	}
233 	return TAPE_IO_SUCCESS;
234 }
235 
236 /*
237  * Read Opposite Error Recovery Function:
238  * Used, when Read Forward does not work
239  */
240 static int
tape_34xx_erp_read_opposite(struct tape_device * device,struct tape_request * request)241 tape_34xx_erp_read_opposite(struct tape_device *device,
242 			    struct tape_request *request)
243 {
244 	if (request->op == TO_RFO) {
245 		/*
246 		 * We did read forward, but the data could not be read
247 		 * *correctly*. We transform the request to a read backward
248 		 * and try again.
249 		 */
250 		tape_std_read_backward(device, request);
251 		return tape_34xx_erp_retry(request);
252 	}
253 
254 	/*
255 	 * We tried to read forward and backward, but hat no
256 	 * success -> failed.
257 	 */
258 	return tape_34xx_erp_failed(request, -EIO);
259 }
260 
261 static int
tape_34xx_erp_bug(struct tape_device * device,struct tape_request * request,struct irb * irb,int no)262 tape_34xx_erp_bug(struct tape_device *device, struct tape_request *request,
263 		  struct irb *irb, int no)
264 {
265 	if (request->op != TO_ASSIGN) {
266 		dev_err(&device->cdev->dev, "An unexpected condition %d "
267 			"occurred in tape error recovery\n", no);
268 		tape_dump_sense_dbf(device, request, irb);
269 	}
270 	return tape_34xx_erp_failed(request, -EIO);
271 }
272 
273 /*
274  * Handle data overrun between cu and drive. The channel speed might
275  * be too slow.
276  */
277 static int
tape_34xx_erp_overrun(struct tape_device * device,struct tape_request * request,struct irb * irb)278 tape_34xx_erp_overrun(struct tape_device *device, struct tape_request *request,
279 		      struct irb *irb)
280 {
281 	if (irb->ecw[3] == 0x40) {
282 		dev_warn (&device->cdev->dev, "A data overrun occurred between"
283 			" the control unit and tape unit\n");
284 		return tape_34xx_erp_failed(request, -EIO);
285 	}
286 	return tape_34xx_erp_bug(device, request, irb, -1);
287 }
288 
289 /*
290  * Handle record sequence error.
291  */
292 static int
tape_34xx_erp_sequence(struct tape_device * device,struct tape_request * request,struct irb * irb)293 tape_34xx_erp_sequence(struct tape_device *device,
294 		       struct tape_request *request, struct irb *irb)
295 {
296 	if (irb->ecw[3] == 0x41) {
297 		/*
298 		 * cu detected incorrect block-id sequence on tape.
299 		 */
300 		dev_warn (&device->cdev->dev, "The block ID sequence on the "
301 			"tape is incorrect\n");
302 		return tape_34xx_erp_failed(request, -EIO);
303 	}
304 	/*
305 	 * Record sequence error bit is set, but erpa does not
306 	 * show record sequence error.
307 	 */
308 	return tape_34xx_erp_bug(device, request, irb, -2);
309 }
310 
311 /*
312  * This function analyses the tape's sense-data in case of a unit-check.
313  * If possible, it tries to recover from the error. Else the user is
314  * informed about the problem.
315  */
316 static int
tape_34xx_unit_check(struct tape_device * device,struct tape_request * request,struct irb * irb)317 tape_34xx_unit_check(struct tape_device *device, struct tape_request *request,
318 		     struct irb *irb)
319 {
320 	int inhibit_cu_recovery;
321 	__u8* sense;
322 
323 	inhibit_cu_recovery = (*device->modeset_byte & 0x80) ? 1 : 0;
324 	sense = irb->ecw;
325 
326 	if (
327 		sense[0] & SENSE_COMMAND_REJECT &&
328 		sense[1] & SENSE_WRITE_PROTECT
329 	) {
330 		if (
331 			request->op == TO_DSE ||
332 			request->op == TO_WRI ||
333 			request->op == TO_WTM
334 		) {
335 			/* medium is write protected */
336 			return tape_34xx_erp_failed(request, -EACCES);
337 		} else {
338 			return tape_34xx_erp_bug(device, request, irb, -3);
339 		}
340 	}
341 
342 	/*
343 	 * Special cases for various tape-states when reaching
344 	 * end of recorded area
345 	 *
346 	 * FIXME: Maybe a special case of the special case:
347 	 *        sense[0] == SENSE_EQUIPMENT_CHECK &&
348 	 *        sense[1] == SENSE_DRIVE_ONLINE    &&
349 	 *        sense[3] == 0x47 (Volume Fenced)
350 	 *
351 	 *        This was caused by continued FSF or FSR after an
352 	 *        'End Of Data'.
353 	 */
354 	if ((
355 		sense[0] == SENSE_DATA_CHECK      ||
356 		sense[0] == SENSE_EQUIPMENT_CHECK ||
357 		sense[0] == (SENSE_EQUIPMENT_CHECK | SENSE_DEFERRED_UNIT_CHECK)
358 	) && (
359 		sense[1] == SENSE_DRIVE_ONLINE ||
360 		sense[1] == (SENSE_BEGINNING_OF_TAPE | SENSE_WRITE_MODE)
361 	)) {
362 		switch (request->op) {
363 		/*
364 		 * sense[0] == SENSE_DATA_CHECK   &&
365 		 * sense[1] == SENSE_DRIVE_ONLINE
366 		 * sense[3] == 0x36 (End Of Data)
367 		 *
368 		 * Further seeks might return a 'Volume Fenced'.
369 		 */
370 		case TO_FSF:
371 		case TO_FSB:
372 			/* Trying to seek beyond end of recorded area */
373 			return tape_34xx_erp_failed(request, -ENOSPC);
374 		case TO_BSB:
375 			return tape_34xx_erp_retry(request);
376 
377 		/*
378 		 * sense[0] == SENSE_DATA_CHECK   &&
379 		 * sense[1] == SENSE_DRIVE_ONLINE &&
380 		 * sense[3] == 0x36 (End Of Data)
381 		 */
382 		case TO_LBL:
383 			/* Block could not be located. */
384 			tape_34xx_delete_sbid_from(device, 0);
385 			return tape_34xx_erp_failed(request, -EIO);
386 
387 		case TO_RFO:
388 			/* Read beyond end of recorded area -> 0 bytes read */
389 			return tape_34xx_erp_failed(request, 0);
390 
391 		/*
392 		 * sense[0] == SENSE_EQUIPMENT_CHECK &&
393 		 * sense[1] == SENSE_DRIVE_ONLINE    &&
394 		 * sense[3] == 0x38 (Physical End Of Volume)
395 		 */
396 		case TO_WRI:
397 			/* Writing at physical end of volume */
398 			return tape_34xx_erp_failed(request, -ENOSPC);
399 		default:
400 			return tape_34xx_erp_failed(request, 0);
401 		}
402 	}
403 
404 	/* Sensing special bits */
405 	if (sense[0] & SENSE_BUS_OUT_CHECK)
406 		return tape_34xx_erp_retry(request);
407 
408 	if (sense[0] & SENSE_DATA_CHECK) {
409 		/*
410 		 * hardware failure, damaged tape or improper
411 		 * operating conditions
412 		 */
413 		switch (sense[3]) {
414 		case 0x23:
415 			/* a read data check occurred */
416 			if ((sense[2] & SENSE_TAPE_SYNC_MODE) ||
417 			    inhibit_cu_recovery)
418 				// data check is not permanent, may be
419 				// recovered. We always use async-mode with
420 				// cu-recovery, so this should *never* happen.
421 				return tape_34xx_erp_bug(device, request,
422 							 irb, -4);
423 
424 			/* data check is permanent, CU recovery has failed */
425 			dev_warn (&device->cdev->dev, "A read error occurred "
426 				"that cannot be recovered\n");
427 			return tape_34xx_erp_failed(request, -EIO);
428 		case 0x25:
429 			// a write data check occurred
430 			if ((sense[2] & SENSE_TAPE_SYNC_MODE) ||
431 			    inhibit_cu_recovery)
432 				// data check is not permanent, may be
433 				// recovered. We always use async-mode with
434 				// cu-recovery, so this should *never* happen.
435 				return tape_34xx_erp_bug(device, request,
436 							 irb, -5);
437 
438 			// data check is permanent, cu-recovery has failed
439 			dev_warn (&device->cdev->dev, "A write error on the "
440 				"tape cannot be recovered\n");
441 			return tape_34xx_erp_failed(request, -EIO);
442 		case 0x26:
443 			/* Data Check (read opposite) occurred. */
444 			return tape_34xx_erp_read_opposite(device, request);
445 		case 0x28:
446 			/* ID-Mark at tape start couldn't be written */
447 			dev_warn (&device->cdev->dev, "Writing the ID-mark "
448 				"failed\n");
449 			return tape_34xx_erp_failed(request, -EIO);
450 		case 0x31:
451 			/* Tape void. Tried to read beyond end of device. */
452 			dev_warn (&device->cdev->dev, "Reading the tape beyond"
453 				" the end of the recorded area failed\n");
454 			return tape_34xx_erp_failed(request, -ENOSPC);
455 		case 0x41:
456 			/* Record sequence error. */
457 			dev_warn (&device->cdev->dev, "The tape contains an "
458 				"incorrect block ID sequence\n");
459 			return tape_34xx_erp_failed(request, -EIO);
460 		default:
461 			/* all data checks for 3480 should result in one of
462 			 * the above erpa-codes. For 3490, other data-check
463 			 * conditions do exist. */
464 			if (device->cdev->id.driver_info == tape_3480)
465 				return tape_34xx_erp_bug(device, request,
466 							 irb, -6);
467 		}
468 	}
469 
470 	if (sense[0] & SENSE_OVERRUN)
471 		return tape_34xx_erp_overrun(device, request, irb);
472 
473 	if (sense[1] & SENSE_RECORD_SEQUENCE_ERR)
474 		return tape_34xx_erp_sequence(device, request, irb);
475 
476 	/* Sensing erpa codes */
477 	switch (sense[3]) {
478 	case 0x00:
479 		/* Unit check with erpa code 0. Report and ignore. */
480 		return TAPE_IO_SUCCESS;
481 	case 0x21:
482 		/*
483 		 * Data streaming not operational. CU will switch to
484 		 * interlock mode. Reissue the command.
485 		 */
486 		return tape_34xx_erp_retry(request);
487 	case 0x22:
488 		/*
489 		 * Path equipment check. Might be drive adapter error, buffer
490 		 * error on the lower interface, internal path not usable,
491 		 * or error during cartridge load.
492 		 */
493 		dev_warn (&device->cdev->dev, "A path equipment check occurred"
494 			" for the tape device\n");
495 		return tape_34xx_erp_failed(request, -EIO);
496 	case 0x24:
497 		/*
498 		 * Load display check. Load display was command was issued,
499 		 * but the drive is displaying a drive check message. Can
500 		 * be threated as "device end".
501 		 */
502 		return tape_34xx_erp_succeeded(request);
503 	case 0x27:
504 		/*
505 		 * Command reject. May indicate illegal channel program or
506 		 * buffer over/underrun. Since all channel programs are
507 		 * issued by this driver and ought be correct, we assume a
508 		 * over/underrun situation and retry the channel program.
509 		 */
510 		return tape_34xx_erp_retry(request);
511 	case 0x29:
512 		/*
513 		 * Function incompatible. Either the tape is idrc compressed
514 		 * but the hardware isn't capable to do idrc, or a perform
515 		 * subsystem func is issued and the CU is not on-line.
516 		 */
517 		return tape_34xx_erp_failed(request, -EIO);
518 	case 0x2a:
519 		/*
520 		 * Unsolicited environmental data. An internal counter
521 		 * overflows, we can ignore this and reissue the cmd.
522 		 */
523 		return tape_34xx_erp_retry(request);
524 	case 0x2b:
525 		/*
526 		 * Environmental data present. Indicates either unload
527 		 * completed ok or read buffered log command completed ok.
528 		 */
529 		if (request->op == TO_RUN) {
530 			/* Rewind unload completed ok. */
531 			tape_med_state_set(device, MS_UNLOADED);
532 			return tape_34xx_erp_succeeded(request);
533 		}
534 		/* tape_34xx doesn't use read buffered log commands. */
535 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
536 	case 0x2c:
537 		/*
538 		 * Permanent equipment check. CU has tried recovery, but
539 		 * did not succeed.
540 		 */
541 		return tape_34xx_erp_failed(request, -EIO);
542 	case 0x2d:
543 		/* Data security erase failure. */
544 		if (request->op == TO_DSE)
545 			return tape_34xx_erp_failed(request, -EIO);
546 		/* Data security erase failure, but no such command issued. */
547 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
548 	case 0x2e:
549 		/*
550 		 * Not capable. This indicates either that the drive fails
551 		 * reading the format id mark or that format specified
552 		 * is not supported by the drive.
553 		 */
554 		dev_warn (&device->cdev->dev, "The tape unit cannot process "
555 			"the tape format\n");
556 		return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
557 	case 0x30:
558 		/* The medium is write protected. */
559 		dev_warn (&device->cdev->dev, "The tape medium is write-"
560 			"protected\n");
561 		return tape_34xx_erp_failed(request, -EACCES);
562 	case 0x32:
563 		// Tension loss. We cannot recover this, it's an I/O error.
564 		dev_warn (&device->cdev->dev, "The tape does not have the "
565 			"required tape tension\n");
566 		return tape_34xx_erp_failed(request, -EIO);
567 	case 0x33:
568 		/*
569 		 * Load Failure. The cartridge was not inserted correctly or
570 		 * the tape is not threaded correctly.
571 		 */
572 		dev_warn (&device->cdev->dev, "The tape unit failed to load"
573 			" the cartridge\n");
574 		tape_34xx_delete_sbid_from(device, 0);
575 		return tape_34xx_erp_failed(request, -EIO);
576 	case 0x34:
577 		/*
578 		 * Unload failure. The drive cannot maintain tape tension
579 		 * and control tape movement during an unload operation.
580 		 */
581 		dev_warn (&device->cdev->dev, "Automatic unloading of the tape"
582 			" cartridge failed\n");
583 		if (request->op == TO_RUN)
584 			return tape_34xx_erp_failed(request, -EIO);
585 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
586 	case 0x35:
587 		/*
588 		 * Drive equipment check. One of the following:
589 		 * - cu cannot recover from a drive detected error
590 		 * - a check code message is shown on drive display
591 		 * - the cartridge loader does not respond correctly
592 		 * - a failure occurs during an index, load, or unload cycle
593 		 */
594 		dev_warn (&device->cdev->dev, "An equipment check has occurred"
595 			" on the tape unit\n");
596 		return tape_34xx_erp_failed(request, -EIO);
597 	case 0x36:
598 		if (device->cdev->id.driver_info == tape_3490)
599 			/* End of data. */
600 			return tape_34xx_erp_failed(request, -EIO);
601 		/* This erpa is reserved for 3480 */
602 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
603 	case 0x37:
604 		/*
605 		 * Tape length error. The tape is shorter than reported in
606 		 * the beginning-of-tape data.
607 		 */
608 		dev_warn (&device->cdev->dev, "The tape information states an"
609 			" incorrect length\n");
610 		return tape_34xx_erp_failed(request, -EIO);
611 	case 0x38:
612 		/*
613 		 * Physical end of tape. A read/write operation reached
614 		 * the physical end of tape.
615 		 */
616 		if (request->op==TO_WRI ||
617 		    request->op==TO_DSE ||
618 		    request->op==TO_WTM)
619 			return tape_34xx_erp_failed(request, -ENOSPC);
620 		return tape_34xx_erp_failed(request, -EIO);
621 	case 0x39:
622 		/* Backward at Beginning of tape. */
623 		return tape_34xx_erp_failed(request, -EIO);
624 	case 0x3a:
625 		/* Drive switched to not ready. */
626 		dev_warn (&device->cdev->dev, "The tape unit is not ready\n");
627 		return tape_34xx_erp_failed(request, -EIO);
628 	case 0x3b:
629 		/* Manual rewind or unload. This causes an I/O error. */
630 		dev_warn (&device->cdev->dev, "The tape medium has been "
631 			"rewound or unloaded manually\n");
632 		tape_34xx_delete_sbid_from(device, 0);
633 		return tape_34xx_erp_failed(request, -EIO);
634 	case 0x42:
635 		/*
636 		 * Degraded mode. A condition that can cause degraded
637 		 * performance is detected.
638 		 */
639 		dev_warn (&device->cdev->dev, "The tape subsystem is running "
640 			"in degraded mode\n");
641 		return tape_34xx_erp_retry(request);
642 	case 0x43:
643 		/* Drive not ready. */
644 		tape_34xx_delete_sbid_from(device, 0);
645 		tape_med_state_set(device, MS_UNLOADED);
646 		/* Some commands commands are successful even in this case */
647 		if (sense[1] & SENSE_DRIVE_ONLINE) {
648 			switch(request->op) {
649 				case TO_ASSIGN:
650 				case TO_UNASSIGN:
651 				case TO_DIS:
652 				case TO_NOP:
653 					return tape_34xx_done(request);
654 					break;
655 				default:
656 					break;
657 			}
658 		}
659 		return tape_34xx_erp_failed(request, -ENOMEDIUM);
660 	case 0x44:
661 		/* Locate Block unsuccessful. */
662 		if (request->op != TO_BLOCK && request->op != TO_LBL)
663 			/* No locate block was issued. */
664 			return tape_34xx_erp_bug(device, request,
665 						 irb, sense[3]);
666 		return tape_34xx_erp_failed(request, -EIO);
667 	case 0x45:
668 		/* The drive is assigned to a different channel path. */
669 		dev_warn (&device->cdev->dev, "The tape unit is already "
670 			"assigned\n");
671 		return tape_34xx_erp_failed(request, -EIO);
672 	case 0x46:
673 		/*
674 		 * Drive not on-line. Drive may be switched offline,
675 		 * the power supply may be switched off or
676 		 * the drive address may not be set correctly.
677 		 */
678 		dev_warn (&device->cdev->dev, "The tape unit is not online\n");
679 		return tape_34xx_erp_failed(request, -EIO);
680 	case 0x47:
681 		/* Volume fenced. CU reports volume integrity is lost. */
682 		dev_warn (&device->cdev->dev, "The control unit has fenced "
683 			"access to the tape volume\n");
684 		tape_34xx_delete_sbid_from(device, 0);
685 		return tape_34xx_erp_failed(request, -EIO);
686 	case 0x48:
687 		/* Log sense data and retry request. */
688 		return tape_34xx_erp_retry(request);
689 	case 0x49:
690 		/* Bus out check. A parity check error on the bus was found. */
691 		dev_warn (&device->cdev->dev, "A parity error occurred on the "
692 			"tape bus\n");
693 		return tape_34xx_erp_failed(request, -EIO);
694 	case 0x4a:
695 		/* Control unit erp failed. */
696 		dev_warn (&device->cdev->dev, "I/O error recovery failed on "
697 			"the tape control unit\n");
698 		return tape_34xx_erp_failed(request, -EIO);
699 	case 0x4b:
700 		/*
701 		 * CU and drive incompatible. The drive requests micro-program
702 		 * patches, which are not available on the CU.
703 		 */
704 		dev_warn (&device->cdev->dev, "The tape unit requires a "
705 			"firmware update\n");
706 		return tape_34xx_erp_failed(request, -EIO);
707 	case 0x4c:
708 		/*
709 		 * Recovered Check-One failure. Cu develops a hardware error,
710 		 * but is able to recover.
711 		 */
712 		return tape_34xx_erp_retry(request);
713 	case 0x4d:
714 		if (device->cdev->id.driver_info == tape_3490)
715 			/*
716 			 * Resetting event received. Since the driver does
717 			 * not support resetting event recovery (which has to
718 			 * be handled by the I/O Layer), retry our command.
719 			 */
720 			return tape_34xx_erp_retry(request);
721 		/* This erpa is reserved for 3480. */
722 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
723 	case 0x4e:
724 		if (device->cdev->id.driver_info == tape_3490) {
725 			/*
726 			 * Maximum block size exceeded. This indicates, that
727 			 * the block to be written is larger than allowed for
728 			 * buffered mode.
729 			 */
730 			dev_warn (&device->cdev->dev, "The maximum block size"
731 				" for buffered mode is exceeded\n");
732 			return tape_34xx_erp_failed(request, -ENOBUFS);
733 		}
734 		/* This erpa is reserved for 3480. */
735 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
736 	case 0x50:
737 		/*
738 		 * Read buffered log (Overflow). CU is running in extended
739 		 * buffered log mode, and a counter overflows. This should
740 		 * never happen, since we're never running in extended
741 		 * buffered log mode.
742 		 */
743 		return tape_34xx_erp_retry(request);
744 	case 0x51:
745 		/*
746 		 * Read buffered log (EOV). EOF processing occurs while the
747 		 * CU is in extended buffered log mode. This should never
748 		 * happen, since we're never running in extended buffered
749 		 * log mode.
750 		 */
751 		return tape_34xx_erp_retry(request);
752 	case 0x52:
753 		/* End of Volume complete. Rewind unload completed ok. */
754 		if (request->op == TO_RUN) {
755 			tape_med_state_set(device, MS_UNLOADED);
756 			tape_34xx_delete_sbid_from(device, 0);
757 			return tape_34xx_erp_succeeded(request);
758 		}
759 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
760 	case 0x53:
761 		/* Global command intercept. */
762 		return tape_34xx_erp_retry(request);
763 	case 0x54:
764 		/* Channel interface recovery (temporary). */
765 		return tape_34xx_erp_retry(request);
766 	case 0x55:
767 		/* Channel interface recovery (permanent). */
768 		dev_warn (&device->cdev->dev, "A channel interface error cannot be"
769 			" recovered\n");
770 		return tape_34xx_erp_failed(request, -EIO);
771 	case 0x56:
772 		/* Channel protocol error. */
773 		dev_warn (&device->cdev->dev, "A channel protocol error "
774 			"occurred\n");
775 		return tape_34xx_erp_failed(request, -EIO);
776 	case 0x57:
777 		/*
778 		 * 3480: Attention intercept.
779 		 * 3490: Global status intercept.
780 		 */
781 		return tape_34xx_erp_retry(request);
782 	case 0x5a:
783 		/*
784 		 * Tape length incompatible. The tape inserted is too long,
785 		 * which could cause damage to the tape or the drive.
786 		 */
787 		dev_warn (&device->cdev->dev, "The tape unit does not support "
788 			"the tape length\n");
789 		return tape_34xx_erp_failed(request, -EIO);
790 	case 0x5b:
791 		/* Format 3480 XF incompatible */
792 		if (sense[1] & SENSE_BEGINNING_OF_TAPE)
793 			/* The tape will get overwritten. */
794 			return tape_34xx_erp_retry(request);
795 		dev_warn (&device->cdev->dev, "The tape unit does not support"
796 			" format 3480 XF\n");
797 		return tape_34xx_erp_failed(request, -EIO);
798 	case 0x5c:
799 		/* Format 3480-2 XF incompatible */
800 		dev_warn (&device->cdev->dev, "The tape unit does not support tape "
801 			"format 3480-2 XF\n");
802 		return tape_34xx_erp_failed(request, -EIO);
803 	case 0x5d:
804 		/* Tape length violation. */
805 		dev_warn (&device->cdev->dev, "The tape unit does not support"
806 			" the current tape length\n");
807 		return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
808 	case 0x5e:
809 		/* Compaction algorithm incompatible. */
810 		dev_warn (&device->cdev->dev, "The tape unit does not support"
811 			" the compaction algorithm\n");
812 		return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
813 
814 		/* The following erpas should have been covered earlier. */
815 	case 0x23: /* Read data check. */
816 	case 0x25: /* Write data check. */
817 	case 0x26: /* Data check (read opposite). */
818 	case 0x28: /* Write id mark check. */
819 	case 0x31: /* Tape void. */
820 	case 0x40: /* Overrun error. */
821 	case 0x41: /* Record sequence error. */
822 		/* All other erpas are reserved for future use. */
823 	default:
824 		return tape_34xx_erp_bug(device, request, irb, sense[3]);
825 	}
826 }
827 
828 /*
829  * 3480/3490 interrupt handler
830  */
831 static int
tape_34xx_irq(struct tape_device * device,struct tape_request * request,struct irb * irb)832 tape_34xx_irq(struct tape_device *device, struct tape_request *request,
833 	      struct irb *irb)
834 {
835 	if (request == NULL)
836 		return tape_34xx_unsolicited_irq(device, irb);
837 
838 	if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) &&
839 	    (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) &&
840 	    (request->op == TO_WRI)) {
841 		/* Write at end of volume */
842 		return tape_34xx_erp_failed(request, -ENOSPC);
843 	}
844 
845 	if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)
846 		return tape_34xx_unit_check(device, request, irb);
847 
848 	if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) {
849 		/*
850 		 * A unit exception occurs on skipping over a tapemark block.
851 		 */
852 		if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) {
853 			if (request->op == TO_BSB || request->op == TO_FSB)
854 				request->rescnt++;
855 			else
856 				DBF_EVENT(5, "Unit Exception!\n");
857 		}
858 		return tape_34xx_done(request);
859 	}
860 
861 	DBF_EVENT(6, "xunknownirq\n");
862 	tape_dump_sense_dbf(device, request, irb);
863 	return TAPE_IO_STOP;
864 }
865 
866 /*
867  * ioctl_overload
868  */
869 static int
tape_34xx_ioctl(struct tape_device * device,unsigned int cmd,unsigned long arg)870 tape_34xx_ioctl(struct tape_device *device, unsigned int cmd, unsigned long arg)
871 {
872 	if (cmd == TAPE390_DISPLAY) {
873 		struct display_struct disp;
874 
875 		if (copy_from_user(&disp, (char __user *) arg, sizeof(disp)) != 0)
876 			return -EFAULT;
877 
878 		return tape_std_display(device, &disp);
879 	} else
880 		return -EINVAL;
881 }
882 
883 static inline void
tape_34xx_append_new_sbid(struct tape_34xx_block_id bid,struct list_head * l)884 tape_34xx_append_new_sbid(struct tape_34xx_block_id bid, struct list_head *l)
885 {
886 	struct tape_34xx_sbid *	new_sbid;
887 
888 	new_sbid = kmalloc(sizeof(*new_sbid), GFP_ATOMIC);
889 	if (!new_sbid)
890 		return;
891 
892 	new_sbid->bid = bid;
893 	list_add(&new_sbid->list, l);
894 }
895 
896 /*
897  * Build up the search block ID list. The block ID consists of a logical
898  * block number and a hardware specific part. The hardware specific part
899  * helps the tape drive to speed up searching for a specific block.
900  */
901 static void
tape_34xx_add_sbid(struct tape_device * device,struct tape_34xx_block_id bid)902 tape_34xx_add_sbid(struct tape_device *device, struct tape_34xx_block_id bid)
903 {
904 	struct list_head *	sbid_list;
905 	struct tape_34xx_sbid *	sbid;
906 	struct list_head *	l;
907 
908 	/*
909 	 * immediately return if there is no list at all or the block to add
910 	 * is located in segment 1 of wrap 0 because this position is used
911 	 * if no hardware position data is supplied.
912 	 */
913 	sbid_list = (struct list_head *) device->discdata;
914 	if (!sbid_list || (bid.segment < 2 && bid.wrap == 0))
915 		return;
916 
917 	/*
918 	 * Search the position where to insert the new entry. Hardware
919 	 * acceleration uses only the segment and wrap number. So we
920 	 * need only one entry for a specific wrap/segment combination.
921 	 * If there is a block with a lower number but the same hard-
922 	 * ware position data we just update the block number in the
923 	 * existing entry.
924 	 */
925 	list_for_each(l, sbid_list) {
926 		sbid = list_entry(l, struct tape_34xx_sbid, list);
927 
928 		if (
929 			(sbid->bid.segment == bid.segment) &&
930 			(sbid->bid.wrap    == bid.wrap)
931 		) {
932 			if (bid.block < sbid->bid.block)
933 				sbid->bid = bid;
934 			else return;
935 			break;
936 		}
937 
938 		/* Sort in according to logical block number. */
939 		if (bid.block < sbid->bid.block) {
940 			tape_34xx_append_new_sbid(bid, l->prev);
941 			break;
942 		}
943 	}
944 	/* List empty or new block bigger than last entry. */
945 	if (l == sbid_list)
946 		tape_34xx_append_new_sbid(bid, l->prev);
947 
948 	DBF_LH(4, "Current list is:\n");
949 	list_for_each(l, sbid_list) {
950 		sbid = list_entry(l, struct tape_34xx_sbid, list);
951 		DBF_LH(4, "%d:%03d@%05d\n",
952 			sbid->bid.wrap,
953 			sbid->bid.segment,
954 			sbid->bid.block
955 		);
956 	}
957 }
958 
959 /*
960  * Delete all entries from the search block ID list that belong to tape blocks
961  * equal or higher than the given number.
962  */
963 static void
tape_34xx_delete_sbid_from(struct tape_device * device,int from)964 tape_34xx_delete_sbid_from(struct tape_device *device, int from)
965 {
966 	struct list_head *	sbid_list;
967 	struct tape_34xx_sbid *	sbid;
968 	struct list_head *	l;
969 	struct list_head *	n;
970 
971 	sbid_list = (struct list_head *) device->discdata;
972 	if (!sbid_list)
973 		return;
974 
975 	list_for_each_safe(l, n, sbid_list) {
976 		sbid = list_entry(l, struct tape_34xx_sbid, list);
977 		if (sbid->bid.block >= from) {
978 			DBF_LH(4, "Delete sbid %d:%03d@%05d\n",
979 				sbid->bid.wrap,
980 				sbid->bid.segment,
981 				sbid->bid.block
982 			);
983 			list_del(l);
984 			kfree(sbid);
985 		}
986 	}
987 }
988 
989 /*
990  * Merge hardware position data into a block id.
991  */
992 static void
tape_34xx_merge_sbid(struct tape_device * device,struct tape_34xx_block_id * bid)993 tape_34xx_merge_sbid(
994 	struct tape_device *		device,
995 	struct tape_34xx_block_id *	bid
996 ) {
997 	struct tape_34xx_sbid *	sbid;
998 	struct tape_34xx_sbid *	sbid_to_use;
999 	struct list_head *	sbid_list;
1000 	struct list_head *	l;
1001 
1002 	sbid_list = (struct list_head *) device->discdata;
1003 	bid->wrap    = 0;
1004 	bid->segment = 1;
1005 
1006 	if (!sbid_list || list_empty(sbid_list))
1007 		return;
1008 
1009 	sbid_to_use = NULL;
1010 	list_for_each(l, sbid_list) {
1011 		sbid = list_entry(l, struct tape_34xx_sbid, list);
1012 
1013 		if (sbid->bid.block >= bid->block)
1014 			break;
1015 		sbid_to_use = sbid;
1016 	}
1017 	if (sbid_to_use) {
1018 		bid->wrap    = sbid_to_use->bid.wrap;
1019 		bid->segment = sbid_to_use->bid.segment;
1020 		DBF_LH(4, "Use %d:%03d@%05d for %05d\n",
1021 			sbid_to_use->bid.wrap,
1022 			sbid_to_use->bid.segment,
1023 			sbid_to_use->bid.block,
1024 			bid->block
1025 		);
1026 	}
1027 }
1028 
1029 static int
tape_34xx_setup_device(struct tape_device * device)1030 tape_34xx_setup_device(struct tape_device * device)
1031 {
1032 	int			rc;
1033 	struct list_head *	discdata;
1034 
1035 	DBF_EVENT(6, "34xx device setup\n");
1036 	if ((rc = tape_std_assign(device)) == 0) {
1037 		if ((rc = tape_34xx_medium_sense(device)) != 0) {
1038 			DBF_LH(3, "34xx medium sense returned %d\n", rc);
1039 		}
1040 	}
1041 	discdata = kmalloc(sizeof(struct list_head), GFP_KERNEL);
1042 	if (discdata) {
1043 			INIT_LIST_HEAD(discdata);
1044 			device->discdata = discdata;
1045 	}
1046 
1047 	return rc;
1048 }
1049 
1050 static void
tape_34xx_cleanup_device(struct tape_device * device)1051 tape_34xx_cleanup_device(struct tape_device *device)
1052 {
1053 	tape_std_unassign(device);
1054 
1055 	if (device->discdata) {
1056 		tape_34xx_delete_sbid_from(device, 0);
1057 		kfree(device->discdata);
1058 		device->discdata = NULL;
1059 	}
1060 }
1061 
1062 
1063 /*
1064  * MTTELL: Tell block. Return the number of block relative to current file.
1065  */
1066 static int
tape_34xx_mttell(struct tape_device * device,int mt_count)1067 tape_34xx_mttell(struct tape_device *device, int mt_count)
1068 {
1069 	struct {
1070 		struct tape_34xx_block_id	cbid;
1071 		struct tape_34xx_block_id	dbid;
1072 	} __attribute__ ((packed)) block_id;
1073 	int rc;
1074 
1075 	rc = tape_std_read_block_id(device, (__u64 *) &block_id);
1076 	if (rc)
1077 		return rc;
1078 
1079 	tape_34xx_add_sbid(device, block_id.cbid);
1080 	return block_id.cbid.block;
1081 }
1082 
1083 /*
1084  * MTSEEK: seek to the specified block.
1085  */
1086 static int
tape_34xx_mtseek(struct tape_device * device,int mt_count)1087 tape_34xx_mtseek(struct tape_device *device, int mt_count)
1088 {
1089 	struct tape_request *request;
1090 	struct tape_34xx_block_id *	bid;
1091 
1092 	if (mt_count > 0x3fffff) {
1093 		DBF_EXCEPTION(6, "xsee parm\n");
1094 		return -EINVAL;
1095 	}
1096 	request = tape_alloc_request(3, 4);
1097 	if (IS_ERR(request))
1098 		return PTR_ERR(request);
1099 
1100 	/* setup ccws */
1101 	request->op = TO_LBL;
1102 	bid         = (struct tape_34xx_block_id *) request->cpdata;
1103 	bid->format = (*device->modeset_byte & 0x08) ?
1104 			TAPE34XX_FMT_3480_XF : TAPE34XX_FMT_3480;
1105 	bid->block  = mt_count;
1106 	tape_34xx_merge_sbid(device, bid);
1107 
1108 	tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
1109 	tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
1110 	tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
1111 
1112 	/* execute it */
1113 	return tape_do_io_free(device, request);
1114 }
1115 
1116 /*
1117  * List of 3480/3490 magnetic tape commands.
1118  */
1119 static tape_mtop_fn tape_34xx_mtop[TAPE_NR_MTOPS] = {
1120 	[MTRESET]	 = tape_std_mtreset,
1121 	[MTFSF]		 = tape_std_mtfsf,
1122 	[MTBSF]		 = tape_std_mtbsf,
1123 	[MTFSR]		 = tape_std_mtfsr,
1124 	[MTBSR]		 = tape_std_mtbsr,
1125 	[MTWEOF]	 = tape_std_mtweof,
1126 	[MTREW]		 = tape_std_mtrew,
1127 	[MTOFFL]	 = tape_std_mtoffl,
1128 	[MTNOP]		 = tape_std_mtnop,
1129 	[MTRETEN]	 = tape_std_mtreten,
1130 	[MTBSFM]	 = tape_std_mtbsfm,
1131 	[MTFSFM]	 = tape_std_mtfsfm,
1132 	[MTEOM]		 = tape_std_mteom,
1133 	[MTERASE]	 = tape_std_mterase,
1134 	[MTRAS1]	 = NULL,
1135 	[MTRAS2]	 = NULL,
1136 	[MTRAS3]	 = NULL,
1137 	[MTSETBLK]	 = tape_std_mtsetblk,
1138 	[MTSETDENSITY]	 = NULL,
1139 	[MTSEEK]	 = tape_34xx_mtseek,
1140 	[MTTELL]	 = tape_34xx_mttell,
1141 	[MTSETDRVBUFFER] = NULL,
1142 	[MTFSS]		 = NULL,
1143 	[MTBSS]		 = NULL,
1144 	[MTWSM]		 = NULL,
1145 	[MTLOCK]	 = NULL,
1146 	[MTUNLOCK]	 = NULL,
1147 	[MTLOAD]	 = tape_std_mtload,
1148 	[MTUNLOAD]	 = tape_std_mtunload,
1149 	[MTCOMPRESSION]	 = tape_std_mtcompression,
1150 	[MTSETPART]	 = NULL,
1151 	[MTMKPART]	 = NULL
1152 };
1153 
1154 /*
1155  * Tape discipline structure for 3480 and 3490.
1156  */
1157 static struct tape_discipline tape_discipline_34xx = {
1158 	.owner = THIS_MODULE,
1159 	.setup_device = tape_34xx_setup_device,
1160 	.cleanup_device = tape_34xx_cleanup_device,
1161 	.process_eov = tape_std_process_eov,
1162 	.irq = tape_34xx_irq,
1163 	.read_block = tape_std_read_block,
1164 	.write_block = tape_std_write_block,
1165 	.ioctl_fn = tape_34xx_ioctl,
1166 	.mtop_array = tape_34xx_mtop
1167 };
1168 
1169 static struct ccw_device_id tape_34xx_ids[] = {
1170 	{ CCW_DEVICE_DEVTYPE(0x3480, 0, 0x3480, 0), .driver_info = tape_3480},
1171 	{ CCW_DEVICE_DEVTYPE(0x3490, 0, 0x3490, 0), .driver_info = tape_3490},
1172 	{ /* end of list */ },
1173 };
1174 
1175 static int
tape_34xx_online(struct ccw_device * cdev)1176 tape_34xx_online(struct ccw_device *cdev)
1177 {
1178 	return tape_generic_online(
1179 		dev_get_drvdata(&cdev->dev),
1180 		&tape_discipline_34xx
1181 	);
1182 }
1183 
1184 static struct ccw_driver tape_34xx_driver = {
1185 	.driver = {
1186 		.name = "tape_34xx",
1187 		.owner = THIS_MODULE,
1188 	},
1189 	.ids = tape_34xx_ids,
1190 	.probe = tape_generic_probe,
1191 	.remove = tape_generic_remove,
1192 	.set_online = tape_34xx_online,
1193 	.set_offline = tape_generic_offline,
1194 	.int_class = IRQIO_TAP,
1195 };
1196 
1197 static int
tape_34xx_init(void)1198 tape_34xx_init (void)
1199 {
1200 	int rc;
1201 
1202 	TAPE_DBF_AREA = debug_register ( "tape_34xx", 2, 2, 4*sizeof(long));
1203 	debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
1204 #ifdef DBF_LIKE_HELL
1205 	debug_set_level(TAPE_DBF_AREA, 6);
1206 #endif
1207 
1208 	DBF_EVENT(3, "34xx init\n");
1209 	/* Register driver for 3480/3490 tapes. */
1210 	rc = ccw_driver_register(&tape_34xx_driver);
1211 	if (rc)
1212 		DBF_EVENT(3, "34xx init failed\n");
1213 	else
1214 		DBF_EVENT(3, "34xx registered\n");
1215 	return rc;
1216 }
1217 
1218 static void
tape_34xx_exit(void)1219 tape_34xx_exit(void)
1220 {
1221 	ccw_driver_unregister(&tape_34xx_driver);
1222 
1223 	debug_unregister(TAPE_DBF_AREA);
1224 }
1225 
1226 MODULE_DEVICE_TABLE(ccw, tape_34xx_ids);
1227 MODULE_AUTHOR("(C) 2001-2002 IBM Deutschland Entwicklung GmbH");
1228 MODULE_DESCRIPTION("Linux on zSeries channel attached 3480 tape device driver");
1229 MODULE_LICENSE("GPL");
1230 
1231 module_init(tape_34xx_init);
1232 module_exit(tape_34xx_exit);
1233