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