]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * drivers/s390/char/tape_34xx.c | |
3 | * tape device discipline for 3480/3490 tapes. | |
4 | * | |
3ef32e62 | 5 | * Copyright IBM Corp. 2001, 2009 |
1da177e4 LT |
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 | ||
59e36927 | 11 | #define KMSG_COMPONENT "tape_34xx" |
bb509912 | 12 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt |
ab640db0 | 13 | |
1da177e4 LT |
14 | #include <linux/module.h> |
15 | #include <linux/init.h> | |
16 | #include <linux/bio.h> | |
17 | #include <linux/workqueue.h> | |
5a0e3ad6 | 18 | #include <linux/slab.h> |
1da177e4 LT |
19 | |
20 | #define TAPE_DBF_AREA tape_34xx_dbf | |
21 | ||
22 | #include "tape.h" | |
23 | #include "tape_std.h" | |
24 | ||
1da177e4 LT |
25 | /* |
26 | * Pointer to debug area. | |
27 | */ | |
28 | debug_info_t *TAPE_DBF_AREA = NULL; | |
29 | EXPORT_SYMBOL(TAPE_DBF_AREA); | |
30 | ||
1da177e4 LT |
31 | #define TAPE34XX_FMT_3480 0 |
32 | #define TAPE34XX_FMT_3480_2_XF 1 | |
33 | #define TAPE34XX_FMT_3480_XF 2 | |
34 | ||
35 | struct tape_34xx_block_id { | |
36 | unsigned int wrap : 1; | |
37 | unsigned int segment : 7; | |
38 | unsigned int format : 2; | |
39 | unsigned int block : 22; | |
40 | }; | |
41 | ||
42 | /* | |
43 | * A list of block ID's is used to faster seek blocks. | |
44 | */ | |
45 | struct tape_34xx_sbid { | |
46 | struct list_head list; | |
47 | struct tape_34xx_block_id bid; | |
48 | }; | |
49 | ||
50 | static void tape_34xx_delete_sbid_from(struct tape_device *, int); | |
51 | ||
52 | /* | |
53 | * Medium sense for 34xx tapes. There is no 'real' medium sense call. | |
54 | * So we just do a normal sense. | |
55 | */ | |
56 | static int | |
57 | tape_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 | ||
c1637532 MS |
100 | struct tape_34xx_work { |
101 | struct tape_device *device; | |
102 | enum tape_op op; | |
103 | struct work_struct work; | |
104 | }; | |
105 | ||
1da177e4 LT |
106 | /* |
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 | */ | |
113 | static void | |
c1637532 | 114 | tape_34xx_work_handler(struct work_struct *work) |
1da177e4 | 115 | { |
c1637532 MS |
116 | struct tape_34xx_work *p = |
117 | container_of(work, struct tape_34xx_work, work); | |
8fd138c3 | 118 | struct tape_device *device = p->device; |
1da177e4 LT |
119 | |
120 | switch(p->op) { | |
121 | case TO_MSEN: | |
8fd138c3 | 122 | tape_34xx_medium_sense(device); |
1da177e4 LT |
123 | break; |
124 | default: | |
125 | DBF_EVENT(3, "T34XX: internal error: unknown work\n"); | |
126 | } | |
8fd138c3 | 127 | tape_put_device(device); |
1da177e4 LT |
128 | kfree(p); |
129 | } | |
130 | ||
131 | static int | |
132 | tape_34xx_schedule_work(struct tape_device *device, enum tape_op op) | |
133 | { | |
c1637532 | 134 | struct tape_34xx_work *p; |
1da177e4 | 135 | |
dd00cc48 | 136 | if ((p = kzalloc(sizeof(*p), GFP_ATOMIC)) == NULL) |
1da177e4 LT |
137 | return -ENOMEM; |
138 | ||
c1637532 | 139 | INIT_WORK(&p->work, tape_34xx_work_handler); |
1da177e4 | 140 | |
8fd138c3 | 141 | p->device = tape_get_device(device); |
1da177e4 LT |
142 | 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 | */ | |
151 | static inline int | |
152 | tape_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 | ||
171 | static inline int | |
172 | tape_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 | ||
179 | static inline int | |
180 | tape_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 | ||
187 | static inline int | |
188 | tape_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 | */ | |
198 | static int | |
199 | tape_34xx_unsolicited_irq(struct tape_device *device, struct irb *irb) | |
200 | { | |
23d805b6 | 201 | if (irb->scsw.cmd.dstat == 0x85) { /* READY */ |
1da177e4 LT |
202 | /* 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); | |
ab640db0 | 208 | tape_dump_sense_dbf(device, NULL, irb); |
1da177e4 LT |
209 | } |
210 | return TAPE_IO_SUCCESS; | |
211 | } | |
212 | ||
213 | /* | |
214 | * Read Opposite Error Recovery Function: | |
215 | * Used, when Read Forward does not work | |
216 | */ | |
217 | static int | |
218 | tape_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 | } | |
ab640db0 | 230 | |
1da177e4 LT |
231 | /* |
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 | ||
238 | static int | |
239 | tape_34xx_erp_bug(struct tape_device *device, struct tape_request *request, | |
240 | struct irb *irb, int no) | |
241 | { | |
242 | if (request->op != TO_ASSIGN) { | |
ab640db0 CO |
243 | 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); | |
1da177e4 LT |
246 | } |
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 | */ | |
254 | static int | |
255 | tape_34xx_erp_overrun(struct tape_device *device, struct tape_request *request, | |
256 | struct irb *irb) | |
257 | { | |
258 | if (irb->ecw[3] == 0x40) { | |
ab640db0 CO |
259 | dev_warn (&device->cdev->dev, "A data overrun occurred between" |
260 | " the control unit and tape unit\n"); | |
1da177e4 LT |
261 | 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 | */ | |
269 | static int | |
270 | tape_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 | */ | |
ab640db0 CO |
277 | dev_warn (&device->cdev->dev, "The block ID sequence on the " |
278 | "tape is incorrect\n"); | |
1da177e4 LT |
279 | 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 | */ | |
293 | static int | |
294 | tape_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: | |
1da177e4 LT |
391 | 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 */ | |
ab640db0 CO |
416 | dev_warn (&device->cdev->dev, "A read error occurred " |
417 | "that cannot be recovered\n"); | |
1da177e4 LT |
418 | 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 | |
ab640db0 CO |
430 | dev_warn (&device->cdev->dev, "A write error on the " |
431 | "tape cannot be recovered\n"); | |
1da177e4 LT |
432 | 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 */ | |
ab640db0 CO |
438 | dev_warn (&device->cdev->dev, "Writing the ID-mark " |
439 | "failed\n"); | |
1da177e4 LT |
440 | return tape_34xx_erp_failed(request, -EIO); |
441 | case 0x31: | |
442 | /* Tape void. Tried to read beyond end of device. */ | |
ab640db0 CO |
443 | dev_warn (&device->cdev->dev, "Reading the tape beyond" |
444 | " the end of the recorded area failed\n"); | |
1da177e4 LT |
445 | return tape_34xx_erp_failed(request, -ENOSPC); |
446 | case 0x41: | |
447 | /* Record sequence error. */ | |
ab640db0 CO |
448 | dev_warn (&device->cdev->dev, "The tape contains an " |
449 | "incorrect block ID sequence\n"); | |
1da177e4 LT |
450 | 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. */ | |
1da177e4 LT |
471 | return TAPE_IO_SUCCESS; |
472 | case 0x21: | |
473 | /* | |
474 | * Data streaming not operational. CU will switch to | |
475 | * interlock mode. Reissue the command. | |
476 | */ | |
1da177e4 LT |
477 | 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 | */ | |
ab640db0 CO |
484 | dev_warn (&device->cdev->dev, "A path equipment check occurred" |
485 | " for the tape device\n"); | |
1da177e4 LT |
486 | 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 | */ | |
1da177e4 LT |
508 | 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 | */ | |
ab640db0 CO |
545 | dev_warn (&device->cdev->dev, "The tape unit cannot process " |
546 | "the tape format\n"); | |
1da177e4 LT |
547 | return tape_34xx_erp_failed(request, -EMEDIUMTYPE); |
548 | case 0x30: | |
549 | /* The medium is write protected. */ | |
ab640db0 CO |
550 | dev_warn (&device->cdev->dev, "The tape medium is write-" |
551 | "protected\n"); | |
1da177e4 LT |
552 | return tape_34xx_erp_failed(request, -EACCES); |
553 | case 0x32: | |
554 | // Tension loss. We cannot recover this, it's an I/O error. | |
ab640db0 CO |
555 | dev_warn (&device->cdev->dev, "The tape does not have the " |
556 | "required tape tension\n"); | |
1da177e4 LT |
557 | 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 | */ | |
ab640db0 CO |
563 | dev_warn (&device->cdev->dev, "The tape unit failed to load" |
564 | " the cartridge\n"); | |
1da177e4 LT |
565 | 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 | */ | |
ab640db0 CO |
572 | dev_warn (&device->cdev->dev, "Automatic unloading of the tape" |
573 | " cartridge failed\n"); | |
1da177e4 LT |
574 | 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 | */ | |
ab640db0 CO |
585 | dev_warn (&device->cdev->dev, "An equipment check has occurred" |
586 | " on the tape unit\n"); | |
1da177e4 LT |
587 | 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 | */ | |
ab640db0 CO |
599 | dev_warn (&device->cdev->dev, "The tape information states an" |
600 | " incorrect length\n"); | |
1da177e4 LT |
601 | 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. */ | |
ab640db0 | 617 | dev_warn (&device->cdev->dev, "The tape unit is not ready\n"); |
1da177e4 LT |
618 | return tape_34xx_erp_failed(request, -EIO); |
619 | case 0x3b: | |
620 | /* Manual rewind or unload. This causes an I/O error. */ | |
ab640db0 CO |
621 | dev_warn (&device->cdev->dev, "The tape medium has been " |
622 | "rewound or unloaded manually\n"); | |
1da177e4 LT |
623 | 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 | */ | |
ab640db0 CO |
630 | dev_warn (&device->cdev->dev, "The tape subsystem is running " |
631 | "in degraded mode\n"); | |
1da177e4 LT |
632 | 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 | } | |
1da177e4 LT |
650 | 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. */ | |
ab640db0 CO |
660 | dev_warn (&device->cdev->dev, "The tape unit is already " |
661 | "assigned\n"); | |
1da177e4 LT |
662 | 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 | */ | |
ab640db0 | 669 | dev_warn (&device->cdev->dev, "The tape unit is not online\n"); |
1da177e4 LT |
670 | return tape_34xx_erp_failed(request, -EIO); |
671 | case 0x47: | |
672 | /* Volume fenced. CU reports volume integrity is lost. */ | |
ab640db0 CO |
673 | dev_warn (&device->cdev->dev, "The control unit has fenced " |
674 | "access to the tape volume\n"); | |
1da177e4 LT |
675 | 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. */ | |
ab640db0 CO |
682 | dev_warn (&device->cdev->dev, "A parity error occurred on the " |
683 | "tape bus\n"); | |
1da177e4 LT |
684 | return tape_34xx_erp_failed(request, -EIO); |
685 | case 0x4a: | |
686 | /* Control unit erp failed. */ | |
ab640db0 CO |
687 | dev_warn (&device->cdev->dev, "I/O error recovery failed on " |
688 | "the tape control unit\n"); | |
1da177e4 LT |
689 | 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 | */ | |
ab640db0 CO |
695 | dev_warn (&device->cdev->dev, "The tape unit requires a " |
696 | "firmware update\n"); | |
1da177e4 LT |
697 | 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 | */ | |
ab640db0 CO |
721 | dev_warn (&device->cdev->dev, "The maximum block size" |
722 | " for buffered mode is exceeded\n"); | |
1da177e4 LT |
723 | 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). */ | |
ab640db0 CO |
759 | dev_warn (&device->cdev->dev, "A channel interface error cannot be" |
760 | " recovered\n"); | |
1da177e4 LT |
761 | return tape_34xx_erp_failed(request, -EIO); |
762 | case 0x56: | |
763 | /* Channel protocol error. */ | |
ab640db0 CO |
764 | dev_warn (&device->cdev->dev, "A channel protocol error " |
765 | "occurred\n"); | |
1da177e4 LT |
766 | return tape_34xx_erp_failed(request, -EIO); |
767 | case 0x57: | |
768 | if (device->cdev->id.driver_info == tape_3480) { | |
769 | /* Attention intercept. */ | |
1da177e4 LT |
770 | return tape_34xx_erp_retry(request); |
771 | } else { | |
772 | /* Global status intercept. */ | |
1da177e4 LT |
773 | 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 | */ | |
ab640db0 CO |
780 | dev_warn (&device->cdev->dev, "The tape unit does not support " |
781 | "the tape length\n"); | |
1da177e4 LT |
782 | 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); | |
ab640db0 CO |
788 | dev_warn (&device->cdev->dev, "The tape unit does not support" |
789 | " format 3480 XF\n"); | |
1da177e4 LT |
790 | return tape_34xx_erp_failed(request, -EIO); |
791 | case 0x5c: | |
792 | /* Format 3480-2 XF incompatible */ | |
ab640db0 CO |
793 | dev_warn (&device->cdev->dev, "The tape unit does not support tape " |
794 | "format 3480-2 XF\n"); | |
1da177e4 LT |
795 | return tape_34xx_erp_failed(request, -EIO); |
796 | case 0x5d: | |
797 | /* Tape length violation. */ | |
ab640db0 CO |
798 | dev_warn (&device->cdev->dev, "The tape unit does not support" |
799 | " the current tape length\n"); | |
1da177e4 LT |
800 | return tape_34xx_erp_failed(request, -EMEDIUMTYPE); |
801 | case 0x5e: | |
802 | /* Compaction algorithm incompatible. */ | |
ab640db0 CO |
803 | dev_warn (&device->cdev->dev, "The tape unit does not support" |
804 | " the compaction algorithm\n"); | |
1da177e4 LT |
805 | 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 | */ | |
824 | static int | |
825 | tape_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 | ||
23d805b6 PO |
831 | if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) && |
832 | (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) && | |
1da177e4 LT |
833 | (request->op == TO_WRI)) { |
834 | /* Write at end of volume */ | |
1da177e4 LT |
835 | return tape_34xx_erp_failed(request, -ENOSPC); |
836 | } | |
837 | ||
23d805b6 | 838 | if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) |
1da177e4 LT |
839 | return tape_34xx_unit_check(device, request, irb); |
840 | ||
23d805b6 | 841 | if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) { |
1da177e4 LT |
842 | /* |
843 | * A unit exception occurs on skipping over a tapemark block. | |
844 | */ | |
23d805b6 | 845 | if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) { |
1da177e4 LT |
846 | 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"); | |
ab640db0 | 855 | tape_dump_sense_dbf(device, request, irb); |
1da177e4 LT |
856 | return TAPE_IO_STOP; |
857 | } | |
858 | ||
859 | /* | |
860 | * ioctl_overload | |
861 | */ | |
862 | static int | |
863 | tape_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 | ||
876 | static inline void | |
877 | tape_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 | */ | |
894 | static void | |
895 | tape_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 | */ | |
956 | static void | |
957 | tape_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 | */ | |
985 | static void | |
986 | tape_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 | ||
1022 | static int | |
1023 | tape_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 | ||
1043 | static void | |
1044 | tape_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 | */ | |
1059 | static int | |
1060 | tape_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 | */ | |
1079 | static int | |
1080 | tape_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 | */ | |
1113 | static struct tape_request * | |
1114 | tape_34xx_bread(struct tape_device *device, struct request *req) | |
1115 | { | |
1116 | struct tape_request *request; | |
1117 | struct ccw1 *ccw; | |
5705f702 | 1118 | int count = 0; |
1da177e4 LT |
1119 | unsigned off; |
1120 | char *dst; | |
1121 | struct bio_vec *bv; | |
5705f702 | 1122 | struct req_iterator iter; |
1da177e4 LT |
1123 | struct tape_34xx_block_id * start_block; |
1124 | ||
1125 | DBF_EVENT(6, "xBREDid:"); | |
1126 | ||
1127 | /* Count the number of blocks for the request. */ | |
5705f702 N |
1128 | rq_for_each_segment(bv, req, iter) |
1129 | count += bv->bv_len >> (TAPEBLOCK_HSEC_S2B + 9); | |
1da177e4 LT |
1130 | |
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; | |
83096ebf | 1139 | start_block->block = blk_rq_pos(req) >> TAPEBLOCK_HSEC_S2B; |
1da177e4 LT |
1140 | 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 | ||
5705f702 | 1156 | rq_for_each_segment(bv, req, iter) { |
6c92e699 JA |
1157 | 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 | } | |
1da177e4 LT |
1166 | } |
1167 | ||
1168 | ccw = tape_ccw_end(ccw, NOP, 0, NULL); | |
1169 | DBF_EVENT(6, "xBREDccwg\n"); | |
1170 | return request; | |
1171 | } | |
1172 | ||
1173 | static void | |
1174 | tape_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 | */ | |
1204 | static void | |
1205 | tape_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 | */ | |
1229 | static 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 | */ | |
1267 | static 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 | ||
1284 | static struct ccw_device_id tape_34xx_ids[] = { | |
d2c993d8 HC |
1285 | { 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 */ }, | |
1da177e4 LT |
1288 | }; |
1289 | ||
1290 | static int | |
1291 | tape_34xx_online(struct ccw_device *cdev) | |
1292 | { | |
1293 | return tape_generic_online( | |
dff59b64 | 1294 | dev_get_drvdata(&cdev->dev), |
1da177e4 LT |
1295 | &tape_discipline_34xx |
1296 | ); | |
1297 | } | |
1298 | ||
1da177e4 LT |
1299 | static 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, | |
4d7a3cdf | 1306 | .set_offline = tape_generic_offline, |
3ef32e62 | 1307 | .freeze = tape_generic_pm_suspend, |
1da177e4 LT |
1308 | }; |
1309 | ||
1310 | static int | |
1311 | tape_34xx_init (void) | |
1312 | { | |
1313 | int rc; | |
1314 | ||
66a464db | 1315 | TAPE_DBF_AREA = debug_register ( "tape_34xx", 2, 2, 4*sizeof(long)); |
1da177e4 LT |
1316 | 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 | ||
e018ba1f | 1321 | DBF_EVENT(3, "34xx init\n"); |
1da177e4 LT |
1322 | /* 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 | ||
1331 | static void | |
1332 | tape_34xx_exit(void) | |
1333 | { | |
1334 | ccw_driver_unregister(&tape_34xx_driver); | |
1335 | ||
1336 | debug_unregister(TAPE_DBF_AREA); | |
1337 | } | |
1338 | ||
1339 | MODULE_DEVICE_TABLE(ccw, tape_34xx_ids); | |
1340 | MODULE_AUTHOR("(C) 2001-2002 IBM Deutschland Entwicklung GmbH"); | |
e018ba1f | 1341 | MODULE_DESCRIPTION("Linux on zSeries channel attached 3480 tape device driver"); |
1da177e4 LT |
1342 | MODULE_LICENSE("GPL"); |
1343 | ||
1344 | module_init(tape_34xx_init); | |
1345 | module_exit(tape_34xx_exit); |