xref: /openbmc/linux/drivers/s390/char/tape_3590.c (revision 732a675a)
1 /*
2  *  drivers/s390/char/tape_3590.c
3  *    tape device discipline for 3590 tapes.
4  *
5  *    Copyright IBM Corp. 2001,2006
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 
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/bio.h>
14 #include <asm/ebcdic.h>
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  */
25 debug_info_t *TAPE_DBF_AREA = NULL;
26 EXPORT_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
34  * - Long Busy:			 implemented
35  * - Special Intercept:		 BRA
36  * - Read Alternate:		 implemented
37  *******************************************************************/
38 
39 #define PRINTK_HEADER "TAPE_3590: "
40 
41 static 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 
98 static int crypt_supported(struct tape_device *device)
99 {
100 	return TAPE390_CRYPT_SUPPORTED(TAPE_3590_CRYPT_INFO(device));
101 }
102 
103 static int crypt_enabled(struct tape_device *device)
104 {
105 	return TAPE390_CRYPT_ON(TAPE_3590_CRYPT_INFO(device));
106 }
107 
108 static 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 
124 static 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 
141 static 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 
162 static 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;
177 invalid:
178 	return -EINVAL;
179 }
180 
181 static 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;
189 invalid:
190 	return -EINVAL;
191 }
192 
193 /*
194  * Query KEKLs
195  */
196 static 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;
227 fail_request:
228 	tape_free_request(request);
229 fail_malloc:
230 	kfree(int_kekls);
231 	return rc;
232 }
233 
234 /*
235  * IOCTL: Query KEKLs
236  */
237 static 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;
259 fail:
260 	kfree(ext_kekls);
261 	return rc;
262 }
263 
264 static int tape_3590_mttell(struct tape_device *device, int mt_count);
265 
266 /*
267  * Set KEKLs
268  */
269 static 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  */
300 static 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);
319 out:
320 	kfree(ext_kekls);
321 	return rc;
322 }
323 
324 /*
325  * Enable encryption
326  */
327 static 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  */
358 static 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  */
387 static 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 
405 static int tape_3590_sense_medium(struct tape_device *device);
406 
407 /*
408  * IOCTL: Query enryption status
409  */
410 static 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 
424 /*
425  * 3590 IOCTL Overload
426  */
427 static int
428 tape_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 	}
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);
447 	default:
448 		return -EINVAL;	/* no additional ioctls */
449 	}
450 }
451 
452 /*
453  * SENSE Medium: Get Sense data about medium state
454  */
455 static int
456 tape_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  */
471 static int
472 tape_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  */
486 static int
487 tape_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  */
507 static void
508 tape_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  */
544 static int
545 tape_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  */
567 struct work_handler_data {
568 	struct tape_device *device;
569 	enum tape_op        op;
570 	struct work_struct  work;
571 };
572 
573 static void
574 tape_3590_work_handler(struct work_struct *work)
575 {
576 	struct work_handler_data *p =
577 		container_of(work, struct work_handler_data, work);
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;
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;
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 
600 static int
601 tape_3590_schedule_work(struct tape_device *device, enum tape_op op)
602 {
603 	struct work_handler_data *p;
604 
605 	if ((p = kzalloc(sizeof(*p), GFP_ATOMIC)) == NULL)
606 		return -ENOMEM;
607 
608 	INIT_WORK(&p->work, tape_3590_work_handler);
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  */
621 static struct tape_request *
622 tape_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;
627 	unsigned off;
628 	char *dst;
629 	struct bio_vec *bv;
630 	struct req_iterator iter;
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_segment(bv, req, iter)
637 		count += bv->bv_len >> (TAPEBLOCK_HSEC_S2B + 9);
638 
639 	request = tape_alloc_request(2 + count + 1, 4);
640 	if (IS_ERR(request))
641 		return request;
642 	request->op = TO_BLOCK;
643 	*(__u32 *) request->cpdata = start_block;
644 	ccw = request->cpaddr;
645 	ccw = tape_ccw_cc(ccw, MODE_SET_DB, 1, device->modeset_byte);
646 
647 	/*
648 	 * We always setup a nop after the mode set ccw. This slot is
649 	 * used in tape_std_check_locate to insert a locate ccw if the
650 	 * current tape position doesn't match the start block to be read.
651 	 */
652 	ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
653 
654 	rq_for_each_segment(bv, req, iter) {
655 		dst = page_address(bv->bv_page) + bv->bv_offset;
656 		for (off = 0; off < bv->bv_len; off += TAPEBLOCK_HSEC_SIZE) {
657 			ccw->flags = CCW_FLAG_CC;
658 			ccw->cmd_code = READ_FORWARD;
659 			ccw->count = TAPEBLOCK_HSEC_SIZE;
660 			set_normalized_cda(ccw, (void *) __pa(dst));
661 			ccw++;
662 			dst += TAPEBLOCK_HSEC_SIZE;
663 		}
664 		if (off > bv->bv_len)
665 			BUG();
666 	}
667 	ccw = tape_ccw_end(ccw, NOP, 0, NULL);
668 	DBF_EVENT(6, "xBREDccwg\n");
669 	return request;
670 }
671 
672 static void
673 tape_3590_free_bread(struct tape_request *request)
674 {
675 	struct ccw1 *ccw;
676 
677 	/* Last ccw is a nop and doesn't need clear_normalized_cda */
678 	for (ccw = request->cpaddr; ccw->flags & CCW_FLAG_CC; ccw++)
679 		if (ccw->cmd_code == READ_FORWARD)
680 			clear_normalized_cda(ccw);
681 	tape_free_request(request);
682 }
683 
684 /*
685  * check_locate is called just before the tape request is passed to
686  * the common io layer for execution. It has to check the current
687  * tape position and insert a locate ccw if it doesn't match the
688  * start block for the request.
689  */
690 static void
691 tape_3590_check_locate(struct tape_device *device, struct tape_request *request)
692 {
693 	__u32 *start_block;
694 
695 	start_block = (__u32 *) request->cpdata;
696 	if (*start_block != device->blk_data.block_position) {
697 		/* Add the start offset of the file to get the real block. */
698 		*start_block += device->bof;
699 		tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
700 	}
701 }
702 #endif
703 
704 static void tape_3590_med_state_set(struct tape_device *device,
705 				    struct tape_3590_med_sense *sense)
706 {
707 	struct tape390_crypt_info *c_info;
708 
709 	c_info = &TAPE_3590_CRYPT_INFO(device);
710 
711 	DBF_EVENT(6, "medium state: %x:%x\n", sense->macst, sense->masst);
712 	switch (sense->macst) {
713 	case 0x04:
714 	case 0x05:
715 	case 0x06:
716 		tape_med_state_set(device, MS_UNLOADED);
717 		TAPE_3590_CRYPT_INFO(device).medium_status = 0;
718 		return;
719 	case 0x08:
720 	case 0x09:
721 		tape_med_state_set(device, MS_LOADED);
722 		break;
723 	default:
724 		tape_med_state_set(device, MS_UNKNOWN);
725 		return;
726 	}
727 	c_info->medium_status |= TAPE390_MEDIUM_LOADED_MASK;
728 	if (sense->flags & MSENSE_CRYPT_MASK) {
729 		PRINT_INFO("Medium is encrypted (%04x)\n", sense->flags);
730 		c_info->medium_status |= TAPE390_MEDIUM_ENCRYPTED_MASK;
731 	} else	{
732 		DBF_EVENT(6, "Medium is not encrypted %04x\n", sense->flags);
733 		c_info->medium_status &= ~TAPE390_MEDIUM_ENCRYPTED_MASK;
734 	}
735 }
736 
737 /*
738  * The done handler is called at device/channel end and wakes up the sleeping
739  * process
740  */
741 static int
742 tape_3590_done(struct tape_device *device, struct tape_request *request)
743 {
744 	struct tape_3590_disc_data *disc_data;
745 
746 	DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
747 	disc_data = device->discdata;
748 
749 	switch (request->op) {
750 	case TO_BSB:
751 	case TO_BSF:
752 	case TO_DSE:
753 	case TO_FSB:
754 	case TO_FSF:
755 	case TO_LBL:
756 	case TO_RFO:
757 	case TO_RBA:
758 	case TO_REW:
759 	case TO_WRI:
760 	case TO_WTM:
761 	case TO_BLOCK:
762 	case TO_LOAD:
763 		tape_med_state_set(device, MS_LOADED);
764 		break;
765 	case TO_RUN:
766 		tape_med_state_set(device, MS_UNLOADED);
767 		tape_3590_schedule_work(device, TO_CRYPT_OFF);
768 		break;
769 	case TO_MSEN:
770 		tape_3590_med_state_set(device, request->cpdata);
771 		break;
772 	case TO_CRYPT_ON:
773 		TAPE_3590_CRYPT_INFO(device).status
774 			|= TAPE390_CRYPT_ON_MASK;
775 		*(device->modeset_byte) |= 0x03;
776 		break;
777 	case TO_CRYPT_OFF:
778 		TAPE_3590_CRYPT_INFO(device).status
779 			&= ~TAPE390_CRYPT_ON_MASK;
780 		*(device->modeset_byte) &= ~0x03;
781 		break;
782 	case TO_RBI:	/* RBI seems to succeed even without medium loaded. */
783 	case TO_NOP:	/* Same to NOP. */
784 	case TO_READ_CONFIG:
785 	case TO_READ_ATTMSG:
786 	case TO_DIS:
787 	case TO_ASSIGN:
788 	case TO_UNASSIGN:
789 	case TO_SIZE:
790 	case TO_KEKL_SET:
791 	case TO_KEKL_QUERY:
792 	case TO_RDC:
793 		break;
794 	}
795 	return TAPE_IO_SUCCESS;
796 }
797 
798 /*
799  * This fuction is called, when error recovery was successfull
800  */
801 static inline int
802 tape_3590_erp_succeded(struct tape_device *device, struct tape_request *request)
803 {
804 	DBF_EVENT(3, "Error Recovery successfull for %s\n",
805 		  tape_op_verbose[request->op]);
806 	return tape_3590_done(device, request);
807 }
808 
809 /*
810  * This fuction is called, when error recovery was not successfull
811  */
812 static inline int
813 tape_3590_erp_failed(struct tape_device *device, struct tape_request *request,
814 		     struct irb *irb, int rc)
815 {
816 	DBF_EVENT(3, "Error Recovery failed for %s\n",
817 		  tape_op_verbose[request->op]);
818 	tape_dump_sense_dbf(device, request, irb);
819 	return rc;
820 }
821 
822 /*
823  * Error Recovery do retry
824  */
825 static inline int
826 tape_3590_erp_retry(struct tape_device *device, struct tape_request *request,
827 		    struct irb *irb)
828 {
829 	DBF_EVENT(2, "Retry: %s\n", tape_op_verbose[request->op]);
830 	tape_dump_sense_dbf(device, request, irb);
831 	return TAPE_IO_RETRY;
832 }
833 
834 /*
835  * Handle unsolicited interrupts
836  */
837 static int
838 tape_3590_unsolicited_irq(struct tape_device *device, struct irb *irb)
839 {
840 	if (irb->scsw.dstat == DEV_STAT_CHN_END)
841 		/* Probably result of halt ssch */
842 		return TAPE_IO_PENDING;
843 	else if (irb->scsw.dstat == 0x85)
844 		/* Device Ready */
845 		DBF_EVENT(3, "unsol.irq! tape ready: %08x\n", device->cdev_id);
846 	else if (irb->scsw.dstat & DEV_STAT_ATTENTION) {
847 		tape_3590_schedule_work(device, TO_READ_ATTMSG);
848 	} else {
849 		DBF_EVENT(3, "unsol.irq! dev end: %08x\n", device->cdev_id);
850 		PRINT_WARN("Unsolicited IRQ (Device End) caught.\n");
851 		tape_dump_sense(device, NULL, irb);
852 	}
853 	/* check medium state */
854 	tape_3590_schedule_work(device, TO_MSEN);
855 	return TAPE_IO_SUCCESS;
856 }
857 
858 /*
859  * Basic Recovery routine
860  */
861 static int
862 tape_3590_erp_basic(struct tape_device *device, struct tape_request *request,
863 		    struct irb *irb, int rc)
864 {
865 	struct tape_3590_sense *sense;
866 
867 	sense = (struct tape_3590_sense *) irb->ecw;
868 
869 	switch (sense->bra) {
870 	case SENSE_BRA_PER:
871 		return tape_3590_erp_failed(device, request, irb, rc);
872 	case SENSE_BRA_CONT:
873 		return tape_3590_erp_succeded(device, request);
874 	case SENSE_BRA_RE:
875 		return tape_3590_erp_retry(device, request, irb);
876 	case SENSE_BRA_DRE:
877 		return tape_3590_erp_failed(device, request, irb, rc);
878 	default:
879 		PRINT_ERR("Unknown BRA %x - This should not happen!\n",
880 			  sense->bra);
881 		BUG();
882 		return TAPE_IO_STOP;
883 	}
884 }
885 
886 /*
887  *  RDL: Read Device (buffered) log
888  */
889 static int
890 tape_3590_erp_read_buf_log(struct tape_device *device,
891 			   struct tape_request *request, struct irb *irb)
892 {
893 	/*
894 	 * We just do the basic error recovery at the moment (retry).
895 	 * Perhaps in the future, we read the log and dump it somewhere...
896 	 */
897 	return tape_3590_erp_basic(device, request, irb, -EIO);
898 }
899 
900 /*
901  *  SWAP: Swap Devices
902  */
903 static int
904 tape_3590_erp_swap(struct tape_device *device, struct tape_request *request,
905 		   struct irb *irb)
906 {
907 	/*
908 	 * This error recovery should swap the tapes
909 	 * if the original has a problem. The operation
910 	 * should proceed with the new tape... this
911 	 * should probably be done in user space!
912 	 */
913 	PRINT_WARN("(%s): Swap Tape Device!\n", device->cdev->dev.bus_id);
914 	return tape_3590_erp_basic(device, request, irb, -EIO);
915 }
916 
917 /*
918  *  LBY: Long Busy
919  */
920 static int
921 tape_3590_erp_long_busy(struct tape_device *device,
922 			struct tape_request *request, struct irb *irb)
923 {
924 	DBF_EVENT(6, "Device is busy\n");
925 	return TAPE_IO_LONG_BUSY;
926 }
927 
928 /*
929  *  SPI: Special Intercept
930  */
931 static int
932 tape_3590_erp_special_interrupt(struct tape_device *device,
933 				struct tape_request *request, struct irb *irb)
934 {
935 	return tape_3590_erp_basic(device, request, irb, -EIO);
936 }
937 
938 /*
939  *  RDA: Read Alternate
940  */
941 static int
942 tape_3590_erp_read_alternate(struct tape_device *device,
943 			     struct tape_request *request, struct irb *irb)
944 {
945 	struct tape_3590_disc_data *data;
946 
947 	/*
948 	 * The issued Read Backward or Read Previous command is not
949 	 * supported by the device
950 	 * The recovery action should be to issue another command:
951 	 * Read Revious: if Read Backward is not supported
952 	 * Read Backward: if Read Previous is not supported
953 	 */
954 	data = device->discdata;
955 	if (data->read_back_op == READ_PREVIOUS) {
956 		DBF_EVENT(2, "(%08x): No support for READ_PREVIOUS command\n",
957 			  device->cdev_id);
958 		data->read_back_op = READ_BACKWARD;
959 	} else {
960 		DBF_EVENT(2, "(%08x): No support for READ_BACKWARD command\n",
961 			  device->cdev_id);
962 		data->read_back_op = READ_PREVIOUS;
963 	}
964 	tape_3590_read_opposite(device, request);
965 	return tape_3590_erp_retry(device, request, irb);
966 }
967 
968 /*
969  * Error Recovery read opposite
970  */
971 static int
972 tape_3590_erp_read_opposite(struct tape_device *device,
973 			    struct tape_request *request, struct irb *irb)
974 {
975 	switch (request->op) {
976 	case TO_RFO:
977 		/*
978 		 * We did read forward, but the data could not be read.
979 		 * We will read backward and then skip forward again.
980 		 */
981 		tape_3590_read_opposite(device, request);
982 		return tape_3590_erp_retry(device, request, irb);
983 	case TO_RBA:
984 		/* We tried to read forward and backward, but hat no success */
985 		return tape_3590_erp_failed(device, request, irb, -EIO);
986 		break;
987 	default:
988 		PRINT_WARN("read_opposite_recovery_called_with_op: %s\n",
989 			   tape_op_verbose[request->op]);
990 		return tape_3590_erp_failed(device, request, irb, -EIO);
991 	}
992 }
993 
994 /*
995  * Print an MIM (Media Information  Message) (message code f0)
996  */
997 static void
998 tape_3590_print_mim_msg_f0(struct tape_device *device, struct irb *irb)
999 {
1000 	struct tape_3590_sense *sense;
1001 
1002 	sense = (struct tape_3590_sense *) irb->ecw;
1003 	/* Exception Message */
1004 	switch (sense->fmt.f70.emc) {
1005 	case 0x02:
1006 		PRINT_WARN("(%s): Data degraded\n", device->cdev->dev.bus_id);
1007 		break;
1008 	case 0x03:
1009 		PRINT_WARN("(%s): Data degraded in partion %i\n",
1010 			   device->cdev->dev.bus_id, sense->fmt.f70.mp);
1011 		break;
1012 	case 0x04:
1013 		PRINT_WARN("(%s): Medium degraded\n", device->cdev->dev.bus_id);
1014 		break;
1015 	case 0x05:
1016 		PRINT_WARN("(%s): Medium degraded in partition %i\n",
1017 			   device->cdev->dev.bus_id, sense->fmt.f70.mp);
1018 		break;
1019 	case 0x06:
1020 		PRINT_WARN("(%s): Block 0 Error\n", device->cdev->dev.bus_id);
1021 		break;
1022 	case 0x07:
1023 		PRINT_WARN("(%s): Medium Exception 0x%02x\n",
1024 			   device->cdev->dev.bus_id, sense->fmt.f70.md);
1025 		break;
1026 	default:
1027 		PRINT_WARN("(%s): MIM ExMsg: 0x%02x\n",
1028 			   device->cdev->dev.bus_id, sense->fmt.f70.emc);
1029 		break;
1030 	}
1031 	/* Service Message */
1032 	switch (sense->fmt.f70.smc) {
1033 	case 0x02:
1034 		PRINT_WARN("(%s): Reference Media maintenance procedure %i\n",
1035 			   device->cdev->dev.bus_id, sense->fmt.f70.md);
1036 		break;
1037 	default:
1038 		PRINT_WARN("(%s): MIM ServiceMsg: 0x%02x\n",
1039 			   device->cdev->dev.bus_id, sense->fmt.f70.smc);
1040 		break;
1041 	}
1042 }
1043 
1044 /*
1045  * Print an I/O Subsystem Service Information Message (message code f1)
1046  */
1047 static void
1048 tape_3590_print_io_sim_msg_f1(struct tape_device *device, struct irb *irb)
1049 {
1050 	struct tape_3590_sense *sense;
1051 
1052 	sense = (struct tape_3590_sense *) irb->ecw;
1053 	/* Exception Message */
1054 	switch (sense->fmt.f71.emc) {
1055 	case 0x01:
1056 		PRINT_WARN("(%s): Effect of failure is unknown\n",
1057 			   device->cdev->dev.bus_id);
1058 		break;
1059 	case 0x02:
1060 		PRINT_WARN("(%s): CU Exception - no performance impact\n",
1061 			   device->cdev->dev.bus_id);
1062 		break;
1063 	case 0x03:
1064 		PRINT_WARN("(%s): CU Exception on channel interface 0x%02x\n",
1065 			   device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1066 		break;
1067 	case 0x04:
1068 		PRINT_WARN("(%s): CU Exception on device path 0x%02x\n",
1069 			   device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1070 		break;
1071 	case 0x05:
1072 		PRINT_WARN("(%s): CU Exception on library path 0x%02x\n",
1073 			   device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1074 		break;
1075 	case 0x06:
1076 		PRINT_WARN("(%s): CU Exception on node 0x%02x\n",
1077 			   device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1078 		break;
1079 	case 0x07:
1080 		PRINT_WARN("(%s): CU Exception on partition 0x%02x\n",
1081 			   device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1082 		break;
1083 	default:
1084 		PRINT_WARN("(%s): SIM ExMsg: 0x%02x\n",
1085 			   device->cdev->dev.bus_id, sense->fmt.f71.emc);
1086 	}
1087 	/* Service Message */
1088 	switch (sense->fmt.f71.smc) {
1089 	case 0x01:
1090 		PRINT_WARN("(%s): Repair impact is unknown\n",
1091 			   device->cdev->dev.bus_id);
1092 		break;
1093 	case 0x02:
1094 		PRINT_WARN("(%s): Repair will not impact cu performance\n",
1095 			   device->cdev->dev.bus_id);
1096 		break;
1097 	case 0x03:
1098 		if (sense->fmt.f71.mdf == 0)
1099 			PRINT_WARN("(%s): Repair will disable node "
1100 				   "0x%x on CU\n",
1101 				   device->cdev->dev.bus_id,
1102 				   sense->fmt.f71.md[1]);
1103 		else
1104 			PRINT_WARN("(%s): Repair will disable nodes "
1105 				   "(0x%x-0x%x) on CU\n",
1106 				   device->cdev->dev.bus_id,
1107 				   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1108 		break;
1109 	case 0x04:
1110 		if (sense->fmt.f71.mdf == 0)
1111 			PRINT_WARN("(%s): Repair will disable cannel path "
1112 				   "0x%x on CU\n",
1113 				   device->cdev->dev.bus_id,
1114 				   sense->fmt.f71.md[1]);
1115 		else
1116 			PRINT_WARN("(%s): Repair will disable cannel paths "
1117 				   "(0x%x-0x%x) on CU\n",
1118 				   device->cdev->dev.bus_id,
1119 				   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1120 		break;
1121 	case 0x05:
1122 		if (sense->fmt.f71.mdf == 0)
1123 			PRINT_WARN("(%s): Repair will disable device path "
1124 				   "0x%x on CU\n",
1125 				   device->cdev->dev.bus_id,
1126 				   sense->fmt.f71.md[1]);
1127 		else
1128 			PRINT_WARN("(%s): Repair will disable device paths "
1129 				   "(0x%x-0x%x) on CU\n",
1130 				   device->cdev->dev.bus_id,
1131 				   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1132 		break;
1133 	case 0x06:
1134 		if (sense->fmt.f71.mdf == 0)
1135 			PRINT_WARN("(%s): Repair will disable library path "
1136 				   "0x%x on CU\n",
1137 				   device->cdev->dev.bus_id,
1138 				   sense->fmt.f71.md[1]);
1139 		else
1140 			PRINT_WARN("(%s): Repair will disable library paths "
1141 				   "(0x%x-0x%x) on CU\n",
1142 				   device->cdev->dev.bus_id,
1143 				   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1144 		break;
1145 	case 0x07:
1146 		PRINT_WARN("(%s): Repair will disable access to CU\n",
1147 			   device->cdev->dev.bus_id);
1148 		break;
1149 	default:
1150 		PRINT_WARN("(%s): SIM ServiceMsg: 0x%02x\n",
1151 			   device->cdev->dev.bus_id, sense->fmt.f71.smc);
1152 	}
1153 }
1154 
1155 /*
1156  * Print an Device Subsystem Service Information Message (message code f2)
1157  */
1158 static void
1159 tape_3590_print_dev_sim_msg_f2(struct tape_device *device, struct irb *irb)
1160 {
1161 	struct tape_3590_sense *sense;
1162 
1163 	sense = (struct tape_3590_sense *) irb->ecw;
1164 	/* Exception Message */
1165 	switch (sense->fmt.f71.emc) {
1166 	case 0x01:
1167 		PRINT_WARN("(%s): Effect of failure is unknown\n",
1168 			   device->cdev->dev.bus_id);
1169 		break;
1170 	case 0x02:
1171 		PRINT_WARN("(%s): DV Exception - no performance impact\n",
1172 			   device->cdev->dev.bus_id);
1173 		break;
1174 	case 0x03:
1175 		PRINT_WARN("(%s): DV Exception on channel interface 0x%02x\n",
1176 			   device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1177 		break;
1178 	case 0x04:
1179 		PRINT_WARN("(%s): DV Exception on loader 0x%02x\n",
1180 			   device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1181 		break;
1182 	case 0x05:
1183 		PRINT_WARN("(%s): DV Exception on message display 0x%02x\n",
1184 			   device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
1185 		break;
1186 	case 0x06:
1187 		PRINT_WARN("(%s): DV Exception in tape path\n",
1188 			   device->cdev->dev.bus_id);
1189 		break;
1190 	case 0x07:
1191 		PRINT_WARN("(%s): DV Exception in drive\n",
1192 			   device->cdev->dev.bus_id);
1193 		break;
1194 	default:
1195 		PRINT_WARN("(%s): DSIM ExMsg: 0x%02x\n",
1196 			   device->cdev->dev.bus_id, sense->fmt.f71.emc);
1197 	}
1198 	/* Service Message */
1199 	switch (sense->fmt.f71.smc) {
1200 	case 0x01:
1201 		PRINT_WARN("(%s): Repair impact is unknown\n",
1202 			   device->cdev->dev.bus_id);
1203 		break;
1204 	case 0x02:
1205 		PRINT_WARN("(%s): Repair will not impact device performance\n",
1206 			   device->cdev->dev.bus_id);
1207 		break;
1208 	case 0x03:
1209 		if (sense->fmt.f71.mdf == 0)
1210 			PRINT_WARN("(%s): Repair will disable channel path "
1211 				   "0x%x on DV\n",
1212 				   device->cdev->dev.bus_id,
1213 				   sense->fmt.f71.md[1]);
1214 		else
1215 			PRINT_WARN("(%s): Repair will disable channel path "
1216 				   "(0x%x-0x%x) on DV\n",
1217 				   device->cdev->dev.bus_id,
1218 				   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1219 		break;
1220 	case 0x04:
1221 		if (sense->fmt.f71.mdf == 0)
1222 			PRINT_WARN("(%s): Repair will disable interface 0x%x "
1223 				   "on DV\n",
1224 				   device->cdev->dev.bus_id,
1225 				   sense->fmt.f71.md[1]);
1226 		else
1227 			PRINT_WARN("(%s): Repair will disable interfaces "
1228 				   "(0x%x-0x%x) on DV\n",
1229 				   device->cdev->dev.bus_id,
1230 				   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1231 		break;
1232 	case 0x05:
1233 		if (sense->fmt.f71.mdf == 0)
1234 			PRINT_WARN("(%s): Repair will disable loader 0x%x "
1235 				   "on DV\n",
1236 				   device->cdev->dev.bus_id,
1237 				   sense->fmt.f71.md[1]);
1238 		else
1239 			PRINT_WARN("(%s): Repair will disable loader "
1240 				   "(0x%x-0x%x) on DV\n",
1241 				   device->cdev->dev.bus_id,
1242 				   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1243 		break;
1244 	case 0x07:
1245 		PRINT_WARN("(%s): Repair will disable access to DV\n",
1246 			   device->cdev->dev.bus_id);
1247 		break;
1248 	case 0x08:
1249 		if (sense->fmt.f71.mdf == 0)
1250 			PRINT_WARN("(%s): Repair will disable message "
1251 				   "display 0x%x on DV\n",
1252 				   device->cdev->dev.bus_id,
1253 				   sense->fmt.f71.md[1]);
1254 		else
1255 			PRINT_WARN("(%s): Repair will disable message "
1256 				   "displays (0x%x-0x%x) on DV\n",
1257 				   device->cdev->dev.bus_id,
1258 				   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
1259 		break;
1260 	case 0x09:
1261 		PRINT_WARN("(%s): Clean DV\n", device->cdev->dev.bus_id);
1262 		break;
1263 	default:
1264 		PRINT_WARN("(%s): DSIM ServiceMsg: 0x%02x\n",
1265 			   device->cdev->dev.bus_id, sense->fmt.f71.smc);
1266 	}
1267 }
1268 
1269 /*
1270  * Print standard ERA Message
1271  */
1272 static void
1273 tape_3590_print_era_msg(struct tape_device *device, struct irb *irb)
1274 {
1275 	struct tape_3590_sense *sense;
1276 
1277 	sense = (struct tape_3590_sense *) irb->ecw;
1278 	if (sense->mc == 0)
1279 		return;
1280 	if ((sense->mc > 0) && (sense->mc < TAPE_3590_MAX_MSG)) {
1281 		if (tape_3590_msg[sense->mc] != NULL)
1282 			PRINT_WARN("(%s): %s\n", device->cdev->dev.bus_id,
1283 				   tape_3590_msg[sense->mc]);
1284 		else {
1285 			PRINT_WARN("(%s): Message Code 0x%x\n",
1286 				   device->cdev->dev.bus_id, sense->mc);
1287 		}
1288 		return;
1289 	}
1290 	if (sense->mc == 0xf0) {
1291 		/* Standard Media Information Message */
1292 		PRINT_WARN("(%s): MIM SEV=%i, MC=%02x, ES=%x/%x, "
1293 			   "RC=%02x-%04x-%02x\n", device->cdev->dev.bus_id,
1294 			   sense->fmt.f70.sev, sense->mc,
1295 			   sense->fmt.f70.emc, sense->fmt.f70.smc,
1296 			   sense->fmt.f70.refcode, sense->fmt.f70.mid,
1297 			   sense->fmt.f70.fid);
1298 		tape_3590_print_mim_msg_f0(device, irb);
1299 		return;
1300 	}
1301 	if (sense->mc == 0xf1) {
1302 		/* Standard I/O Subsystem Service Information Message */
1303 		PRINT_WARN("(%s): IOSIM SEV=%i, DEVTYPE=3590/%02x, "
1304 			   "MC=%02x, ES=%x/%x, REF=0x%04x-0x%04x-0x%04x\n",
1305 			   device->cdev->dev.bus_id, sense->fmt.f71.sev,
1306 			   device->cdev->id.dev_model,
1307 			   sense->mc, sense->fmt.f71.emc,
1308 			   sense->fmt.f71.smc, sense->fmt.f71.refcode1,
1309 			   sense->fmt.f71.refcode2, sense->fmt.f71.refcode3);
1310 		tape_3590_print_io_sim_msg_f1(device, irb);
1311 		return;
1312 	}
1313 	if (sense->mc == 0xf2) {
1314 		/* Standard Device Service Information Message */
1315 		PRINT_WARN("(%s): DEVSIM SEV=%i, DEVTYPE=3590/%02x, "
1316 			   "MC=%02x, ES=%x/%x, REF=0x%04x-0x%04x-0x%04x\n",
1317 			   device->cdev->dev.bus_id, sense->fmt.f71.sev,
1318 			   device->cdev->id.dev_model,
1319 			   sense->mc, sense->fmt.f71.emc,
1320 			   sense->fmt.f71.smc, sense->fmt.f71.refcode1,
1321 			   sense->fmt.f71.refcode2, sense->fmt.f71.refcode3);
1322 		tape_3590_print_dev_sim_msg_f2(device, irb);
1323 		return;
1324 	}
1325 	if (sense->mc == 0xf3) {
1326 		/* Standard Library Service Information Message */
1327 		return;
1328 	}
1329 	PRINT_WARN("(%s): Device Message(%x)\n",
1330 		   device->cdev->dev.bus_id, sense->mc);
1331 }
1332 
1333 static int tape_3590_crypt_error(struct tape_device *device,
1334 				 struct tape_request *request, struct irb *irb)
1335 {
1336 	u8 cu_rc, ekm_rc1;
1337 	u16 ekm_rc2;
1338 	u32 drv_rc;
1339 	char *bus_id, *sense;
1340 
1341 	sense = ((struct tape_3590_sense *) irb->ecw)->fmt.data;
1342 	bus_id = device->cdev->dev.bus_id;
1343 	cu_rc = sense[0];
1344 	drv_rc = *((u32*) &sense[5]) & 0xffffff;
1345 	ekm_rc1 = sense[9];
1346 	ekm_rc2 = *((u16*) &sense[10]);
1347 	if ((cu_rc == 0) && (ekm_rc2 == 0xee31))
1348 		/* key not defined on EKM */
1349 		return tape_3590_erp_basic(device, request, irb, -EKEYREJECTED);
1350 	if ((cu_rc == 1) || (cu_rc == 2))
1351 		/* No connection to EKM */
1352 		return tape_3590_erp_basic(device, request, irb, -ENOTCONN);
1353 
1354 	PRINT_ERR("(%s): Unable to get encryption key from EKM\n", bus_id);
1355 	PRINT_ERR("(%s): CU=%02X DRIVE=%06X EKM=%02X:%04X\n", bus_id, cu_rc,
1356 		drv_rc, ekm_rc1, ekm_rc2);
1357 
1358 	return tape_3590_erp_basic(device, request, irb, -ENOKEY);
1359 }
1360 
1361 /*
1362  *  3590 error Recovery routine:
1363  *  If possible, it tries to recover from the error. If this is not possible,
1364  *  inform the user about the problem.
1365  */
1366 static int
1367 tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
1368 		     struct irb *irb)
1369 {
1370 	struct tape_3590_sense *sense;
1371 	int rc;
1372 
1373 #ifdef CONFIG_S390_TAPE_BLOCK
1374 	if (request->op == TO_BLOCK) {
1375 		/*
1376 		 * Recovery for block device requests. Set the block_position
1377 		 * to something invalid and retry.
1378 		 */
1379 		device->blk_data.block_position = -1;
1380 		if (request->retries-- <= 0)
1381 			return tape_3590_erp_failed(device, request, irb, -EIO);
1382 		else
1383 			return tape_3590_erp_retry(device, request, irb);
1384 	}
1385 #endif
1386 
1387 	sense = (struct tape_3590_sense *) irb->ecw;
1388 
1389 	DBF_EVENT(6, "Unit Check: RQC = %x\n", sense->rc_rqc);
1390 
1391 	/*
1392 	 * First check all RC-QRCs where we want to do something special
1393 	 *   - "break":     basic error recovery is done
1394 	 *   - "goto out:": just print error message if available
1395 	 */
1396 	rc = -EIO;
1397 	switch (sense->rc_rqc) {
1398 
1399 	case 0x1110:
1400 		tape_3590_print_era_msg(device, irb);
1401 		return tape_3590_erp_read_buf_log(device, request, irb);
1402 
1403 	case 0x2011:
1404 		tape_3590_print_era_msg(device, irb);
1405 		return tape_3590_erp_read_alternate(device, request, irb);
1406 
1407 	case 0x2230:
1408 	case 0x2231:
1409 		tape_3590_print_era_msg(device, irb);
1410 		return tape_3590_erp_special_interrupt(device, request, irb);
1411 	case 0x2240:
1412 		return tape_3590_crypt_error(device, request, irb);
1413 
1414 	case 0x3010:
1415 		DBF_EVENT(2, "(%08x): Backward at Beginning of Partition\n",
1416 			  device->cdev_id);
1417 		return tape_3590_erp_basic(device, request, irb, -ENOSPC);
1418 	case 0x3012:
1419 		DBF_EVENT(2, "(%08x): Forward at End of Partition\n",
1420 			  device->cdev_id);
1421 		return tape_3590_erp_basic(device, request, irb, -ENOSPC);
1422 	case 0x3020:
1423 		DBF_EVENT(2, "(%08x): End of Data Mark\n", device->cdev_id);
1424 		return tape_3590_erp_basic(device, request, irb, -ENOSPC);
1425 
1426 	case 0x3122:
1427 		DBF_EVENT(2, "(%08x): Rewind Unload initiated\n",
1428 			  device->cdev_id);
1429 		return tape_3590_erp_basic(device, request, irb, -EIO);
1430 	case 0x3123:
1431 		DBF_EVENT(2, "(%08x): Rewind Unload complete\n",
1432 			  device->cdev_id);
1433 		tape_med_state_set(device, MS_UNLOADED);
1434 		tape_3590_schedule_work(device, TO_CRYPT_OFF);
1435 		return tape_3590_erp_basic(device, request, irb, 0);
1436 
1437 	case 0x4010:
1438 		/*
1439 		 * print additional msg since default msg
1440 		 * "device intervention" is not very meaningfull
1441 		 */
1442 		PRINT_WARN("(%s): Tape operation when medium not loaded\n",
1443 			   device->cdev->dev.bus_id);
1444 		tape_med_state_set(device, MS_UNLOADED);
1445 		tape_3590_schedule_work(device, TO_CRYPT_OFF);
1446 		return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
1447 	case 0x4012:		/* Device Long Busy */
1448 		/* XXX: Also use long busy handling here? */
1449 		DBF_EVENT(6, "(%08x): LONG BUSY\n", device->cdev_id);
1450 		tape_3590_print_era_msg(device, irb);
1451 		return tape_3590_erp_basic(device, request, irb, -EBUSY);
1452 	case 0x4014:
1453 		DBF_EVENT(6, "(%08x): Crypto LONG BUSY\n", device->cdev_id);
1454 		return tape_3590_erp_long_busy(device, request, irb);
1455 
1456 	case 0x5010:
1457 		if (sense->rac == 0xd0) {
1458 			/* Swap */
1459 			tape_3590_print_era_msg(device, irb);
1460 			return tape_3590_erp_swap(device, request, irb);
1461 		}
1462 		if (sense->rac == 0x26) {
1463 			/* Read Opposite */
1464 			tape_3590_print_era_msg(device, irb);
1465 			return tape_3590_erp_read_opposite(device, request,
1466 							   irb);
1467 		}
1468 		return tape_3590_erp_basic(device, request, irb, -EIO);
1469 	case 0x5020:
1470 	case 0x5021:
1471 	case 0x5022:
1472 	case 0x5040:
1473 	case 0x5041:
1474 	case 0x5042:
1475 		tape_3590_print_era_msg(device, irb);
1476 		return tape_3590_erp_swap(device, request, irb);
1477 
1478 	case 0x5110:
1479 	case 0x5111:
1480 		return tape_3590_erp_basic(device, request, irb, -EMEDIUMTYPE);
1481 
1482 	case 0x5120:
1483 	case 0x1120:
1484 		tape_med_state_set(device, MS_UNLOADED);
1485 		tape_3590_schedule_work(device, TO_CRYPT_OFF);
1486 		return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
1487 
1488 	case 0x6020:
1489 		PRINT_WARN("(%s): Cartridge of wrong type ?\n",
1490 			   device->cdev->dev.bus_id);
1491 		return tape_3590_erp_basic(device, request, irb, -EMEDIUMTYPE);
1492 
1493 	case 0x8011:
1494 		PRINT_WARN("(%s): Another host has reserved the tape device\n",
1495 			   device->cdev->dev.bus_id);
1496 		return tape_3590_erp_basic(device, request, irb, -EPERM);
1497 	case 0x8013:
1498 		PRINT_WARN("(%s): Another host has privileged access to the "
1499 			   "tape device\n", device->cdev->dev.bus_id);
1500 		PRINT_WARN("(%s): To solve the problem unload the current "
1501 			   "cartridge!\n", device->cdev->dev.bus_id);
1502 		return tape_3590_erp_basic(device, request, irb, -EPERM);
1503 	default:
1504 		return tape_3590_erp_basic(device, request, irb, -EIO);
1505 	}
1506 }
1507 
1508 /*
1509  * 3590 interrupt handler:
1510  */
1511 static int
1512 tape_3590_irq(struct tape_device *device, struct tape_request *request,
1513 	      struct irb *irb)
1514 {
1515 	if (request == NULL)
1516 		return tape_3590_unsolicited_irq(device, irb);
1517 
1518 	if ((irb->scsw.dstat & DEV_STAT_UNIT_EXCEP) &&
1519 	    (irb->scsw.dstat & DEV_STAT_DEV_END) && (request->op == TO_WRI)) {
1520 		/* Write at end of volume */
1521 		DBF_EVENT(2, "End of volume\n");
1522 		return tape_3590_erp_failed(device, request, irb, -ENOSPC);
1523 	}
1524 
1525 	if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK)
1526 		return tape_3590_unit_check(device, request, irb);
1527 
1528 	if (irb->scsw.dstat & DEV_STAT_DEV_END) {
1529 		if (irb->scsw.dstat == DEV_STAT_UNIT_EXCEP) {
1530 			if (request->op == TO_FSB || request->op == TO_BSB)
1531 				request->rescnt++;
1532 			else
1533 				DBF_EVENT(5, "Unit Exception!\n");
1534 		}
1535 
1536 		return tape_3590_done(device, request);
1537 	}
1538 
1539 	if (irb->scsw.dstat & DEV_STAT_CHN_END) {
1540 		DBF_EVENT(2, "cannel end\n");
1541 		return TAPE_IO_PENDING;
1542 	}
1543 
1544 	if (irb->scsw.dstat & DEV_STAT_ATTENTION) {
1545 		DBF_EVENT(2, "Unit Attention when busy..\n");
1546 		return TAPE_IO_PENDING;
1547 	}
1548 
1549 	DBF_EVENT(6, "xunknownirq\n");
1550 	PRINT_ERR("Unexpected interrupt.\n");
1551 	PRINT_ERR("Current op is: %s", tape_op_verbose[request->op]);
1552 	tape_dump_sense(device, request, irb);
1553 	return TAPE_IO_STOP;
1554 }
1555 
1556 
1557 static int tape_3590_read_dev_chars(struct tape_device *device,
1558 				    struct tape_3590_rdc_data *rdc_data)
1559 {
1560 	int rc;
1561 	struct tape_request *request;
1562 
1563 	request = tape_alloc_request(1, sizeof(*rdc_data));
1564 	if (IS_ERR(request))
1565 		return PTR_ERR(request);
1566 	request->op = TO_RDC;
1567 	tape_ccw_end(request->cpaddr, CCW_CMD_RDC, sizeof(*rdc_data),
1568 		     request->cpdata);
1569 	rc = tape_do_io(device, request);
1570 	if (rc == 0)
1571 		memcpy(rdc_data, request->cpdata, sizeof(*rdc_data));
1572 	tape_free_request(request);
1573 	return rc;
1574 }
1575 
1576 /*
1577  * Setup device function
1578  */
1579 static int
1580 tape_3590_setup_device(struct tape_device *device)
1581 {
1582 	int rc;
1583 	struct tape_3590_disc_data *data;
1584 	struct tape_3590_rdc_data *rdc_data;
1585 
1586 	DBF_EVENT(6, "3590 device setup\n");
1587 	data = kzalloc(sizeof(struct tape_3590_disc_data), GFP_KERNEL | GFP_DMA);
1588 	if (data == NULL)
1589 		return -ENOMEM;
1590 	data->read_back_op = READ_PREVIOUS;
1591 	device->discdata = data;
1592 
1593 	rdc_data = kmalloc(sizeof(*rdc_data), GFP_KERNEL | GFP_DMA);
1594 	if (!rdc_data) {
1595 		rc = -ENOMEM;
1596 		goto fail_kmalloc;
1597 	}
1598 	rc = tape_3590_read_dev_chars(device, rdc_data);
1599 	if (rc) {
1600 		DBF_LH(3, "Read device characteristics failed!\n");
1601 		goto fail_rdc_data;
1602 	}
1603 	rc = tape_std_assign(device);
1604 	if (rc)
1605 		goto fail_rdc_data;
1606 	if (rdc_data->data[31] == 0x13) {
1607 		PRINT_INFO("Device has crypto support\n");
1608 		data->crypt_info.capability |= TAPE390_CRYPT_SUPPORTED_MASK;
1609 		tape_3592_disable_crypt(device);
1610 	} else {
1611 		DBF_EVENT(6, "Device has NO crypto support\n");
1612 	}
1613 	/* Try to find out if medium is loaded */
1614 	rc = tape_3590_sense_medium(device);
1615 	if (rc) {
1616 		DBF_LH(3, "3590 medium sense returned %d\n", rc);
1617 		goto fail_rdc_data;
1618 	}
1619 	return 0;
1620 
1621 fail_rdc_data:
1622 	kfree(rdc_data);
1623 fail_kmalloc:
1624 	kfree(data);
1625 	return rc;
1626 }
1627 
1628 /*
1629  * Cleanup device function
1630  */
1631 static void
1632 tape_3590_cleanup_device(struct tape_device *device)
1633 {
1634 	flush_scheduled_work();
1635 	tape_std_unassign(device);
1636 
1637 	kfree(device->discdata);
1638 	device->discdata = NULL;
1639 }
1640 
1641 /*
1642  * List of 3590 magnetic tape commands.
1643  */
1644 static tape_mtop_fn tape_3590_mtop[TAPE_NR_MTOPS] = {
1645 	[MTRESET]	 = tape_std_mtreset,
1646 	[MTFSF]		 = tape_std_mtfsf,
1647 	[MTBSF]		 = tape_std_mtbsf,
1648 	[MTFSR]		 = tape_std_mtfsr,
1649 	[MTBSR]		 = tape_std_mtbsr,
1650 	[MTWEOF]	 = tape_std_mtweof,
1651 	[MTREW]		 = tape_std_mtrew,
1652 	[MTOFFL]	 = tape_std_mtoffl,
1653 	[MTNOP]		 = tape_std_mtnop,
1654 	[MTRETEN]	 = tape_std_mtreten,
1655 	[MTBSFM]	 = tape_std_mtbsfm,
1656 	[MTFSFM]	 = tape_std_mtfsfm,
1657 	[MTEOM]		 = tape_std_mteom,
1658 	[MTERASE]	 = tape_std_mterase,
1659 	[MTRAS1]	 = NULL,
1660 	[MTRAS2]	 = NULL,
1661 	[MTRAS3]	 = NULL,
1662 	[MTSETBLK]	 = tape_std_mtsetblk,
1663 	[MTSETDENSITY]	 = NULL,
1664 	[MTSEEK]	 = tape_3590_mtseek,
1665 	[MTTELL]	 = tape_3590_mttell,
1666 	[MTSETDRVBUFFER] = NULL,
1667 	[MTFSS]		 = NULL,
1668 	[MTBSS]		 = NULL,
1669 	[MTWSM]		 = NULL,
1670 	[MTLOCK]	 = NULL,
1671 	[MTUNLOCK]	 = NULL,
1672 	[MTLOAD]	 = tape_std_mtload,
1673 	[MTUNLOAD]	 = tape_std_mtunload,
1674 	[MTCOMPRESSION]	 = tape_std_mtcompression,
1675 	[MTSETPART]	 = NULL,
1676 	[MTMKPART]	 = NULL
1677 };
1678 
1679 /*
1680  * Tape discipline structure for 3590.
1681  */
1682 static struct tape_discipline tape_discipline_3590 = {
1683 	.owner = THIS_MODULE,
1684 	.setup_device = tape_3590_setup_device,
1685 	.cleanup_device = tape_3590_cleanup_device,
1686 	.process_eov = tape_std_process_eov,
1687 	.irq = tape_3590_irq,
1688 	.read_block = tape_std_read_block,
1689 	.write_block = tape_std_write_block,
1690 #ifdef CONFIG_S390_TAPE_BLOCK
1691 	.bread = tape_3590_bread,
1692 	.free_bread = tape_3590_free_bread,
1693 	.check_locate = tape_3590_check_locate,
1694 #endif
1695 	.ioctl_fn = tape_3590_ioctl,
1696 	.mtop_array = tape_3590_mtop
1697 };
1698 
1699 static struct ccw_device_id tape_3590_ids[] = {
1700 	{CCW_DEVICE_DEVTYPE(0x3590, 0, 0x3590, 0), .driver_info = tape_3590},
1701 	{CCW_DEVICE_DEVTYPE(0x3592, 0, 0x3592, 0), .driver_info = tape_3592},
1702 	{ /* end of list */ }
1703 };
1704 
1705 static int
1706 tape_3590_online(struct ccw_device *cdev)
1707 {
1708 	return tape_generic_online(cdev->dev.driver_data,
1709 				   &tape_discipline_3590);
1710 }
1711 
1712 static int
1713 tape_3590_offline(struct ccw_device *cdev)
1714 {
1715 	return tape_generic_offline(cdev->dev.driver_data);
1716 }
1717 
1718 static struct ccw_driver tape_3590_driver = {
1719 	.name = "tape_3590",
1720 	.owner = THIS_MODULE,
1721 	.ids = tape_3590_ids,
1722 	.probe = tape_generic_probe,
1723 	.remove = tape_generic_remove,
1724 	.set_offline = tape_3590_offline,
1725 	.set_online = tape_3590_online,
1726 };
1727 
1728 /*
1729  * Setup discipline structure.
1730  */
1731 static int
1732 tape_3590_init(void)
1733 {
1734 	int rc;
1735 
1736 	TAPE_DBF_AREA = debug_register("tape_3590", 2, 2, 4 * sizeof(long));
1737 	debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
1738 #ifdef DBF_LIKE_HELL
1739 	debug_set_level(TAPE_DBF_AREA, 6);
1740 #endif
1741 
1742 	DBF_EVENT(3, "3590 init\n");
1743 	/* Register driver for 3590 tapes. */
1744 	rc = ccw_driver_register(&tape_3590_driver);
1745 	if (rc)
1746 		DBF_EVENT(3, "3590 init failed\n");
1747 	else
1748 		DBF_EVENT(3, "3590 registered\n");
1749 	return rc;
1750 }
1751 
1752 static void
1753 tape_3590_exit(void)
1754 {
1755 	ccw_driver_unregister(&tape_3590_driver);
1756 
1757 	debug_unregister(TAPE_DBF_AREA);
1758 }
1759 
1760 MODULE_DEVICE_TABLE(ccw, tape_3590_ids);
1761 MODULE_AUTHOR("(C) 2001,2006 IBM Corporation");
1762 MODULE_DESCRIPTION("Linux on zSeries channel attached 3590 tape device driver");
1763 MODULE_LICENSE("GPL");
1764 
1765 module_init(tape_3590_init);
1766 module_exit(tape_3590_exit);
1767