projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master' of /pub/scm/linux/kernel/git/torvalds/linux-2.6
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / s390 / char / tape_3590.c
CommitLineData
b6cba4ee
SB		 1/*
2 * drivers/s390/char/tape_3590.c
3 * tape device discipline for 3590 tapes.
4 *
cced1dd4 5 * Copyright IBM Corp. 2001,2006
b6cba4ee
SB		 6 * Author(s): Stefan Bader <shbader@de.ibm.com>
7 * Michael Holzheu <holzheu@de.ibm.com>
8 * Martin Schwidefsky <schwidefsky@de.ibm.com>
9 */
10
b6cba4ee
SB		 11#include <linux/module.h>
12#include <linux/init.h>
13#include <linux/bio.h>
cced1dd4 14#include <asm/ebcdic.h>
b6cba4ee
SB		 15
16#define TAPE_DBF_AREA tape_3590_dbf
17
18#include "tape.h"
19#include "tape_std.h"
20#include "tape_3590.h"
21
22/*
23 * Pointer to debug area.
24 */
25debug_info_t *TAPE_DBF_AREA = NULL;
26EXPORT_SYMBOL(TAPE_DBF_AREA);
27
28/*******************************************************************
29 * Error Recovery fuctions:
30 * - Read Opposite: implemented
31 * - Read Device (buffered) log: BRA
32 * - Read Library log: BRA
33 * - Swap Devices: BRA
cced1dd4 34 * - Long Busy: implemented
b6cba4ee
SB		 35 * - Special Intercept: BRA
36 * - Read Alternate: implemented
37 *******************************************************************/
38
39#define PRINTK_HEADER "TAPE_3590: "
40
41static const char *tape_3590_msg[TAPE_3590_MAX_MSG] = {
42 [0x00] = "",
43 [0x10] = "Lost Sense",
44 [0x11] = "Assigned Elsewhere",
45 [0x12] = "Allegiance Reset",
46 [0x13] = "Shared Access Violation",
47 [0x20] = "Command Reject",
48 [0x21] = "Configuration Error",
49 [0x22] = "Protection Exception",
50 [0x23] = "Write Protect",
51 [0x24] = "Write Length",
52 [0x25] = "Read-Only Format",
53 [0x31] = "Beginning of Partition",
54 [0x33] = "End of Partition",
55 [0x34] = "End of Data",
56 [0x35] = "Block not found",
57 [0x40] = "Device Intervention",
58 [0x41] = "Loader Intervention",
59 [0x42] = "Library Intervention",
60 [0x50] = "Write Error",
61 [0x51] = "Erase Error",
62 [0x52] = "Formatting Error",
63 [0x53] = "Read Error",
64 [0x54] = "Unsupported Format",
65 [0x55] = "No Formatting",
66 [0x56] = "Positioning lost",
67 [0x57] = "Read Length",
68 [0x60] = "Unsupported Medium",
69 [0x61] = "Medium Length Error",
70 [0x62] = "Medium removed",
71 [0x64] = "Load Check",
72 [0x65] = "Unload Check",
73 [0x70] = "Equipment Check",
74 [0x71] = "Bus out Check",
75 [0x72] = "Protocol Error",
76 [0x73] = "Interface Error",
77 [0x74] = "Overrun",
78 [0x75] = "Halt Signal",
79 [0x90] = "Device fenced",
80 [0x91] = "Device Path fenced",
81 [0xa0] = "Volume misplaced",
82 [0xa1] = "Volume inaccessible",
83 [0xa2] = "Volume in input",
84 [0xa3] = "Volume ejected",
85 [0xa4] = "All categories reserved",
86 [0xa5] = "Duplicate Volume",
87 [0xa6] = "Library Manager Offline",
88 [0xa7] = "Library Output Station full",
89 [0xa8] = "Vision System non-operational",
90 [0xa9] = "Library Manager Equipment Check",
91 [0xaa] = "Library Equipment Check",
92 [0xab] = "All Library Cells full",
93 [0xac] = "No Cleaner Volumes in Library",
94 [0xad] = "I/O Station door open",
95 [0xae] = "Subsystem environmental alert",
96};
97
cced1dd4
MH		 98static int crypt_supported(struct tape_device *device)
99{
100 return TAPE390_CRYPT_SUPPORTED(TAPE_3590_CRYPT_INFO(device));
101}
102
103static int crypt_enabled(struct tape_device *device)
104{
105 return TAPE390_CRYPT_ON(TAPE_3590_CRYPT_INFO(device));
106}
107
108static void ext_to_int_kekl(struct tape390_kekl *in,
109 struct tape3592_kekl *out)
110{
111 int i;
112
113 memset(out, 0, sizeof(*out));
114 if (in->type == TAPE390_KEKL_TYPE_HASH)
115 out->flags |= 0x40;
116 if (in->type_on_tape == TAPE390_KEKL_TYPE_HASH)
117 out->flags |= 0x80;
118 strncpy(out->label, in->label, 64);
119 for (i = strlen(in->label); i < sizeof(out->label); i++)
120 out->label[i] = ' ';
121 ASCEBC(out->label, sizeof(out->label));
122}
123
124static void int_to_ext_kekl(struct tape3592_kekl *in,
125 struct tape390_kekl *out)
126{
127 memset(out, 0, sizeof(*out));
128 if(in->flags & 0x40)
129 out->type = TAPE390_KEKL_TYPE_HASH;
130 else
131 out->type = TAPE390_KEKL_TYPE_LABEL;
132 if(in->flags & 0x80)
133 out->type_on_tape = TAPE390_KEKL_TYPE_HASH;
134 else
135 out->type_on_tape = TAPE390_KEKL_TYPE_LABEL;
136 memcpy(out->label, in->label, sizeof(in->label));
137 EBCASC(out->label, sizeof(in->label));
138 strstrip(out->label);
139}
140
141static void int_to_ext_kekl_pair(struct tape3592_kekl_pair *in,
142 struct tape390_kekl_pair *out)
143{
144 if (in->count == 0) {
145 out->kekl[0].type = TAPE390_KEKL_TYPE_NONE;
146 out->kekl[0].type_on_tape = TAPE390_KEKL_TYPE_NONE;
147 out->kekl[1].type = TAPE390_KEKL_TYPE_NONE;
148 out->kekl[1].type_on_tape = TAPE390_KEKL_TYPE_NONE;
149 } else if (in->count == 1) {
150 int_to_ext_kekl(&in->kekl[0], &out->kekl[0]);
151 out->kekl[1].type = TAPE390_KEKL_TYPE_NONE;
152 out->kekl[1].type_on_tape = TAPE390_KEKL_TYPE_NONE;
153 } else if (in->count == 2) {
154 int_to_ext_kekl(&in->kekl[0], &out->kekl[0]);
155 int_to_ext_kekl(&in->kekl[1], &out->kekl[1]);
156 } else {
157 printk("Invalid KEKL number: %d\n", in->count);
158 BUG();
159 }
160}
161
162static int check_ext_kekl(struct tape390_kekl *kekl)
163{
164 if (kekl->type == TAPE390_KEKL_TYPE_NONE)
165 goto invalid;
166 if (kekl->type > TAPE390_KEKL_TYPE_HASH)
167 goto invalid;
168 if (kekl->type_on_tape == TAPE390_KEKL_TYPE_NONE)
169 goto invalid;
170 if (kekl->type_on_tape > TAPE390_KEKL_TYPE_HASH)
171 goto invalid;
172 if ((kekl->type == TAPE390_KEKL_TYPE_HASH) &&
173 (kekl->type_on_tape == TAPE390_KEKL_TYPE_LABEL))
174 goto invalid;
175
176 return 0;
177invalid:
178 return -EINVAL;
179}
180
181static int check_ext_kekl_pair(struct tape390_kekl_pair *kekls)
182{
183 if (check_ext_kekl(&kekls->kekl[0]))
184 goto invalid;
185 if (check_ext_kekl(&kekls->kekl[1]))
186 goto invalid;
187
188 return 0;
189invalid:
190 return -EINVAL;
191}
192
193/*
194 * Query KEKLs
195 */
196static int tape_3592_kekl_query(struct tape_device *device,
197 struct tape390_kekl_pair *ext_kekls)
198{
199 struct tape_request *request;
200 struct tape3592_kekl_query_order *order;
201 struct tape3592_kekl_query_data *int_kekls;
202 int rc;
203
204 DBF_EVENT(6, "tape3592_kekl_query\n");
205 int_kekls = kmalloc(sizeof(*int_kekls), GFP_KERNEL|GFP_DMA);
206 if (!int_kekls)
207 return -ENOMEM;
208 request = tape_alloc_request(2, sizeof(*order));
209 if (IS_ERR(request)) {
210 rc = PTR_ERR(request);
211 goto fail_malloc;
212 }
213 order = request->cpdata;
214 memset(order,0,sizeof(*order));
215 order->code = 0xe2;
216 order->max_count = 2;
217 request->op = TO_KEKL_QUERY;
218 tape_ccw_cc(request->cpaddr, PERF_SUBSYS_FUNC, sizeof(*order), order);
219 tape_ccw_end(request->cpaddr + 1, READ_SS_DATA, sizeof(*int_kekls),
220 int_kekls);
221 rc = tape_do_io(device, request);
222 if (rc)
223 goto fail_request;
224 int_to_ext_kekl_pair(&int_kekls->kekls, ext_kekls);
225
226 rc = 0;
227fail_request:
228 tape_free_request(request);
229fail_malloc:
230 kfree(int_kekls);
231 return rc;
232}
233
234/*
235 * IOCTL: Query KEKLs
236 */
237static int tape_3592_ioctl_kekl_query(struct tape_device *device,
238 unsigned long arg)
239{
240 int rc;
241 struct tape390_kekl_pair *ext_kekls;
242
243 DBF_EVENT(6, "tape_3592_ioctl_kekl_query\n");
244 if (!crypt_supported(device))
245 return -ENOSYS;
246 if (!crypt_enabled(device))
247 return -EUNATCH;
248 ext_kekls = kmalloc(sizeof(*ext_kekls), GFP_KERNEL);
249 if (!ext_kekls)
250 return -ENOMEM;
251 rc = tape_3592_kekl_query(device, ext_kekls);
252 if (rc != 0)
253 goto fail;
254 if (copy_to_user((char __user *) arg, ext_kekls, sizeof(*ext_kekls))) {
255 rc = -EFAULT;
256 goto fail;
257 }
258 rc = 0;
259fail:
260 kfree(ext_kekls);
261 return rc;
262}
263
264static int tape_3590_mttell(struct tape_device *device, int mt_count);
265
266/*
267 * Set KEKLs
268 */
269static int tape_3592_kekl_set(struct tape_device *device,
270 struct tape390_kekl_pair *ext_kekls)
271{
272 struct tape_request *request;
273 struct tape3592_kekl_set_order *order;
274
275 DBF_EVENT(6, "tape3592_kekl_set\n");
276 if (check_ext_kekl_pair(ext_kekls)) {
277 DBF_EVENT(6, "invalid kekls\n");
278 return -EINVAL;
279 }
280 if (tape_3590_mttell(device, 0) != 0)
281 return -EBADSLT;
282 request = tape_alloc_request(1, sizeof(*order));
283 if (IS_ERR(request))
284 return PTR_ERR(request);
285 order = request->cpdata;
286 memset(order, 0, sizeof(*order));
287 order->code = 0xe3;
288 order->kekls.count = 2;
289 ext_to_int_kekl(&ext_kekls->kekl[0], &order->kekls.kekl[0]);
290 ext_to_int_kekl(&ext_kekls->kekl[1], &order->kekls.kekl[1]);
291 request->op = TO_KEKL_SET;
292 tape_ccw_end(request->cpaddr, PERF_SUBSYS_FUNC, sizeof(*order), order);
293
294 return tape_do_io_free(device, request);
295}
296
297/*
298 * IOCTL: Set KEKLs
299 */
300static int tape_3592_ioctl_kekl_set(struct tape_device *device,
301 unsigned long arg)
302{
303 int rc;
304 struct tape390_kekl_pair *ext_kekls;
305
306 DBF_EVENT(6, "tape_3592_ioctl_kekl_set\n");
307 if (!crypt_supported(device))
308 return -ENOSYS;
309 if (!crypt_enabled(device))
310 return -EUNATCH;
311 ext_kekls = kmalloc(sizeof(*ext_kekls), GFP_KERNEL);
312 if (!ext_kekls)
313 return -ENOMEM;
314 if (copy_from_user(ext_kekls, (char __user *)arg, sizeof(*ext_kekls))) {
315 rc = -EFAULT;
316 goto out;
317 }
318 rc = tape_3592_kekl_set(device, ext_kekls);
319out:
320 kfree(ext_kekls);
321 return rc;
322}
323
324/*
325 * Enable encryption
326 */
327static int tape_3592_enable_crypt(struct tape_device *device)
328{
329 struct tape_request *request;
330 char *data;
331
332 DBF_EVENT(6, "tape_3592_enable_crypt\n");
333 if (!crypt_supported(device))
334 return -ENOSYS;
335 request = tape_alloc_request(2, 72);
336 if (IS_ERR(request))
337 return PTR_ERR(request);
338 data = request->cpdata;
339 memset(data,0,72);
340
341 data[0] = 0x05;
342 data[36 + 0] = 0x03;
343 data[36 + 1] = 0x03;
344 data[36 + 4] = 0x40;
345 data[36 + 6] = 0x01;
346 data[36 + 14] = 0x2f;
347 data[36 + 18] = 0xc3;
348 data[36 + 35] = 0x72;
349 request->op = TO_CRYPT_ON;
350 tape_ccw_cc(request->cpaddr, MODE_SET_CB, 36, data);
351 tape_ccw_end(request->cpaddr + 1, MODE_SET_CB, 36, data + 36);
352 return tape_do_io_free(device, request);
353}
354
355/*
356 * Disable encryption
357 */
358static int tape_3592_disable_crypt(struct tape_device *device)
359{
360 struct tape_request *request;
361 char *data;
362
363 DBF_EVENT(6, "tape_3592_disable_crypt\n");
364 if (!crypt_supported(device))
365 return -ENOSYS;
366 request = tape_alloc_request(2, 72);
367 if (IS_ERR(request))
368 return PTR_ERR(request);
369 data = request->cpdata;
370 memset(data,0,72);
371
372 data[0] = 0x05;
373 data[36 + 0] = 0x03;
374 data[36 + 1] = 0x03;
375 data[36 + 35] = 0x32;
376
377 request->op = TO_CRYPT_OFF;
378 tape_ccw_cc(request->cpaddr, MODE_SET_CB, 36, data);
379 tape_ccw_end(request->cpaddr + 1, MODE_SET_CB, 36, data + 36);
380
381 return tape_do_io_free(device, request);
382}
383
384/*
385 * IOCTL: Set encryption status
386 */
387static int tape_3592_ioctl_crypt_set(struct tape_device *device,
388 unsigned long arg)
389{
390 struct tape390_crypt_info info;
391
392 DBF_EVENT(6, "tape_3592_ioctl_crypt_set\n");
393 if (!crypt_supported(device))
394 return -ENOSYS;
395 if (copy_from_user(&info, (char __user *)arg, sizeof(info)))
396 return -EFAULT;
397 if (info.status & ~TAPE390_CRYPT_ON_MASK)
398 return -EINVAL;
399 if (info.status & TAPE390_CRYPT_ON_MASK)
400 return tape_3592_enable_crypt(device);
401 else
402 return tape_3592_disable_crypt(device);
403}
404
405static int tape_3590_sense_medium(struct tape_device *device);
406
407/*
408 * IOCTL: Query enryption status
409 */
410static int tape_3592_ioctl_crypt_query(struct tape_device *device,
411 unsigned long arg)
412{
413 DBF_EVENT(6, "tape_3592_ioctl_crypt_query\n");
414 if (!crypt_supported(device))
415 return -ENOSYS;
416 tape_3590_sense_medium(device);
417 if (copy_to_user((char __user *) arg, &TAPE_3590_CRYPT_INFO(device),
418 sizeof(TAPE_3590_CRYPT_INFO(device))))
419 return -EFAULT;
420 else
421 return 0;
422}
423
b6cba4ee
SB		 424/*
425 * 3590 IOCTL Overload
426 */
427static int
428tape_3590_ioctl(struct tape_device *device, unsigned int cmd, unsigned long arg)
429{
430 switch (cmd) {
431 case TAPE390_DISPLAY: {
432 struct display_struct disp;
433
434 if (copy_from_user(&disp, (char __user *) arg, sizeof(disp)))
435 return -EFAULT;
436
437 return tape_std_display(device, &disp);
438 }
cced1dd4
MH		 439 case TAPE390_KEKL_SET:
440 return tape_3592_ioctl_kekl_set(device, arg);
441 case TAPE390_KEKL_QUERY:
442 return tape_3592_ioctl_kekl_query(device, arg);
443 case TAPE390_CRYPT_SET:
444 return tape_3592_ioctl_crypt_set(device, arg);
445 case TAPE390_CRYPT_QUERY:
446 return tape_3592_ioctl_crypt_query(device, arg);
b6cba4ee
SB		 447 default:
448 return -EINVAL; /* no additional ioctls */
449 }
450}
451
452/*
453 * SENSE Medium: Get Sense data about medium state
454 */
455static int
456tape_3590_sense_medium(struct tape_device *device)
457{
458 struct tape_request *request;
459
460 request = tape_alloc_request(1, 128);
461 if (IS_ERR(request))
462 return PTR_ERR(request);
463 request->op = TO_MSEN;
464 tape_ccw_end(request->cpaddr, MEDIUM_SENSE, 128, request->cpdata);
465 return tape_do_io_free(device, request);
466}
467
468/*
469 * MTTELL: Tell block. Return the number of block relative to current file.
470 */
471static int
472tape_3590_mttell(struct tape_device *device, int mt_count)
473{
474 __u64 block_id;
475 int rc;
476
477 rc = tape_std_read_block_id(device, &block_id);
478 if (rc)
479 return rc;
480 return block_id >> 32;
481}
482
483/*
484 * MTSEEK: seek to the specified block.
485 */
486static int
487tape_3590_mtseek(struct tape_device *device, int count)
488{
489 struct tape_request *request;
490
491 DBF_EVENT(6, "xsee id: %x\n", count);
492 request = tape_alloc_request(3, 4);
493 if (IS_ERR(request))
494 return PTR_ERR(request);
495 request->op = TO_LBL;
496 tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
497 *(__u32 *) request->cpdata = count;
498 tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
499 tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
500 return tape_do_io_free(device, request);
501}
502
503/*
504 * Read Opposite Error Recovery Function:
505 * Used, when Read Forward does not work
506 */
507static void
508tape_3590_read_opposite(struct tape_device *device,
509 struct tape_request *request)
510{
511 struct tape_3590_disc_data *data;
512
513 /*
514 * We have allocated 4 ccws in tape_std_read, so we can now
515 * transform the request to a read backward, followed by a
516 * forward space block.
517 */
518 request->op = TO_RBA;
519 tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
520 data = device->discdata;
521 tape_ccw_cc_idal(request->cpaddr + 1, data->read_back_op,
522 device->char_data.idal_buf);
523 tape_ccw_cc(request->cpaddr + 2, FORSPACEBLOCK, 0, NULL);
524 tape_ccw_end(request->cpaddr + 3, NOP, 0, NULL);
525 DBF_EVENT(6, "xrop ccwg\n");
526}
527
528/*
529 * Read Attention Msg
530 * This should be done after an interrupt with attention bit (0x80)
531 * in device state.
532 *
533 * After a "read attention message" request there are two possible
534 * results:
535 *
536 * 1. A unit check is presented, when attention sense is present (e.g. when
537 * a medium has been unloaded). The attention sense comes then
538 * together with the unit check. The recovery action is either "retry"
539 * (in case there is an attention message pending) or "permanent error".
540 *
541 * 2. The attention msg is written to the "read subsystem data" buffer.
542 * In this case we probably should print it to the console.
543 */
544static int
545tape_3590_read_attmsg(struct tape_device *device)
546{
547 struct tape_request *request;
548 char *buf;
549
550 request = tape_alloc_request(3, 4096);
551 if (IS_ERR(request))
552 return PTR_ERR(request);
553 request->op = TO_READ_ATTMSG;
554 buf = request->cpdata;
555 buf[0] = PREP_RD_SS_DATA;
556 buf[6] = RD_ATTMSG; /* read att msg */
557 tape_ccw_cc(request->cpaddr, PERFORM_SS_FUNC, 12, buf);
558 tape_ccw_cc(request->cpaddr + 1, READ_SS_DATA, 4096 - 12, buf + 12);
559 tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
560 return tape_do_io_free(device, request);
561}
562
563/*
564 * These functions are used to schedule follow-up actions from within an
565 * interrupt context (like unsolicited interrupts).
566 */
2cc924b8
SB		 567struct work_handler_data {
568 struct tape_device *device;
569 enum tape_op op;
570 struct work_struct work;
571};
572
b6cba4ee 573static void
c1637532 574tape_3590_work_handler(struct work_struct *work)
b6cba4ee 575{
c1637532
MS		 576 struct work_handler_data *p =
577 container_of(work, struct work_handler_data, work);
b6cba4ee
SB		 578
579 switch (p->op) {
580 case TO_MSEN:
581 tape_3590_sense_medium(p->device);
582 break;
583 case TO_READ_ATTMSG:
584 tape_3590_read_attmsg(p->device);
585 break;
cced1dd4
MH		 586 case TO_CRYPT_ON:
587 tape_3592_enable_crypt(p->device);
588 break;
589 case TO_CRYPT_OFF:
590 tape_3592_disable_crypt(p->device);
591 break;
b6cba4ee
SB		 592 default:
593 DBF_EVENT(3, "T3590: work handler undefined for "
594 "operation 0x%02x\n", p->op);
595 }
596 tape_put_device(p->device);
597 kfree(p);
598}
599
600static int
601tape_3590_schedule_work(struct tape_device *device, enum tape_op op)
602{
2cc924b8 603 struct work_handler_data *p;
b6cba4ee
SB		 604
605 if ((p = kzalloc(sizeof(*p), GFP_ATOMIC)) == NULL)
606 return -ENOMEM;
607
c1637532 608 INIT_WORK(&p->work, tape_3590_work_handler);
b6cba4ee
SB		 609
610 p->device = tape_get_device_reference(device);
611 p->op = op;
612
613 schedule_work(&p->work);
614 return 0;
615}
616
617#ifdef CONFIG_S390_TAPE_BLOCK
618/*
619 * Tape Block READ
620 */
621static struct tape_request *
622tape_3590_bread(struct tape_device *device, struct request *req)
623{
624 struct tape_request *request;
625 struct ccw1 *ccw;
626 int count = 0, start_block, i;
627 unsigned off;
628 char *dst;
629 struct bio_vec *bv;
630 struct bio *bio;
631
632 DBF_EVENT(6, "xBREDid:");
633 start_block = req->sector >> TAPEBLOCK_HSEC_S2B;
634 DBF_EVENT(6, "start_block = %i\n", start_block);
635
636 rq_for_each_bio(bio, req) {
637 bio_for_each_segment(bv, bio, i) {
638 count += bv->bv_len >> (TAPEBLOCK_HSEC_S2B + 9);
639 }
640 }
641 request = tape_alloc_request(2 + count + 1, 4);
642 if (IS_ERR(request))
643 return request;
644 request->op = TO_BLOCK;
645 *(__u32 *) request->cpdata = start_block;
646 ccw = request->cpaddr;
647 ccw = tape_ccw_cc(ccw, MODE_SET_DB, 1, device->modeset_byte);
648
649 /*
650 * We always setup a nop after the mode set ccw. This slot is
651 * used in tape_std_check_locate to insert a locate ccw if the
652 * current tape position doesn't match the start block to be read.
653 */
654 ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
655
656 rq_for_each_bio(bio, req) {
657 bio_for_each_segment(bv, bio, i) {
2cc924b8 658 dst = page_address(bv->bv_page) + bv->bv_offset;
b6cba4ee
SB		 659 for (off = 0; off < bv->bv_len;
660 off += TAPEBLOCK_HSEC_SIZE) {
661 ccw->flags = CCW_FLAG_CC;
662 ccw->cmd_code = READ_FORWARD;
663 ccw->count = TAPEBLOCK_HSEC_SIZE;
664 set_normalized_cda(ccw, (void *) __pa(dst));
665 ccw++;
666 dst += TAPEBLOCK_HSEC_SIZE;
667 }
668 if (off > bv->bv_len)
669 BUG();
670 }
671 }
672 ccw = tape_ccw_end(ccw, NOP, 0, NULL);
673 DBF_EVENT(6, "xBREDccwg\n");
674 return request;
675}
676
677static void
678tape_3590_free_bread(struct tape_request *request)
679{
680 struct ccw1 *ccw;
681
682 /* Last ccw is a nop and doesn't need clear_normalized_cda */
683 for (ccw = request->cpaddr; ccw->flags & CCW_FLAG_CC; ccw++)
684 if (ccw->cmd_code == READ_FORWARD)
685 clear_normalized_cda(ccw);
686 tape_free_request(request);
687}
688
689/*
690 * check_locate is called just before the tape request is passed to
691 * the common io layer for execution. It has to check the current
692 * tape position and insert a locate ccw if it doesn't match the
693 * start block for the request.
694 */
695static void
696tape_3590_check_locate(struct tape_device *device, struct tape_request *request)
697{
698 __u32 *start_block;
699
700 start_block = (__u32 *) request->cpdata;
701 if (*start_block != device->blk_data.block_position) {
702 /* Add the start offset of the file to get the real block. */
703 *start_block += device->bof;
704 tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
705 }
706}
707#endif
708
cced1dd4
MH		 709static void tape_3590_med_state_set(struct tape_device *device,
710 struct tape_3590_med_sense *sense)
711{
712 struct tape390_crypt_info *c_info;
713
714 c_info = &TAPE_3590_CRYPT_INFO(device);
715
716 if (sense->masst == MSENSE_UNASSOCIATED) {
717 tape_med_state_set(device, MS_UNLOADED);
718 TAPE_3590_CRYPT_INFO(device).medium_status = 0;
719 return;
720 }
721 if (sense->masst != MSENSE_ASSOCIATED_MOUNT) {
722 PRINT_ERR("Unknown medium state: %x\n", sense->masst);
723 return;
724 }
725 tape_med_state_set(device, MS_LOADED);
726 c_info->medium_status |= TAPE390_MEDIUM_LOADED_MASK;
727 if (sense->flags & MSENSE_CRYPT_MASK) {
728 PRINT_INFO("Medium is encrypted (%04x)\n", sense->flags);
729 c_info->medium_status |= TAPE390_MEDIUM_ENCRYPTED_MASK;
730 } else {
731 DBF_EVENT(6, "Medium is not encrypted %04x\n", sense->flags);
732 c_info->medium_status &= ~TAPE390_MEDIUM_ENCRYPTED_MASK;
733 }
734}
735
b6cba4ee
SB		 736/*
737 * The done handler is called at device/channel end and wakes up the sleeping
738 * process
739 */
740static int
741tape_3590_done(struct tape_device *device, struct tape_request *request)
742{
cced1dd4 743 struct tape_3590_disc_data *disc_data;
b6cba4ee
SB		 744
745 DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
cced1dd4 746 disc_data = device->discdata;
b6cba4ee
SB		 747
748 switch (request->op) {
749 case TO_BSB:
750 case TO_BSF:
751 case TO_DSE:
752 case TO_FSB:
753 case TO_FSF:
754 case TO_LBL:
755 case TO_RFO:
756 case TO_RBA:
757 case TO_REW:
758 case TO_WRI:
759 case TO_WTM:
760 case TO_BLOCK:
761 case TO_LOAD:
762 tape_med_state_set(device, MS_LOADED);
763 break;
764 case TO_RUN:
765 tape_med_state_set(device, MS_UNLOADED);
cced1dd4 766 tape_3590_schedule_work(device, TO_CRYPT_OFF);
b6cba4ee
SB		 767 break;
768 case TO_MSEN:
cced1dd4
MH		 769 tape_3590_med_state_set(device, request->cpdata);
770 break;
771 case TO_CRYPT_ON:
772 TAPE_3590_CRYPT_INFO(device).status
773 |= TAPE390_CRYPT_ON_MASK;
774 *(device->modeset_byte) |= 0x03;
775 break;
776 case TO_CRYPT_OFF:
777 TAPE_3590_CRYPT_INFO(device).status
778 &= ~TAPE390_CRYPT_ON_MASK;
779 *(device->modeset_byte) &= ~0x03;
b6cba4ee
SB		 780 break;
781 case TO_RBI: /* RBI seems to succeed even without medium loaded. */
782 case TO_NOP: /* Same to NOP. */
783 case TO_READ_CONFIG:
784 case TO_READ_ATTMSG:
785 case TO_DIS:
786 case TO_ASSIGN:
787 case TO_UNASSIGN:
b6cba4ee 788 case TO_SIZE:
cced1dd4
MH		 789 case TO_KEKL_SET:
790 case TO_KEKL_QUERY:
b6cba4ee
SB		 791 break;
792 }
793 return TAPE_IO_SUCCESS;
794}
795
796/*
797 * This fuction is called, when error recovery was successfull
798 */
799static inline int
800tape_3590_erp_succeded(struct tape_device *device, struct tape_request *request)
801{
802 DBF_EVENT(3, "Error Recovery successfull for %s\n",
803 tape_op_verbose[request->op]);
804 return tape_3590_done(device, request);
805}
806
807/*
808 * This fuction is called, when error recovery was not successfull
809 */
810static inline int
811tape_3590_erp_failed(struct tape_device *device, struct tape_request *request,
812 struct irb *irb, int rc)
813{
814 DBF_EVENT(3, "Error Recovery failed for %s\n",
815 tape_op_verbose[request->op]);
816 tape_dump_sense_dbf(device, request, irb);
817 return rc;
818}
819
820/*
821 * Error Recovery do retry
822 */
823static inline int
824tape_3590_erp_retry(struct tape_device *device, struct tape_request *request,
825 struct irb *irb)
826{
827 DBF_EVENT(2, "Retry: %s\n", tape_op_verbose[request->op]);
828 tape_dump_sense_dbf(device, request, irb);
829 return TAPE_IO_RETRY;
830}
831
832/*
833 * Handle unsolicited interrupts
834 */
835static int
836tape_3590_unsolicited_irq(struct tape_device *device, struct irb *irb)
837{
838 if (irb->scsw.dstat == DEV_STAT_CHN_END)
839 /* Probably result of halt ssch */
840 return TAPE_IO_PENDING;
841 else if (irb->scsw.dstat == 0x85)
842 /* Device Ready -> check medium state */
843 tape_3590_schedule_work(device, TO_MSEN);
844 else if (irb->scsw.dstat & DEV_STAT_ATTENTION)
845 tape_3590_schedule_work(device, TO_READ_ATTMSG);
846 else {
847 DBF_EVENT(3, "unsol.irq! dev end: %08x\n", device->cdev_id);
848 PRINT_WARN("Unsolicited IRQ (Device End) caught.\n");
849 tape_dump_sense(device, NULL, irb);
850 }
851 return TAPE_IO_SUCCESS;
852}
853
854/*
855 * Basic Recovery routine
856 */
857static int
858tape_3590_erp_basic(struct tape_device *device, struct tape_request *request,
859 struct irb *irb, int rc)
860{
861 struct tape_3590_sense *sense;
862
863 sense = (struct tape_3590_sense *) irb->ecw;
864
865 switch (sense->bra) {
866 case SENSE_BRA_PER:
867 return tape_3590_erp_failed(device, request, irb, rc);
868 case SENSE_BRA_CONT:
869 return tape_3590_erp_succeded(device, request);
870 case SENSE_BRA_RE:
871 return tape_3590_erp_retry(device, request, irb);
872 case SENSE_BRA_DRE:
873 return tape_3590_erp_failed(device, request, irb, rc);
874 default:
875 PRINT_ERR("Unknown BRA %x - This should not happen!\n",
876 sense->bra);
877 BUG();
878 return TAPE_IO_STOP;
879 }
880}
881
882/*
883 * RDL: Read Device (buffered) log
884 */
885static int
886tape_3590_erp_read_buf_log(struct tape_device *device,
887 struct tape_request *request, struct irb *irb)
888{
889 /*
890 * We just do the basic error recovery at the moment (retry).
891 * Perhaps in the future, we read the log and dump it somewhere...
892 */
893 return tape_3590_erp_basic(device, request, irb, -EIO);
894}
895
896/*
897 * SWAP: Swap Devices
898 */
899static int
900tape_3590_erp_swap(struct tape_device *device, struct tape_request *request,
901 struct irb *irb)
902{
903 /*
904 * This error recovery should swap the tapes
905 * if the original has a problem. The operation
906 * should proceed with the new tape... this
907 * should probably be done in user space!
908 */
909 PRINT_WARN("(%s): Swap Tape Device!\n", device->cdev->dev.bus_id);
910 return tape_3590_erp_basic(device, request, irb, -EIO);
911}
912
913/*
914 * LBY: Long Busy
915 */
916static int
917tape_3590_erp_long_busy(struct tape_device *device,
918 struct tape_request *request, struct irb *irb)
919{
cced1dd4
MH		 920 DBF_EVENT(6, "Device is busy\n");
921 return TAPE_IO_LONG_BUSY;
b6cba4ee
SB		 922}
923
924/*
925 * SPI: Special Intercept
926 */
927static int
928tape_3590_erp_special_interrupt(struct tape_device *device,
929 struct tape_request *request, struct irb *irb)
930{
931 return tape_3590_erp_basic(device, request, irb, -EIO);
932}
933
934/*
935 * RDA: Read Alternate
936 */
937static int
938tape_3590_erp_read_alternate(struct tape_device *device,
939 struct tape_request *request, struct irb *irb)
940{
941 struct tape_3590_disc_data *data;
942
943 /*
944 * The issued Read Backward or Read Previous command is not
945 * supported by the device
946 * The recovery action should be to issue another command:
947 * Read Revious: if Read Backward is not supported
948 * Read Backward: if Read Previous is not supported
949 */
950 data = device->discdata;
951 if (data->read_back_op == READ_PREVIOUS) {
952 DBF_EVENT(2, "(%08x): No support for READ_PREVIOUS command\n",
953 device->cdev_id);
954 data->read_back_op = READ_BACKWARD;
955 } else {
956 DBF_EVENT(2, "(%08x): No support for READ_BACKWARD command\n",
957 device->cdev_id);
958 data->read_back_op = READ_PREVIOUS;
959 }
960 tape_3590_read_opposite(device, request);
961 return tape_3590_erp_retry(device, request, irb);
962}
963
964/*
965 * Error Recovery read opposite
966 */
967static int
968tape_3590_erp_read_opposite(struct tape_device *device,
969 struct tape_request *request, struct irb *irb)
970{
971 switch (request->op) {
972 case TO_RFO:
973 /*
974 * We did read forward, but the data could not be read.
975 * We will read backward and then skip forward again.
976 */
977 tape_3590_read_opposite(device, request);
978 return tape_3590_erp_retry(device, request, irb);
979 case TO_RBA:
980 /* We tried to read forward and backward, but hat no success */
981 return tape_3590_erp_failed(device, request, irb, -EIO);
982 break;
983 default:
984 PRINT_WARN("read_opposite_recovery_called_with_op: %s\n",
985 tape_op_verbose[request->op]);
986 return tape_3590_erp_failed(device, request, irb, -EIO);
987 }
988}
989
990/*
991 * Print an MIM (Media Information Message) (message code f0)
992 */
993static void
994tape_3590_print_mim_msg_f0(struct tape_device *device, struct irb *irb)
995{
996 struct tape_3590_sense *sense;
997
998 sense = (struct tape_3590_sense *) irb->ecw;
999 /* Exception Message */
1000 switch (sense->fmt.f70.emc) {
1001 case 0x02:
1002 PRINT_WARN("(%s): Data degraded\n", device->cdev->dev.bus_id);
1003 break;
1004 case 0x03:
1005 PRINT_WARN("(%s): Data degraded in partion %i\n",
1006 device->cdev->dev.bus_id, sense->fmt.f70.mp);
1007 break;
1008 case 0x04:
1009 PRINT_WARN("(%s): Medium degraded\n", device->cdev->dev.bus_id);
1010 break;
1011 case 0x05:
1012 PRINT_WARN("(%s): Medium degraded in partition %i\n",
1013 device->cdev->dev.bus_id, sense->fmt.f70.mp);
1014 break;
1015 case 0x06:
1016 PRINT_WARN("(%s): Block 0 Error\n", device->cdev->dev.bus_id);
1017 break;
1018 case 0x07:
1019 PRINT_WARN("(%s): Medium Exception 0x%02x\n",
1020 device->cdev->dev.bus_id, sense->fmt.f70.md);
1021 break;
1022 default:
1023 PRINT_WARN("(%s): MIM ExMsg: 0x%02x\n",
1024 device->cdev->dev.bus_id, sense->fmt.f70.emc);
1025 break;
1026 }
1027 /* Service Message */
1028 switch (sense->fmt.f70.smc) {
1029 case 0x02:
1030 PRINT_WARN("(%s): Reference Media maintenance procedure %i\n",
1031 device->cdev->dev.bus_id, sense->fmt.f70.md);
1032 break;
1033 default:
1034 PRINT_WARN("(%s): MIM ServiceMsg: 0x%02x\n",
1035 device->cdev->dev.bus_id, sense->fmt.f70.smc);
1036 break;
1037 }
1038}
1039
1040/*
1041 * Print an I/O Subsystem Service Information Message (message code f1)
1042 */
1043static void
1044tape_3590_print_io_sim_msg_f1(struct tape_device *device, struct irb *irb)
1045{
1046 struct tape_3590_sense *sense;
1047
1048 sense = (struct tape_3590_sense *) irb->ecw;
1049 /* Exception Message */
1050 switch (sense->fmt.f71.emc) {
1051 case 0x01:
1052 PRINT_WARN("(%s): Effect of failure is unknown\n",
1053 device->cdev->dev.bus_id);
1054 break;
1055 case 0x02:
1056 PRINT_WARN("(%s): CU Exception - no performance impact\n",
1057 device->cdev->dev.bus_id);
1058 break;
1059 case 0x03:
1060 PRINT_WARN("(%s): CU Exception on channel interface 0x%02x\n",
1061 device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1062 break;
1063 case 0x04:
1064 PRINT_WARN("(%s): CU Exception on device path 0x%02x\n",
1065 device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1066 break;
1067 case 0x05:
1068 PRINT_WARN("(%s): CU Exception on library path 0x%02x\n",
1069 device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1070 break;
1071 case 0x06:
1072 PRINT_WARN("(%s): CU Exception on node 0x%02x\n",
1073 device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1074 break;
1075 case 0x07:
1076 PRINT_WARN("(%s): CU Exception on partition 0x%02x\n",
1077 device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1078 break;
1079 default:
1080 PRINT_WARN("(%s): SIM ExMsg: 0x%02x\n",
1081 device->cdev->dev.bus_id, sense->fmt.f71.emc);
1082 }
1083 /* Service Message */
1084 switch (sense->fmt.f71.smc) {
1085 case 0x01:
1086 PRINT_WARN("(%s): Repair impact is unknown\n",
1087 device->cdev->dev.bus_id);
1088 break;
1089 case 0x02:
1090 PRINT_WARN("(%s): Repair will not impact cu performance\n",
1091 device->cdev->dev.bus_id);
1092 break;
1093 case 0x03:
1094 if (sense->fmt.f71.mdf == 0)
1095 PRINT_WARN("(%s): Repair will disable node "
1096 "0x%x on CU\n",
1097 device->cdev->dev.bus_id,
1098 sense->fmt.f71.md[1]);
1099 else
1100 PRINT_WARN("(%s): Repair will disable nodes "
1101 "(0x%x-0x%x) on CU\n",
1102 device->cdev->dev.bus_id,
1103 sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1104 break;
1105 case 0x04:
1106 if (sense->fmt.f71.mdf == 0)
1107 PRINT_WARN("(%s): Repair will disable cannel path "
1108 "0x%x on CU\n",
1109 device->cdev->dev.bus_id,
1110 sense->fmt.f71.md[1]);
1111 else
1112 PRINT_WARN("(%s): Repair will disable cannel paths "
1113 "(0x%x-0x%x) on CU\n",
1114 device->cdev->dev.bus_id,
1115 sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1116 break;
1117 case 0x05:
1118 if (sense->fmt.f71.mdf == 0)
1119 PRINT_WARN("(%s): Repair will disable device path "
1120 "0x%x on CU\n",
1121 device->cdev->dev.bus_id,
1122 sense->fmt.f71.md[1]);
1123 else
1124 PRINT_WARN("(%s): Repair will disable device paths "
1125 "(0x%x-0x%x) on CU\n",
1126 device->cdev->dev.bus_id,
1127 sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1128 break;
1129 case 0x06:
1130 if (sense->fmt.f71.mdf == 0)
1131 PRINT_WARN("(%s): Repair will disable library path "
1132 "0x%x on CU\n",
1133 device->cdev->dev.bus_id,
1134 sense->fmt.f71.md[1]);
1135 else
1136 PRINT_WARN("(%s): Repair will disable library paths "
1137 "(0x%x-0x%x) on CU\n",
1138 device->cdev->dev.bus_id,
1139 sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1140 break;
1141 case 0x07:
1142 PRINT_WARN("(%s): Repair will disable access to CU\n",
1143 device->cdev->dev.bus_id);
1144 break;
1145 default:
1146 PRINT_WARN("(%s): SIM ServiceMsg: 0x%02x\n",
1147 device->cdev->dev.bus_id, sense->fmt.f71.smc);
1148 }
1149}
1150
1151/*
1152 * Print an Device Subsystem Service Information Message (message code f2)
1153 */
1154static void
1155tape_3590_print_dev_sim_msg_f2(struct tape_device *device, struct irb *irb)
1156{
1157 struct tape_3590_sense *sense;
1158
1159 sense = (struct tape_3590_sense *) irb->ecw;
1160 /* Exception Message */
1161 switch (sense->fmt.f71.emc) {
1162 case 0x01:
1163 PRINT_WARN("(%s): Effect of failure is unknown\n",
1164 device->cdev->dev.bus_id);
1165 break;
1166 case 0x02:
1167 PRINT_WARN("(%s): DV Exception - no performance impact\n",
1168 device->cdev->dev.bus_id);
1169 break;
1170 case 0x03:
1171 PRINT_WARN("(%s): DV Exception on channel interface 0x%02x\n",
1172 device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1173 break;
1174 case 0x04:
1175 PRINT_WARN("(%s): DV Exception on loader 0x%02x\n",
1176 device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1177 break;
1178 case 0x05:
1179 PRINT_WARN("(%s): DV Exception on message display 0x%02x\n",
1180 device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1181 break;
1182 case 0x06:
1183 PRINT_WARN("(%s): DV Exception in tape path\n",
1184 device->cdev->dev.bus_id);
1185 break;
1186 case 0x07:
1187 PRINT_WARN("(%s): DV Exception in drive\n",
1188 device->cdev->dev.bus_id);
1189 break;
1190 default:
1191 PRINT_WARN("(%s): DSIM ExMsg: 0x%02x\n",
1192 device->cdev->dev.bus_id, sense->fmt.f71.emc);
1193 }
1194 /* Service Message */
1195 switch (sense->fmt.f71.smc) {
1196 case 0x01:
1197 PRINT_WARN("(%s): Repair impact is unknown\n",
1198 device->cdev->dev.bus_id);
1199 break;
1200 case 0x02:
1201 PRINT_WARN("(%s): Repair will not impact device performance\n",
1202 device->cdev->dev.bus_id);
1203 break;
1204 case 0x03:
1205 if (sense->fmt.f71.mdf == 0)
1206 PRINT_WARN("(%s): Repair will disable channel path "
1207 "0x%x on DV\n",
1208 device->cdev->dev.bus_id,
1209 sense->fmt.f71.md[1]);
1210 else
1211 PRINT_WARN("(%s): Repair will disable channel path "
1212 "(0x%x-0x%x) on DV\n",
1213 device->cdev->dev.bus_id,
1214 sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1215 break;
1216 case 0x04:
1217 if (sense->fmt.f71.mdf == 0)
1218 PRINT_WARN("(%s): Repair will disable interface 0x%x "
1219 "on DV\n",
1220 device->cdev->dev.bus_id,
1221 sense->fmt.f71.md[1]);
1222 else
1223 PRINT_WARN("(%s): Repair will disable interfaces "
1224 "(0x%x-0x%x) on DV\n",
1225 device->cdev->dev.bus_id,
1226 sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1227 break;
1228 case 0x05:
1229 if (sense->fmt.f71.mdf == 0)
1230 PRINT_WARN("(%s): Repair will disable loader 0x%x "
1231 "on DV\n",
1232 device->cdev->dev.bus_id,
1233 sense->fmt.f71.md[1]);
1234 else
1235 PRINT_WARN("(%s): Repair will disable loader "
1236 "(0x%x-0x%x) on DV\n",
1237 device->cdev->dev.bus_id,
1238 sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1239 break;
1240 case 0x07:
1241 PRINT_WARN("(%s): Repair will disable access to DV\n",
1242 device->cdev->dev.bus_id);
1243 break;
1244 case 0x08:
1245 if (sense->fmt.f71.mdf == 0)
1246 PRINT_WARN("(%s): Repair will disable message "
1247 "display 0x%x on DV\n",
1248 device->cdev->dev.bus_id,
1249 sense->fmt.f71.md[1]);
1250 else
1251 PRINT_WARN("(%s): Repair will disable message "
1252 "displays (0x%x-0x%x) on DV\n",
1253 device->cdev->dev.bus_id,
1254 sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1255 break;
1256 case 0x09:
1257 PRINT_WARN("(%s): Clean DV\n", device->cdev->dev.bus_id);
1258 break;
1259 default:
1260 PRINT_WARN("(%s): DSIM ServiceMsg: 0x%02x\n",
1261 device->cdev->dev.bus_id, sense->fmt.f71.smc);
1262 }
1263}
1264
1265/*
1266 * Print standard ERA Message
1267 */
1268static void
1269tape_3590_print_era_msg(struct tape_device *device, struct irb *irb)
1270{
1271 struct tape_3590_sense *sense;
1272
1273 sense = (struct tape_3590_sense *) irb->ecw;
1274 if (sense->mc == 0)
1275 return;
1276 if ((sense->mc > 0) && (sense->mc < TAPE_3590_MAX_MSG)) {
1277 if (tape_3590_msg[sense->mc] != NULL)
1278 PRINT_WARN("(%s): %s\n", device->cdev->dev.bus_id,
1279 tape_3590_msg[sense->mc]);
1280 else {
1281 PRINT_WARN("(%s): Message Code 0x%x\n",
1282 device->cdev->dev.bus_id, sense->mc);
1283 }
1284 return;
1285 }
1286 if (sense->mc == 0xf0) {
1287 /* Standard Media Information Message */
1288 PRINT_WARN("(%s): MIM SEV=%i, MC=%02x, ES=%x/%x, "
1289 "RC=%02x-%04x-%02x\n", device->cdev->dev.bus_id,
1290 sense->fmt.f70.sev, sense->mc,
1291 sense->fmt.f70.emc, sense->fmt.f70.smc,
1292 sense->fmt.f70.refcode, sense->fmt.f70.mid,
1293 sense->fmt.f70.fid);
1294 tape_3590_print_mim_msg_f0(device, irb);
1295 return;
1296 }
1297 if (sense->mc == 0xf1) {
1298 /* Standard I/O Subsystem Service Information Message */
1299 PRINT_WARN("(%s): IOSIM SEV=%i, DEVTYPE=3590/%02x, "
1300 "MC=%02x, ES=%x/%x, REF=0x%04x-0x%04x-0x%04x\n",
1301 device->cdev->dev.bus_id, sense->fmt.f71.sev,
1302 device->cdev->id.dev_model,
1303 sense->mc, sense->fmt.f71.emc,
1304 sense->fmt.f71.smc, sense->fmt.f71.refcode1,
1305 sense->fmt.f71.refcode2, sense->fmt.f71.refcode3);
1306 tape_3590_print_io_sim_msg_f1(device, irb);
1307 return;
1308 }
1309 if (sense->mc == 0xf2) {
1310 /* Standard Device Service Information Message */
1311 PRINT_WARN("(%s): DEVSIM SEV=%i, DEVTYPE=3590/%02x, "
1312 "MC=%02x, ES=%x/%x, REF=0x%04x-0x%04x-0x%04x\n",
1313 device->cdev->dev.bus_id, sense->fmt.f71.sev,
1314 device->cdev->id.dev_model,
1315 sense->mc, sense->fmt.f71.emc,
1316 sense->fmt.f71.smc, sense->fmt.f71.refcode1,
1317 sense->fmt.f71.refcode2, sense->fmt.f71.refcode3);
1318 tape_3590_print_dev_sim_msg_f2(device, irb);
1319 return;
1320 }
1321 if (sense->mc == 0xf3) {
1322 /* Standard Library Service Information Message */
1323 return;
1324 }
1325 PRINT_WARN("(%s): Device Message(%x)\n",
1326 device->cdev->dev.bus_id, sense->mc);
1327}
1328
cced1dd4
MH		 1329static int tape_3590_crypt_error(struct tape_device *device,
1330 struct tape_request *request, struct irb *irb)
1331{
1332 u8 cu_rc, ekm_rc1;
1333 u16 ekm_rc2;
1334 u32 drv_rc;
1335 char *bus_id, *sense;
1336
1337 sense = ((struct tape_3590_sense *) irb->ecw)->fmt.data;
1338 bus_id = device->cdev->dev.bus_id;
1339 cu_rc = sense[0];
1340 drv_rc = *((u32*) &sense[5]) & 0xffffff;
1341 ekm_rc1 = sense[9];
1342 ekm_rc2 = *((u16*) &sense[10]);
1343 if ((cu_rc == 0) && (ekm_rc2 == 0xee31))
1344 /* key not defined on EKM */
1345 return tape_3590_erp_basic(device, request, irb, -EKEYREJECTED);
1346 if ((cu_rc == 1) || (cu_rc == 2))
1347 /* No connection to EKM */
1348 return tape_3590_erp_basic(device, request, irb, -ENOTCONN);
1349
1350 PRINT_ERR("(%s): Unable to get encryption key from EKM\n", bus_id);
1351 PRINT_ERR("(%s): CU=%02X DRIVE=%06X EKM=%02X:%04X\n", bus_id, cu_rc,
1352 drv_rc, ekm_rc1, ekm_rc2);
1353
1354 return tape_3590_erp_basic(device, request, irb, -ENOKEY);
1355}
1356
b6cba4ee
SB		 1357/*
1358 * 3590 error Recovery routine:
1359 * If possible, it tries to recover from the error. If this is not possible,
1360 * inform the user about the problem.
1361 */
1362static int
1363tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
1364 struct irb *irb)
1365{
1366 struct tape_3590_sense *sense;
1367 int rc;
1368
1369#ifdef CONFIG_S390_TAPE_BLOCK
1370 if (request->op == TO_BLOCK) {
1371 /*
1372 * Recovery for block device requests. Set the block_position
1373 * to something invalid and retry.
1374 */
1375 device->blk_data.block_position = -1;
1376 if (request->retries-- <= 0)
1377 return tape_3590_erp_failed(device, request, irb, -EIO);
1378 else
1379 return tape_3590_erp_retry(device, request, irb);
1380 }
1381#endif
1382
1383 sense = (struct tape_3590_sense *) irb->ecw;
1384
cced1dd4
MH		 1385 DBF_EVENT(6, "Unit Check: RQC = %x\n", sense->rc_rqc);
1386
b6cba4ee
SB		 1387 /*
1388 * First check all RC-QRCs where we want to do something special
1389 * - "break": basic error recovery is done
1390 * - "goto out:": just print error message if available
1391 */
1392 rc = -EIO;
1393 switch (sense->rc_rqc) {
1394
1395 case 0x1110:
1396 tape_3590_print_era_msg(device, irb);
1397 return tape_3590_erp_read_buf_log(device, request, irb);
1398
1399 case 0x2011:
1400 tape_3590_print_era_msg(device, irb);
1401 return tape_3590_erp_read_alternate(device, request, irb);
1402
1403 case 0x2230:
1404 case 0x2231:
1405 tape_3590_print_era_msg(device, irb);
1406 return tape_3590_erp_special_interrupt(device, request, irb);
cced1dd4
MH		 1407 case 0x2240:
1408 return tape_3590_crypt_error(device, request, irb);
b6cba4ee
SB		 1409
1410 case 0x3010:
1411 DBF_EVENT(2, "(%08x): Backward at Beginning of Partition\n",
1412 device->cdev_id);
1413 return tape_3590_erp_basic(device, request, irb, -ENOSPC);
1414 case 0x3012:
1415 DBF_EVENT(2, "(%08x): Forward at End of Partition\n",
1416 device->cdev_id);
1417 return tape_3590_erp_basic(device, request, irb, -ENOSPC);
1418 case 0x3020:
1419 DBF_EVENT(2, "(%08x): End of Data Mark\n", device->cdev_id);
1420 return tape_3590_erp_basic(device, request, irb, -ENOSPC);
1421
1422 case 0x3122:
1423 DBF_EVENT(2, "(%08x): Rewind Unload initiated\n",
1424 device->cdev_id);
1425 return tape_3590_erp_basic(device, request, irb, -EIO);
1426 case 0x3123:
1427 DBF_EVENT(2, "(%08x): Rewind Unload complete\n",
1428 device->cdev_id);
1429 tape_med_state_set(device, MS_UNLOADED);
cced1dd4 1430 tape_3590_schedule_work(device, TO_CRYPT_OFF);
b6cba4ee
SB		 1431 return tape_3590_erp_basic(device, request, irb, 0);
1432
1433 case 0x4010:
1434 /*
1435 * print additional msg since default msg
1436 * "device intervention" is not very meaningfull
1437 */
1438 PRINT_WARN("(%s): Tape operation when medium not loaded\n",
1439 device->cdev->dev.bus_id);
1440 tape_med_state_set(device, MS_UNLOADED);
cced1dd4 1441 tape_3590_schedule_work(device, TO_CRYPT_OFF);
b6cba4ee
SB		 1442 return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
1443 case 0x4012: /* Device Long Busy */
cced1dd4
MH		 1444 /* XXX: Also use long busy handling here? */
1445 DBF_EVENT(6, "(%08x): LONG BUSY\n", device->cdev_id);
b6cba4ee 1446 tape_3590_print_era_msg(device, irb);
cced1dd4
MH		 1447 return tape_3590_erp_basic(device, request, irb, -EBUSY);
1448 case 0x4014:
1449 DBF_EVENT(6, "(%08x): Crypto LONG BUSY\n", device->cdev_id);
b6cba4ee
SB		 1450 return tape_3590_erp_long_busy(device, request, irb);
1451
1452 case 0x5010:
1453 if (sense->rac == 0xd0) {
1454 /* Swap */
1455 tape_3590_print_era_msg(device, irb);
1456 return tape_3590_erp_swap(device, request, irb);
1457 }
1458 if (sense->rac == 0x26) {
1459 /* Read Opposite */
1460 tape_3590_print_era_msg(device, irb);
1461 return tape_3590_erp_read_opposite(device, request,
1462 irb);
1463 }
1464 return tape_3590_erp_basic(device, request, irb, -EIO);
1465 case 0x5020:
1466 case 0x5021:
1467 case 0x5022:
1468 case 0x5040:
1469 case 0x5041:
1470 case 0x5042:
1471 tape_3590_print_era_msg(device, irb);
1472 return tape_3590_erp_swap(device, request, irb);
1473
1474 case 0x5110:
1475 case 0x5111:
1476 return tape_3590_erp_basic(device, request, irb, -EMEDIUMTYPE);
1477
1478 case 0x5120:
1479 case 0x1120:
1480 tape_med_state_set(device, MS_UNLOADED);
cced1dd4 1481 tape_3590_schedule_work(device, TO_CRYPT_OFF);
b6cba4ee
SB		 1482 return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
1483
1484 case 0x6020:
1485 PRINT_WARN("(%s): Cartridge of wrong type ?\n",
1486 device->cdev->dev.bus_id);
1487 return tape_3590_erp_basic(device, request, irb, -EMEDIUMTYPE);
1488
1489 case 0x8011:
1490 PRINT_WARN("(%s): Another host has reserved the tape device\n",
1491 device->cdev->dev.bus_id);
1492 return tape_3590_erp_basic(device, request, irb, -EPERM);
1493 case 0x8013:
1494 PRINT_WARN("(%s): Another host has priviliged access to the "
1495 "tape device\n", device->cdev->dev.bus_id);
1496 PRINT_WARN("(%s): To solve the problem unload the current "
1497 "cartridge!\n", device->cdev->dev.bus_id);
1498 return tape_3590_erp_basic(device, request, irb, -EPERM);
1499 default:
1500 return tape_3590_erp_basic(device, request, irb, -EIO);
1501 }
1502}
1503
1504/*
1505 * 3590 interrupt handler:
1506 */
1507static int
1508tape_3590_irq(struct tape_device *device, struct tape_request *request,
1509 struct irb *irb)
1510{
1511 if (request == NULL)
1512 return tape_3590_unsolicited_irq(device, irb);
1513
1514 if ((irb->scsw.dstat & DEV_STAT_UNIT_EXCEP) &&
1515 (irb->scsw.dstat & DEV_STAT_DEV_END) && (request->op == TO_WRI)) {
1516 /* Write at end of volume */
1517 DBF_EVENT(2, "End of volume\n");
1518 return tape_3590_erp_failed(device, request, irb, -ENOSPC);
1519 }
1520
1521 if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK)
1522 return tape_3590_unit_check(device, request, irb);
1523
1524 if (irb->scsw.dstat & DEV_STAT_DEV_END) {
1525 if (irb->scsw.dstat == DEV_STAT_UNIT_EXCEP) {
1526 if (request->op == TO_FSB || request->op == TO_BSB)
1527 request->rescnt++;
1528 else
1529 DBF_EVENT(5, "Unit Exception!\n");
1530 }
1531
1532 return tape_3590_done(device, request);
1533 }
1534
1535 if (irb->scsw.dstat & DEV_STAT_CHN_END) {
1536 DBF_EVENT(2, "cannel end\n");
1537 return TAPE_IO_PENDING;
1538 }
1539
1540 if (irb->scsw.dstat & DEV_STAT_ATTENTION) {
1541 DBF_EVENT(2, "Unit Attention when busy..\n");
1542 return TAPE_IO_PENDING;
1543 }
1544
1545 DBF_EVENT(6, "xunknownirq\n");
1546 PRINT_ERR("Unexpected interrupt.\n");
1547 PRINT_ERR("Current op is: %s", tape_op_verbose[request->op]);
1548 tape_dump_sense(device, request, irb);
1549 return TAPE_IO_STOP;
1550}
1551
1552/*
1553 * Setup device function
1554 */
1555static int
1556tape_3590_setup_device(struct tape_device *device)
1557{
1558 int rc;
1559 struct tape_3590_disc_data *data;
cced1dd4 1560 char *rdc_data;
b6cba4ee
SB		 1561
1562 DBF_EVENT(6, "3590 device setup\n");
cced1dd4 1563 data = kzalloc(sizeof(struct tape_3590_disc_data), GFP_KERNEL | GFP_DMA);
b6cba4ee
SB		 1564 if (data == NULL)
1565 return -ENOMEM;
1566 data->read_back_op = READ_PREVIOUS;
1567 device->discdata = data;
1568
cced1dd4
MH		 1569 rdc_data = kmalloc(64, GFP_KERNEL | GFP_DMA);
1570 if (!rdc_data) {
1571 rc = -ENOMEM;
1572 goto fail_kmalloc;
1573 }
1574 rc = read_dev_chars(device->cdev, (void**)&rdc_data, 64);
1575 if (rc) {
1576 DBF_LH(3, "Read device characteristics failed!\n");
1577 goto fail_kmalloc;
1578 }
1579 rc = tape_std_assign(device);
1580 if (rc)
1581 goto fail_rdc_data;
1582 if (rdc_data[31] == 0x13) {
1583 PRINT_INFO("Device has crypto support\n");
1584 data->crypt_info.capability |= TAPE390_CRYPT_SUPPORTED_MASK;
1585 tape_3592_disable_crypt(device);
1586 } else {
1587 DBF_EVENT(6, "Device has NO crypto support\n");
b6cba4ee 1588 }
cced1dd4
MH		 1589 /* Try to find out if medium is loaded */
1590 rc = tape_3590_sense_medium(device);
1591 if (rc) {
1592 DBF_LH(3, "3590 medium sense returned %d\n", rc);
1593 goto fail_rdc_data;
1594 }
1595 return 0;
b6cba4ee 1596
cced1dd4
MH		 1597fail_rdc_data:
1598 kfree(rdc_data);
1599fail_kmalloc:
1600 kfree(data);
b6cba4ee
SB		 1601 return rc;
1602}
1603
1604/*
1605 * Cleanup device function
1606 */
1607static void
1608tape_3590_cleanup_device(struct tape_device *device)
1609{
2cc924b8 1610 flush_scheduled_work();
b6cba4ee
SB		 1611 tape_std_unassign(device);
1612
1613 kfree(device->discdata);
1614 device->discdata = NULL;
1615}
1616
1617/*
1618 * List of 3590 magnetic tape commands.
1619 */
1620static tape_mtop_fn tape_3590_mtop[TAPE_NR_MTOPS] = {
1621 [MTRESET] = tape_std_mtreset,
1622 [MTFSF] = tape_std_mtfsf,
1623 [MTBSF] = tape_std_mtbsf,
1624 [MTFSR] = tape_std_mtfsr,
1625 [MTBSR] = tape_std_mtbsr,
1626 [MTWEOF] = tape_std_mtweof,
1627 [MTREW] = tape_std_mtrew,
1628 [MTOFFL] = tape_std_mtoffl,
1629 [MTNOP] = tape_std_mtnop,
1630 [MTRETEN] = tape_std_mtreten,
1631 [MTBSFM] = tape_std_mtbsfm,
1632 [MTFSFM] = tape_std_mtfsfm,
1633 [MTEOM] = tape_std_mteom,
1634 [MTERASE] = tape_std_mterase,
1635 [MTRAS1] = NULL,
1636 [MTRAS2] = NULL,
1637 [MTRAS3] = NULL,
1638 [MTSETBLK] = tape_std_mtsetblk,
1639 [MTSETDENSITY] = NULL,
1640 [MTSEEK] = tape_3590_mtseek,
1641 [MTTELL] = tape_3590_mttell,
1642 [MTSETDRVBUFFER] = NULL,
1643 [MTFSS] = NULL,
1644 [MTBSS] = NULL,
1645 [MTWSM] = NULL,
1646 [MTLOCK] = NULL,
1647 [MTUNLOCK] = NULL,
1648 [MTLOAD] = tape_std_mtload,
1649 [MTUNLOAD] = tape_std_mtunload,
1650 [MTCOMPRESSION] = tape_std_mtcompression,
1651 [MTSETPART] = NULL,
1652 [MTMKPART] = NULL
1653};
1654
1655/*
1656 * Tape discipline structure for 3590.
1657 */
1658static struct tape_discipline tape_discipline_3590 = {
1659 .owner = THIS_MODULE,
1660 .setup_device = tape_3590_setup_device,
1661 .cleanup_device = tape_3590_cleanup_device,
1662 .process_eov = tape_std_process_eov,
1663 .irq = tape_3590_irq,
1664 .read_block = tape_std_read_block,
1665 .write_block = tape_std_write_block,
1666#ifdef CONFIG_S390_TAPE_BLOCK
1667 .bread = tape_3590_bread,
1668 .free_bread = tape_3590_free_bread,
1669 .check_locate = tape_3590_check_locate,
1670#endif
1671 .ioctl_fn = tape_3590_ioctl,
1672 .mtop_array = tape_3590_mtop
1673};
1674
1675static struct ccw_device_id tape_3590_ids[] = {
1676 {CCW_DEVICE_DEVTYPE(0x3590, 0, 0x3590, 0), .driver_info = tape_3590},
2cc924b8 1677 {CCW_DEVICE_DEVTYPE(0x3592, 0, 0x3592, 0), .driver_info = tape_3592},
b6cba4ee
SB		 1678 { /* end of list */ }
1679};
1680
1681static int
1682tape_3590_online(struct ccw_device *cdev)
1683{
1684 return tape_generic_online(cdev->dev.driver_data,
1685 &tape_discipline_3590);
1686}
1687
1688static int
1689tape_3590_offline(struct ccw_device *cdev)
1690{
1691 return tape_generic_offline(cdev->dev.driver_data);
1692}
1693
1694static struct ccw_driver tape_3590_driver = {
1695 .name = "tape_3590",
1696 .owner = THIS_MODULE,
1697 .ids = tape_3590_ids,
1698 .probe = tape_generic_probe,
1699 .remove = tape_generic_remove,
1700 .set_offline = tape_3590_offline,
1701 .set_online = tape_3590_online,
1702};
1703
1704/*
1705 * Setup discipline structure.
1706 */
1707static int
1708tape_3590_init(void)
1709{
1710 int rc;
1711
1712 TAPE_DBF_AREA = debug_register("tape_3590", 2, 2, 4 * sizeof(long));
1713 debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
1714#ifdef DBF_LIKE_HELL
1715 debug_set_level(TAPE_DBF_AREA, 6);
1716#endif
1717
1718 DBF_EVENT(3, "3590 init\n");
1719 /* Register driver for 3590 tapes. */
1720 rc = ccw_driver_register(&tape_3590_driver);
1721 if (rc)
1722 DBF_EVENT(3, "3590 init failed\n");
1723 else
1724 DBF_EVENT(3, "3590 registered\n");
1725 return rc;
1726}
1727
1728static void
1729tape_3590_exit(void)
1730{
1731 ccw_driver_unregister(&tape_3590_driver);
1732
1733 debug_unregister(TAPE_DBF_AREA);
1734}
1735
1736MODULE_DEVICE_TABLE(ccw, tape_3590_ids);
1737MODULE_AUTHOR("(C) 2001,2006 IBM Corporation");
1738MODULE_DESCRIPTION("Linux on zSeries channel attached 3590 tape device driver");
1739MODULE_LICENSE("GPL");
1740
1741module_init(tape_3590_init);
1742module_exit(tape_3590_exit);
kernel source for telekom puls (alcatel/mediatek)