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