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 */
28debug_info_t *TAPE_DBF_AREA = NULL;
29EXPORT_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
35struct 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 */
45struct tape_34xx_sbid {
46 struct list_head list;
47 struct tape_34xx_block_id bid;
48};
49
50static 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 */
56static 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
85static int tape_34xx_medium_sense(struct tape_device *device)
86{
87 struct tape_request *request;
88 int rc;
89
90 request = tape_alloc_request(cplength: 1, datasize: 32);
91 if (IS_ERR(ptr: request)) {
92 DBF_EXCEPTION(6, "MSEN fail\n");
93 return PTR_ERR(ptr: request);
94 }
95
96 request->op = TO_MSEN;
97 tape_ccw_end(ccw: request->cpaddr, SENSE, memsize: 32, cda: request->cpdata);
98 rc = tape_do_io_interruptible(device, request);
99 __tape_34xx_medium_sense(request);
100 return rc;
101}
102
103static void tape_34xx_medium_sense_async(struct tape_device *device)
104{
105 struct tape_request *request;
106
107 request = tape_alloc_request(cplength: 1, datasize: 32);
108 if (IS_ERR(ptr: request)) {
109 DBF_EXCEPTION(6, "MSEN fail\n");
110 return;
111 }
112
113 request->op = TO_MSEN;
114 tape_ccw_end(ccw: request->cpaddr, SENSE, memsize: 32, cda: request->cpdata);
115 request->callback = (void *) __tape_34xx_medium_sense;
116 request->callback_data = NULL;
117 tape_do_io_async(device, request);
118}
119
120struct 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 */
136static void
137tape_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(objp: p);
152}
153
154static int
155tape_34xx_schedule_work(struct tape_device *device, enum tape_op op)
156{
157 struct tape_34xx_work *p;
158
159 if ((p = kzalloc(size: 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(work: &p->work);
168 return 0;
169}
170
171/*
172 * Done Handler is called when dev stat = DEVICE-END (successful operation)
173 */
174static inline int
175tape_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
194static inline int
195tape_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
202static inline int
203tape_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
210static inline int
211tape_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 */
221static int
222tape_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, op: 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 */
240static int
241tape_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, rc: -EIO);
259}
260
261static int
262tape_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, rc: -EIO);
271}
272
273/*
274 * Handle data overrun between cu and drive. The channel speed might
275 * be too slow.
276 */
277static int
278tape_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, rc: -EIO);
285 }
286 return tape_34xx_erp_bug(device, request, irb, no: -1);
287}
288
289/*
290 * Handle record sequence error.
291 */
292static int
293tape_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, rc: -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, no: -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 */
316static int
317tape_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, rc: -EACCES);
337 } else {
338 return tape_34xx_erp_bug(device, request, irb, no: -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, rc: -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, rc: -EIO);
386
387 case TO_RFO:
388 /* Read beyond end of recorded area -> 0 bytes read */
389 return tape_34xx_erp_failed(request, rc: 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, rc: -ENOSPC);
399 default:
400 return tape_34xx_erp_failed(request, rc: 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, no: -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, rc: -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, no: -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, rc: -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, rc: -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, rc: -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, rc: -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, no: -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, rc: -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, rc: -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, no: 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, rc: -EIO);
542 case 0x2d:
543 /* Data security erase failure. */
544 if (request->op == TO_DSE)
545 return tape_34xx_erp_failed(request, rc: -EIO);
546 /* Data security erase failure, but no such command issued. */
547 return tape_34xx_erp_bug(device, request, irb, no: 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, rc: -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, rc: -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, rc: -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, rc: -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, rc: -EIO);
585 return tape_34xx_erp_bug(device, request, irb, no: 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, rc: -EIO);
597 case 0x36:
598 if (device->cdev->id.driver_info == tape_3490)
599 /* End of data. */
600 return tape_34xx_erp_failed(request, rc: -EIO);
601 /* This erpa is reserved for 3480 */
602 return tape_34xx_erp_bug(device, request, irb, no: 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, rc: -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, rc: -ENOSPC);
620 return tape_34xx_erp_failed(request, rc: -EIO);
621 case 0x39:
622 /* Backward at Beginning of tape. */
623 return tape_34xx_erp_failed(request, rc: -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, rc: -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, rc: -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, rc: -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, no: sense[3]);
666 return tape_34xx_erp_failed(request, rc: -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, rc: -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, rc: -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, rc: -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, rc: -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, rc: -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, rc: -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, no: 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, rc: -ENOBUFS);
733 }
734 /* This erpa is reserved for 3480. */
735 return tape_34xx_erp_bug(device, request, irb, no: 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, no: 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, rc: -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, rc: -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, rc: -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, rc: -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, rc: -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, rc: -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, rc: -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, no: sense[3]);
825 }
826}
827
828/*
829 * 3480/3490 interrupt handler
830 */
831static int
832tape_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, rc: -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 */
869static int
870tape_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(to: &disp, from: (char __user *) arg, n: sizeof(disp)) != 0)
876 return -EFAULT;
877
878 return tape_std_display(device, disp: &disp);
879 } else
880 return -EINVAL;
881}
882
883static inline void
884tape_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(size: sizeof(*new_sbid), GFP_ATOMIC);
889 if (!new_sbid)
890 return;
891
892 new_sbid->bid = bid;
893 list_add(new: &new_sbid->list, head: 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 */
901static void
902tape_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: 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: 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 */
963static void
964tape_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(entry: l);
984 kfree(objp: sbid);
985 }
986 }
987}
988
989/*
990 * Merge hardware position data into a block id.
991 */
992static void
993tape_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(head: 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
1029static int
1030tape_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(size: sizeof(struct list_head), GFP_KERNEL);
1042 if (discdata) {
1043 INIT_LIST_HEAD(list: discdata);
1044 device->discdata = discdata;
1045 }
1046
1047 return rc;
1048}
1049
1050static void
1051tape_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, from: 0);
1057 kfree(objp: 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 */
1066static int
1067tape_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, id: (__u64 *) &block_id);
1076 if (rc)
1077 return rc;
1078
1079 tape_34xx_add_sbid(device, bid: block_id.cbid);
1080 return block_id.cbid.block;
1081}
1082
1083/*
1084 * MTSEEK: seek to the specified block.
1085 */
1086static int
1087tape_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(cplength: 3, datasize: 4);
1097 if (IS_ERR(ptr: request))
1098 return PTR_ERR(ptr: 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(ccw: request->cpaddr, MODE_SET_DB, memsize: 1, cda: device->modeset_byte);
1109 tape_ccw_cc(ccw: request->cpaddr + 1, LOCATE, memsize: 4, cda: request->cpdata);
1110 tape_ccw_end(ccw: request->cpaddr + 2, NOP, memsize: 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 */
1119static 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 */
1157static 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
1169static 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
1175static int
1176tape_34xx_online(struct ccw_device *cdev)
1177{
1178 return tape_generic_online(
1179 dev_get_drvdata(dev: &cdev->dev),
1180 &tape_discipline_34xx
1181 );
1182}
1183
1184static 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
1197static int
1198tape_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
1218static void
1219tape_34xx_exit(void)
1220{
1221 ccw_driver_unregister(&tape_34xx_driver);
1222
1223 debug_unregister(TAPE_DBF_AREA);
1224}
1225
1226MODULE_DEVICE_TABLE(ccw, tape_34xx_ids);
1227MODULE_AUTHOR("(C) 2001-2002 IBM Deutschland Entwicklung GmbH");
1228MODULE_DESCRIPTION("Linux on zSeries channel attached 3480 tape device driver");
1229MODULE_LICENSE("GPL");
1230
1231module_init(tape_34xx_init);
1232module_exit(tape_34xx_exit);
1233

source code of linux/drivers/s390/char/tape_34xx.c