1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Author(s)......: Horst  Hummel    <Horst.Hummel@de.ibm.com>
4  *		    Holger Smolinski <Holger.Smolinski@de.ibm.com>
5  * Bugreports.to..: <Linux390@de.ibm.com>
6  * Copyright IBM Corp. 2000, 2001
7  *
8  */
9 
10 #define KMSG_COMPONENT "dasd-eckd"
11 
12 #include <linux/timer.h>
13 #include <asm/idals.h>
14 
15 #define PRINTK_HEADER "dasd_erp(3990): "
16 
17 #include "dasd_int.h"
18 #include "dasd_eckd.h"
19 
20 
21 struct DCTL_data {
22 	unsigned char subcommand;  /* e.g Inhibit Write, Enable Write,... */
23 	unsigned char modifier;	   /* Subcommand modifier */
24 	unsigned short res;	   /* reserved */
25 } __attribute__ ((packed));
26 
27 /*
28  *****************************************************************************
29  * SECTION ERP HANDLING
30  *****************************************************************************
31  */
32 /*
33  *****************************************************************************
34  * 24 and 32 byte sense ERP functions
35  *****************************************************************************
36  */
37 
38 /*
39  * DASD_3990_ERP_CLEANUP
40  *
41  * DESCRIPTION
42  *   Removes the already build but not necessary ERP request and sets
43  *   the status of the original cqr / erp to the given (final) status
44  *
45  *  PARAMETER
46  *   erp		request to be blocked
47  *   final_status	either DASD_CQR_DONE or DASD_CQR_FAILED
48  *
49  * RETURN VALUES
50  *   cqr		original cqr
51  */
52 static struct dasd_ccw_req *
53 dasd_3990_erp_cleanup(struct dasd_ccw_req * erp, char final_status)
54 {
55 	struct dasd_ccw_req *cqr = erp->refers;
56 
57 	dasd_free_erp_request(erp, erp->memdev);
58 	cqr->status = final_status;
59 	return cqr;
60 
61 }				/* end dasd_3990_erp_cleanup */
62 
63 /*
64  * DASD_3990_ERP_BLOCK_QUEUE
65  *
66  * DESCRIPTION
67  *   Block the given device request queue to prevent from further
68  *   processing until the started timer has expired or an related
69  *   interrupt was received.
70  */
71 static void dasd_3990_erp_block_queue(struct dasd_ccw_req *erp, int expires)
72 {
73 
74 	struct dasd_device *device = erp->startdev;
75 	unsigned long flags;
76 
77 	DBF_DEV_EVENT(DBF_INFO, device,
78 		    "blocking request queue for %is", expires/HZ);
79 
80 	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
81 	dasd_device_set_stop_bits(device, DASD_STOPPED_PENDING);
82 	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
83 	erp->status = DASD_CQR_FILLED;
84 	if (erp->block)
85 		dasd_block_set_timer(erp->block, expires);
86 	else
87 		dasd_device_set_timer(device, expires);
88 }
89 
90 /*
91  * DASD_3990_ERP_INT_REQ
92  *
93  * DESCRIPTION
94  *   Handles 'Intervention Required' error.
95  *   This means either device offline or not installed.
96  *
97  * PARAMETER
98  *   erp		current erp
99  * RETURN VALUES
100  *   erp		modified erp
101  */
102 static struct dasd_ccw_req *
103 dasd_3990_erp_int_req(struct dasd_ccw_req * erp)
104 {
105 
106 	struct dasd_device *device = erp->startdev;
107 
108 	/* first time set initial retry counter and erp_function */
109 	/* and retry once without blocking queue		 */
110 	/* (this enables easier enqueing of the cqr)		 */
111 	if (erp->function != dasd_3990_erp_int_req) {
112 
113 		erp->retries = 256;
114 		erp->function = dasd_3990_erp_int_req;
115 
116 	} else {
117 
118 		/* issue a message and wait for 'device ready' interrupt */
119 		dev_err(&device->cdev->dev,
120 			    "is offline or not installed - "
121 			    "INTERVENTION REQUIRED!!\n");
122 
123 		dasd_3990_erp_block_queue(erp, 60*HZ);
124 	}
125 
126 	return erp;
127 
128 }				/* end dasd_3990_erp_int_req */
129 
130 /*
131  * DASD_3990_ERP_ALTERNATE_PATH
132  *
133  * DESCRIPTION
134  *   Repeat the operation on a different channel path.
135  *   If all alternate paths have been tried, the request is posted with a
136  *   permanent error.
137  *
138  *  PARAMETER
139  *   erp		pointer to the current ERP
140  *
141  * RETURN VALUES
142  *   erp		modified pointer to the ERP
143  */
144 static void
145 dasd_3990_erp_alternate_path(struct dasd_ccw_req * erp)
146 {
147 	struct dasd_device *device = erp->startdev;
148 	__u8 opm;
149 	unsigned long flags;
150 
151 	/* try alternate valid path */
152 	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
153 	opm = ccw_device_get_path_mask(device->cdev);
154 	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
155 	if (erp->lpm == 0)
156 		erp->lpm = dasd_path_get_opm(device) &
157 			~(erp->irb.esw.esw0.sublog.lpum);
158 	else
159 		erp->lpm &= ~(erp->irb.esw.esw0.sublog.lpum);
160 
161 	if ((erp->lpm & opm) != 0x00) {
162 
163 		DBF_DEV_EVENT(DBF_WARNING, device,
164 			    "try alternate lpm=%x (lpum=%x / opm=%x)",
165 			    erp->lpm, erp->irb.esw.esw0.sublog.lpum, opm);
166 
167 		/* reset status to submit the request again... */
168 		erp->status = DASD_CQR_FILLED;
169 		erp->retries = 10;
170 	} else {
171 		dev_err(&device->cdev->dev,
172 			"The DASD cannot be reached on any path (lpum=%x"
173 			"/opm=%x)\n", erp->irb.esw.esw0.sublog.lpum, opm);
174 
175 		/* post request with permanent error */
176 		erp->status = DASD_CQR_FAILED;
177 	}
178 }				/* end dasd_3990_erp_alternate_path */
179 
180 /*
181  * DASD_3990_ERP_DCTL
182  *
183  * DESCRIPTION
184  *   Setup cqr to do the Diagnostic Control (DCTL) command with an
185  *   Inhibit Write subcommand (0x20) and the given modifier.
186  *
187  *  PARAMETER
188  *   erp		pointer to the current (failed) ERP
189  *   modifier		subcommand modifier
190  *
191  * RETURN VALUES
192  *   dctl_cqr		pointer to NEW dctl_cqr
193  *
194  */
195 static struct dasd_ccw_req *
196 dasd_3990_erp_DCTL(struct dasd_ccw_req * erp, char modifier)
197 {
198 
199 	struct dasd_device *device = erp->startdev;
200 	struct DCTL_data *DCTL_data;
201 	struct ccw1 *ccw;
202 	struct dasd_ccw_req *dctl_cqr;
203 
204 	dctl_cqr = dasd_alloc_erp_request((char *) &erp->magic, 1,
205 					  sizeof(struct DCTL_data),
206 					  device);
207 	if (IS_ERR(dctl_cqr)) {
208 		dev_err(&device->cdev->dev,
209 			    "Unable to allocate DCTL-CQR\n");
210 		erp->status = DASD_CQR_FAILED;
211 		return erp;
212 	}
213 
214 	DCTL_data = dctl_cqr->data;
215 
216 	DCTL_data->subcommand = 0x02;	/* Inhibit Write */
217 	DCTL_data->modifier = modifier;
218 
219 	ccw = dctl_cqr->cpaddr;
220 	memset(ccw, 0, sizeof(struct ccw1));
221 	ccw->cmd_code = CCW_CMD_DCTL;
222 	ccw->count = 4;
223 	ccw->cda = (__u32)(addr_t) DCTL_data;
224 	dctl_cqr->flags = erp->flags;
225 	dctl_cqr->function = dasd_3990_erp_DCTL;
226 	dctl_cqr->refers = erp;
227 	dctl_cqr->startdev = device;
228 	dctl_cqr->memdev = device;
229 	dctl_cqr->magic = erp->magic;
230 	dctl_cqr->expires = 5 * 60 * HZ;
231 	dctl_cqr->retries = 2;
232 
233 	dctl_cqr->buildclk = get_tod_clock();
234 
235 	dctl_cqr->status = DASD_CQR_FILLED;
236 
237 	return dctl_cqr;
238 
239 }				/* end dasd_3990_erp_DCTL */
240 
241 /*
242  * DASD_3990_ERP_ACTION_1
243  *
244  * DESCRIPTION
245  *   Setup ERP to do the ERP action 1 (see Reference manual).
246  *   Repeat the operation on a different channel path.
247  *   As deviation from the recommended recovery action, we reset the path mask
248  *   after we have tried each path and go through all paths a second time.
249  *   This will cover situations where only one path at a time is actually down,
250  *   but all paths fail and recover just with the same sequence and timing as
251  *   we try to use them (flapping links).
252  *   If all alternate paths have been tried twice, the request is posted with
253  *   a permanent error.
254  *
255  *  PARAMETER
256  *   erp		pointer to the current ERP
257  *
258  * RETURN VALUES
259  *   erp		pointer to the ERP
260  *
261  */
262 static struct dasd_ccw_req *dasd_3990_erp_action_1_sec(struct dasd_ccw_req *erp)
263 {
264 	erp->function = dasd_3990_erp_action_1_sec;
265 	dasd_3990_erp_alternate_path(erp);
266 	return erp;
267 }
268 
269 static struct dasd_ccw_req *dasd_3990_erp_action_1(struct dasd_ccw_req *erp)
270 {
271 	erp->function = dasd_3990_erp_action_1;
272 	dasd_3990_erp_alternate_path(erp);
273 	if (erp->status == DASD_CQR_FAILED &&
274 	    !test_bit(DASD_CQR_VERIFY_PATH, &erp->flags)) {
275 		erp->status = DASD_CQR_FILLED;
276 		erp->retries = 10;
277 		erp->lpm = dasd_path_get_opm(erp->startdev);
278 		erp->function = dasd_3990_erp_action_1_sec;
279 	}
280 	return erp;
281 }				/* end dasd_3990_erp_action_1(b) */
282 
283 /*
284  * DASD_3990_ERP_ACTION_4
285  *
286  * DESCRIPTION
287  *   Setup ERP to do the ERP action 4 (see Reference manual).
288  *   Set the current request to PENDING to block the CQR queue for that device
289  *   until the state change interrupt appears.
290  *   Use a timer (20 seconds) to retry the cqr if the interrupt is still
291  *   missing.
292  *
293  *  PARAMETER
294  *   sense		sense data of the actual error
295  *   erp		pointer to the current ERP
296  *
297  * RETURN VALUES
298  *   erp		pointer to the ERP
299  *
300  */
301 static struct dasd_ccw_req *
302 dasd_3990_erp_action_4(struct dasd_ccw_req * erp, char *sense)
303 {
304 
305 	struct dasd_device *device = erp->startdev;
306 
307 	/* first time set initial retry counter and erp_function    */
308 	/* and retry once without waiting for state change pending  */
309 	/* interrupt (this enables easier enqueing of the cqr)	    */
310 	if (erp->function != dasd_3990_erp_action_4) {
311 
312 		DBF_DEV_EVENT(DBF_INFO, device, "%s",
313 			    "dasd_3990_erp_action_4: first time retry");
314 
315 		erp->retries = 256;
316 		erp->function = dasd_3990_erp_action_4;
317 
318 	} else {
319 		if (sense && (sense[25] == 0x1D)) { /* state change pending */
320 
321 			DBF_DEV_EVENT(DBF_INFO, device,
322 				    "waiting for state change pending "
323 				    "interrupt, %d retries left",
324 				    erp->retries);
325 
326 			dasd_3990_erp_block_queue(erp, 30*HZ);
327 
328 		} else if (sense && (sense[25] == 0x1E)) {	/* busy */
329 			DBF_DEV_EVENT(DBF_INFO, device,
330 				    "busy - redriving request later, "
331 				    "%d retries left",
332 				    erp->retries);
333                         dasd_3990_erp_block_queue(erp, HZ);
334 		} else {
335 			/* no state change pending - retry */
336 			DBF_DEV_EVENT(DBF_INFO, device,
337 				     "redriving request immediately, "
338 				     "%d retries left",
339 				     erp->retries);
340 			erp->status = DASD_CQR_FILLED;
341 		}
342 	}
343 
344 	return erp;
345 
346 }				/* end dasd_3990_erp_action_4 */
347 
348 /*
349  *****************************************************************************
350  * 24 byte sense ERP functions (only)
351  *****************************************************************************
352  */
353 
354 /*
355  * DASD_3990_ERP_ACTION_5
356  *
357  * DESCRIPTION
358  *   Setup ERP to do the ERP action 5 (see Reference manual).
359  *   NOTE: Further handling is done in xxx_further_erp after the retries.
360  *
361  *  PARAMETER
362  *   erp		pointer to the current ERP
363  *
364  * RETURN VALUES
365  *   erp		pointer to the ERP
366  *
367  */
368 static struct dasd_ccw_req *
369 dasd_3990_erp_action_5(struct dasd_ccw_req * erp)
370 {
371 
372 	/* first of all retry */
373 	erp->retries = 10;
374 	erp->function = dasd_3990_erp_action_5;
375 
376 	return erp;
377 
378 }				/* end dasd_3990_erp_action_5 */
379 
380 /*
381  * DASD_3990_HANDLE_ENV_DATA
382  *
383  * DESCRIPTION
384  *   Handles 24 byte 'Environmental data present'.
385  *   Does a analysis of the sense data (message Format)
386  *   and prints the error messages.
387  *
388  * PARAMETER
389  *   sense		current sense data
390  *
391  * RETURN VALUES
392  *   void
393  */
394 static void
395 dasd_3990_handle_env_data(struct dasd_ccw_req * erp, char *sense)
396 {
397 
398 	struct dasd_device *device = erp->startdev;
399 	char msg_format = (sense[7] & 0xF0);
400 	char msg_no = (sense[7] & 0x0F);
401 	char errorstring[ERRORLENGTH];
402 
403 	switch (msg_format) {
404 	case 0x00:		/* Format 0 - Program or System Checks */
405 
406 		if (sense[1] & 0x10) {	/* check message to operator bit */
407 
408 			switch (msg_no) {
409 			case 0x00:	/* No Message */
410 				break;
411 			case 0x01:
412 				dev_warn(&device->cdev->dev,
413 					    "FORMAT 0 - Invalid Command\n");
414 				break;
415 			case 0x02:
416 				dev_warn(&device->cdev->dev,
417 					    "FORMAT 0 - Invalid Command "
418 					    "Sequence\n");
419 				break;
420 			case 0x03:
421 				dev_warn(&device->cdev->dev,
422 					    "FORMAT 0 - CCW Count less than "
423 					    "required\n");
424 				break;
425 			case 0x04:
426 				dev_warn(&device->cdev->dev,
427 					    "FORMAT 0 - Invalid Parameter\n");
428 				break;
429 			case 0x05:
430 				dev_warn(&device->cdev->dev,
431 					    "FORMAT 0 - Diagnostic of Special"
432 					    " Command Violates File Mask\n");
433 				break;
434 			case 0x07:
435 				dev_warn(&device->cdev->dev,
436 					    "FORMAT 0 - Channel Returned with "
437 					    "Incorrect retry CCW\n");
438 				break;
439 			case 0x08:
440 				dev_warn(&device->cdev->dev,
441 					    "FORMAT 0 - Reset Notification\n");
442 				break;
443 			case 0x09:
444 				dev_warn(&device->cdev->dev,
445 					 "FORMAT 0 - Storage Path Restart\n");
446 				break;
447 			case 0x0A:
448 				dev_warn(&device->cdev->dev,
449 					    "FORMAT 0 - Channel requested "
450 					    "... %02x\n", sense[8]);
451 				break;
452 			case 0x0B:
453 				dev_warn(&device->cdev->dev,
454 					    "FORMAT 0 - Invalid Defective/"
455 					    "Alternate Track Pointer\n");
456 				break;
457 			case 0x0C:
458 				dev_warn(&device->cdev->dev,
459 					    "FORMAT 0 - DPS Installation "
460 					    "Check\n");
461 				break;
462 			case 0x0E:
463 				dev_warn(&device->cdev->dev,
464 					    "FORMAT 0 - Command Invalid on "
465 					    "Secondary Address\n");
466 				break;
467 			case 0x0F:
468 				dev_warn(&device->cdev->dev,
469 					    "FORMAT 0 - Status Not As "
470 					    "Required: reason %02x\n",
471 					 sense[8]);
472 				break;
473 			default:
474 				dev_warn(&device->cdev->dev,
475 					    "FORMAT 0 - Reserved\n");
476 			}
477 		} else {
478 			switch (msg_no) {
479 			case 0x00:	/* No Message */
480 				break;
481 			case 0x01:
482 				dev_warn(&device->cdev->dev,
483 					 "FORMAT 0 - Device Error "
484 					 "Source\n");
485 				break;
486 			case 0x02:
487 				dev_warn(&device->cdev->dev,
488 					    "FORMAT 0 - Reserved\n");
489 				break;
490 			case 0x03:
491 				dev_warn(&device->cdev->dev,
492 					    "FORMAT 0 - Device Fenced - "
493 					    "device = %02x\n", sense[4]);
494 				break;
495 			case 0x04:
496 				dev_warn(&device->cdev->dev,
497 					    "FORMAT 0 - Data Pinned for "
498 					    "Device\n");
499 				break;
500 			default:
501 				dev_warn(&device->cdev->dev,
502 					    "FORMAT 0 - Reserved\n");
503 			}
504 		}
505 		break;
506 
507 	case 0x10:		/* Format 1 - Device Equipment Checks */
508 		switch (msg_no) {
509 		case 0x00:	/* No Message */
510 			break;
511 		case 0x01:
512 			dev_warn(&device->cdev->dev,
513 				    "FORMAT 1 - Device Status 1 not as "
514 				    "expected\n");
515 			break;
516 		case 0x03:
517 			dev_warn(&device->cdev->dev,
518 				    "FORMAT 1 - Index missing\n");
519 			break;
520 		case 0x04:
521 			dev_warn(&device->cdev->dev,
522 				 "FORMAT 1 - Interruption cannot be "
523 				 "reset\n");
524 			break;
525 		case 0x05:
526 			dev_warn(&device->cdev->dev,
527 				    "FORMAT 1 - Device did not respond to "
528 				    "selection\n");
529 			break;
530 		case 0x06:
531 			dev_warn(&device->cdev->dev,
532 				    "FORMAT 1 - Device check-2 error or Set "
533 				    "Sector is not complete\n");
534 			break;
535 		case 0x07:
536 			dev_warn(&device->cdev->dev,
537 				    "FORMAT 1 - Head address does not "
538 				    "compare\n");
539 			break;
540 		case 0x08:
541 			dev_warn(&device->cdev->dev,
542 				    "FORMAT 1 - Device status 1 not valid\n");
543 			break;
544 		case 0x09:
545 			dev_warn(&device->cdev->dev,
546 				    "FORMAT 1 - Device not ready\n");
547 			break;
548 		case 0x0A:
549 			dev_warn(&device->cdev->dev,
550 				    "FORMAT 1 - Track physical address did "
551 				    "not compare\n");
552 			break;
553 		case 0x0B:
554 			dev_warn(&device->cdev->dev,
555 				    "FORMAT 1 - Missing device address bit\n");
556 			break;
557 		case 0x0C:
558 			dev_warn(&device->cdev->dev,
559 				    "FORMAT 1 - Drive motor switch is off\n");
560 			break;
561 		case 0x0D:
562 			dev_warn(&device->cdev->dev,
563 				    "FORMAT 1 - Seek incomplete\n");
564 			break;
565 		case 0x0E:
566 			dev_warn(&device->cdev->dev,
567 				    "FORMAT 1 - Cylinder address did not "
568 				    "compare\n");
569 			break;
570 		case 0x0F:
571 			dev_warn(&device->cdev->dev,
572 				    "FORMAT 1 - Offset active cannot be "
573 				    "reset\n");
574 			break;
575 		default:
576 			dev_warn(&device->cdev->dev,
577 				    "FORMAT 1 - Reserved\n");
578 		}
579 		break;
580 
581 	case 0x20:		/* Format 2 - 3990 Equipment Checks */
582 		switch (msg_no) {
583 		case 0x08:
584 			dev_warn(&device->cdev->dev,
585 				    "FORMAT 2 - 3990 check-2 error\n");
586 			break;
587 		case 0x0E:
588 			dev_warn(&device->cdev->dev,
589 				    "FORMAT 2 - Support facility errors\n");
590 			break;
591 		case 0x0F:
592 			dev_warn(&device->cdev->dev,
593 				 "FORMAT 2 - Microcode detected error "
594 				 "%02x\n",
595 				 sense[8]);
596 			break;
597 		default:
598 			dev_warn(&device->cdev->dev,
599 				    "FORMAT 2 - Reserved\n");
600 		}
601 		break;
602 
603 	case 0x30:		/* Format 3 - 3990 Control Checks */
604 		switch (msg_no) {
605 		case 0x0F:
606 			dev_warn(&device->cdev->dev,
607 				    "FORMAT 3 - Allegiance terminated\n");
608 			break;
609 		default:
610 			dev_warn(&device->cdev->dev,
611 				    "FORMAT 3 - Reserved\n");
612 		}
613 		break;
614 
615 	case 0x40:		/* Format 4 - Data Checks */
616 		switch (msg_no) {
617 		case 0x00:
618 			dev_warn(&device->cdev->dev,
619 				    "FORMAT 4 - Home address area error\n");
620 			break;
621 		case 0x01:
622 			dev_warn(&device->cdev->dev,
623 				    "FORMAT 4 - Count area error\n");
624 			break;
625 		case 0x02:
626 			dev_warn(&device->cdev->dev,
627 				    "FORMAT 4 - Key area error\n");
628 			break;
629 		case 0x03:
630 			dev_warn(&device->cdev->dev,
631 				    "FORMAT 4 - Data area error\n");
632 			break;
633 		case 0x04:
634 			dev_warn(&device->cdev->dev,
635 				    "FORMAT 4 - No sync byte in home address "
636 				    "area\n");
637 			break;
638 		case 0x05:
639 			dev_warn(&device->cdev->dev,
640 				    "FORMAT 4 - No sync byte in count address "
641 				    "area\n");
642 			break;
643 		case 0x06:
644 			dev_warn(&device->cdev->dev,
645 				    "FORMAT 4 - No sync byte in key area\n");
646 			break;
647 		case 0x07:
648 			dev_warn(&device->cdev->dev,
649 				    "FORMAT 4 - No sync byte in data area\n");
650 			break;
651 		case 0x08:
652 			dev_warn(&device->cdev->dev,
653 				    "FORMAT 4 - Home address area error; "
654 				    "offset active\n");
655 			break;
656 		case 0x09:
657 			dev_warn(&device->cdev->dev,
658 				    "FORMAT 4 - Count area error; offset "
659 				    "active\n");
660 			break;
661 		case 0x0A:
662 			dev_warn(&device->cdev->dev,
663 				    "FORMAT 4 - Key area error; offset "
664 				    "active\n");
665 			break;
666 		case 0x0B:
667 			dev_warn(&device->cdev->dev,
668 				    "FORMAT 4 - Data area error; "
669 				    "offset active\n");
670 			break;
671 		case 0x0C:
672 			dev_warn(&device->cdev->dev,
673 				    "FORMAT 4 - No sync byte in home "
674 				    "address area; offset active\n");
675 			break;
676 		case 0x0D:
677 			dev_warn(&device->cdev->dev,
678 				    "FORMAT 4 - No sync byte in count "
679 				    "address area; offset active\n");
680 			break;
681 		case 0x0E:
682 			dev_warn(&device->cdev->dev,
683 				    "FORMAT 4 - No sync byte in key area; "
684 				    "offset active\n");
685 			break;
686 		case 0x0F:
687 			dev_warn(&device->cdev->dev,
688 				    "FORMAT 4 - No sync byte in data area; "
689 				    "offset active\n");
690 			break;
691 		default:
692 			dev_warn(&device->cdev->dev,
693 				    "FORMAT 4 - Reserved\n");
694 		}
695 		break;
696 
697 	case 0x50:  /* Format 5 - Data Check with displacement information */
698 		switch (msg_no) {
699 		case 0x00:
700 			dev_warn(&device->cdev->dev,
701 				    "FORMAT 5 - Data Check in the "
702 				    "home address area\n");
703 			break;
704 		case 0x01:
705 			dev_warn(&device->cdev->dev,
706 				 "FORMAT 5 - Data Check in the count "
707 				 "area\n");
708 			break;
709 		case 0x02:
710 			dev_warn(&device->cdev->dev,
711 				    "FORMAT 5 - Data Check in the key area\n");
712 			break;
713 		case 0x03:
714 			dev_warn(&device->cdev->dev,
715 				 "FORMAT 5 - Data Check in the data "
716 				 "area\n");
717 			break;
718 		case 0x08:
719 			dev_warn(&device->cdev->dev,
720 				    "FORMAT 5 - Data Check in the "
721 				    "home address area; offset active\n");
722 			break;
723 		case 0x09:
724 			dev_warn(&device->cdev->dev,
725 				    "FORMAT 5 - Data Check in the count area; "
726 				    "offset active\n");
727 			break;
728 		case 0x0A:
729 			dev_warn(&device->cdev->dev,
730 				    "FORMAT 5 - Data Check in the key area; "
731 				    "offset active\n");
732 			break;
733 		case 0x0B:
734 			dev_warn(&device->cdev->dev,
735 				    "FORMAT 5 - Data Check in the data area; "
736 				    "offset active\n");
737 			break;
738 		default:
739 			dev_warn(&device->cdev->dev,
740 				    "FORMAT 5 - Reserved\n");
741 		}
742 		break;
743 
744 	case 0x60:  /* Format 6 - Usage Statistics/Overrun Errors */
745 		switch (msg_no) {
746 		case 0x00:
747 			dev_warn(&device->cdev->dev,
748 				    "FORMAT 6 - Overrun on channel A\n");
749 			break;
750 		case 0x01:
751 			dev_warn(&device->cdev->dev,
752 				    "FORMAT 6 - Overrun on channel B\n");
753 			break;
754 		case 0x02:
755 			dev_warn(&device->cdev->dev,
756 				    "FORMAT 6 - Overrun on channel C\n");
757 			break;
758 		case 0x03:
759 			dev_warn(&device->cdev->dev,
760 				    "FORMAT 6 - Overrun on channel D\n");
761 			break;
762 		case 0x04:
763 			dev_warn(&device->cdev->dev,
764 				    "FORMAT 6 - Overrun on channel E\n");
765 			break;
766 		case 0x05:
767 			dev_warn(&device->cdev->dev,
768 				    "FORMAT 6 - Overrun on channel F\n");
769 			break;
770 		case 0x06:
771 			dev_warn(&device->cdev->dev,
772 				    "FORMAT 6 - Overrun on channel G\n");
773 			break;
774 		case 0x07:
775 			dev_warn(&device->cdev->dev,
776 				    "FORMAT 6 - Overrun on channel H\n");
777 			break;
778 		default:
779 			dev_warn(&device->cdev->dev,
780 				    "FORMAT 6 - Reserved\n");
781 		}
782 		break;
783 
784 	case 0x70:  /* Format 7 - Device Connection Control Checks */
785 		switch (msg_no) {
786 		case 0x00:
787 			dev_warn(&device->cdev->dev,
788 				    "FORMAT 7 - RCC initiated by a connection "
789 				    "check alert\n");
790 			break;
791 		case 0x01:
792 			dev_warn(&device->cdev->dev,
793 				    "FORMAT 7 - RCC 1 sequence not "
794 				    "successful\n");
795 			break;
796 		case 0x02:
797 			dev_warn(&device->cdev->dev,
798 				    "FORMAT 7 - RCC 1 and RCC 2 sequences not "
799 				    "successful\n");
800 			break;
801 		case 0x03:
802 			dev_warn(&device->cdev->dev,
803 				    "FORMAT 7 - Invalid tag-in during "
804 				    "selection sequence\n");
805 			break;
806 		case 0x04:
807 			dev_warn(&device->cdev->dev,
808 				    "FORMAT 7 - extra RCC required\n");
809 			break;
810 		case 0x05:
811 			dev_warn(&device->cdev->dev,
812 				    "FORMAT 7 - Invalid DCC selection "
813 				    "response or timeout\n");
814 			break;
815 		case 0x06:
816 			dev_warn(&device->cdev->dev,
817 				    "FORMAT 7 - Missing end operation; device "
818 				    "transfer complete\n");
819 			break;
820 		case 0x07:
821 			dev_warn(&device->cdev->dev,
822 				    "FORMAT 7 - Missing end operation; device "
823 				    "transfer incomplete\n");
824 			break;
825 		case 0x08:
826 			dev_warn(&device->cdev->dev,
827 				    "FORMAT 7 - Invalid tag-in for an "
828 				    "immediate command sequence\n");
829 			break;
830 		case 0x09:
831 			dev_warn(&device->cdev->dev,
832 				    "FORMAT 7 - Invalid tag-in for an "
833 				    "extended command sequence\n");
834 			break;
835 		case 0x0A:
836 			dev_warn(&device->cdev->dev,
837 				    "FORMAT 7 - 3990 microcode time out when "
838 				    "stopping selection\n");
839 			break;
840 		case 0x0B:
841 			dev_warn(&device->cdev->dev,
842 				    "FORMAT 7 - No response to selection "
843 				    "after a poll interruption\n");
844 			break;
845 		case 0x0C:
846 			dev_warn(&device->cdev->dev,
847 				    "FORMAT 7 - Permanent path error (DASD "
848 				    "controller not available)\n");
849 			break;
850 		case 0x0D:
851 			dev_warn(&device->cdev->dev,
852 				    "FORMAT 7 - DASD controller not available"
853 				    " on disconnected command chain\n");
854 			break;
855 		default:
856 			dev_warn(&device->cdev->dev,
857 				    "FORMAT 7 - Reserved\n");
858 		}
859 		break;
860 
861 	case 0x80:  /* Format 8 - Additional Device Equipment Checks */
862 		switch (msg_no) {
863 		case 0x00:	/* No Message */
864 		case 0x01:
865 			dev_warn(&device->cdev->dev,
866 				    "FORMAT 8 - Error correction code "
867 				    "hardware fault\n");
868 			break;
869 		case 0x03:
870 			dev_warn(&device->cdev->dev,
871 				    "FORMAT 8 - Unexpected end operation "
872 				    "response code\n");
873 			break;
874 		case 0x04:
875 			dev_warn(&device->cdev->dev,
876 				    "FORMAT 8 - End operation with transfer "
877 				    "count not zero\n");
878 			break;
879 		case 0x05:
880 			dev_warn(&device->cdev->dev,
881 				    "FORMAT 8 - End operation with transfer "
882 				    "count zero\n");
883 			break;
884 		case 0x06:
885 			dev_warn(&device->cdev->dev,
886 				    "FORMAT 8 - DPS checks after a system "
887 				    "reset or selective reset\n");
888 			break;
889 		case 0x07:
890 			dev_warn(&device->cdev->dev,
891 				    "FORMAT 8 - DPS cannot be filled\n");
892 			break;
893 		case 0x08:
894 			dev_warn(&device->cdev->dev,
895 				    "FORMAT 8 - Short busy time-out during "
896 				    "device selection\n");
897 			break;
898 		case 0x09:
899 			dev_warn(&device->cdev->dev,
900 				    "FORMAT 8 - DASD controller failed to "
901 				    "set or reset the long busy latch\n");
902 			break;
903 		case 0x0A:
904 			dev_warn(&device->cdev->dev,
905 				    "FORMAT 8 - No interruption from device "
906 				    "during a command chain\n");
907 			break;
908 		default:
909 			dev_warn(&device->cdev->dev,
910 				    "FORMAT 8 - Reserved\n");
911 		}
912 		break;
913 
914 	case 0x90:  /* Format 9 - Device Read, Write, and Seek Checks */
915 		switch (msg_no) {
916 		case 0x00:
917 			break;	/* No Message */
918 		case 0x06:
919 			dev_warn(&device->cdev->dev,
920 				    "FORMAT 9 - Device check-2 error\n");
921 			break;
922 		case 0x07:
923 			dev_warn(&device->cdev->dev,
924 				 "FORMAT 9 - Head address did not "
925 				 "compare\n");
926 			break;
927 		case 0x0A:
928 			dev_warn(&device->cdev->dev,
929 				    "FORMAT 9 - Track physical address did "
930 				    "not compare while oriented\n");
931 			break;
932 		case 0x0E:
933 			dev_warn(&device->cdev->dev,
934 				    "FORMAT 9 - Cylinder address did not "
935 				    "compare\n");
936 			break;
937 		default:
938 			dev_warn(&device->cdev->dev,
939 				    "FORMAT 9 - Reserved\n");
940 		}
941 		break;
942 
943 	case 0xF0:		/* Format F - Cache Storage Checks */
944 		switch (msg_no) {
945 		case 0x00:
946 			dev_warn(&device->cdev->dev,
947 				    "FORMAT F - Operation Terminated\n");
948 			break;
949 		case 0x01:
950 			dev_warn(&device->cdev->dev,
951 				    "FORMAT F - Subsystem Processing Error\n");
952 			break;
953 		case 0x02:
954 			dev_warn(&device->cdev->dev,
955 				    "FORMAT F - Cache or nonvolatile storage "
956 				    "equipment failure\n");
957 			break;
958 		case 0x04:
959 			dev_warn(&device->cdev->dev,
960 				    "FORMAT F - Caching terminated\n");
961 			break;
962 		case 0x06:
963 			dev_warn(&device->cdev->dev,
964 				    "FORMAT F - Cache fast write access not "
965 				    "authorized\n");
966 			break;
967 		case 0x07:
968 			dev_warn(&device->cdev->dev,
969 				    "FORMAT F - Track format incorrect\n");
970 			break;
971 		case 0x09:
972 			dev_warn(&device->cdev->dev,
973 				    "FORMAT F - Caching reinitiated\n");
974 			break;
975 		case 0x0A:
976 			dev_warn(&device->cdev->dev,
977 				    "FORMAT F - Nonvolatile storage "
978 				    "terminated\n");
979 			break;
980 		case 0x0B:
981 			dev_warn(&device->cdev->dev,
982 				    "FORMAT F - Volume is suspended duplex\n");
983 			/* call extended error reporting (EER) */
984 			dasd_eer_write(device, erp->refers,
985 				       DASD_EER_PPRCSUSPEND);
986 			break;
987 		case 0x0C:
988 			dev_warn(&device->cdev->dev,
989 				    "FORMAT F - Subsystem status cannot be "
990 				    "determined\n");
991 			break;
992 		case 0x0D:
993 			dev_warn(&device->cdev->dev,
994 				    "FORMAT F - Caching status reset to "
995 				    "default\n");
996 			break;
997 		case 0x0E:
998 			dev_warn(&device->cdev->dev,
999 				    "FORMAT F - DASD Fast Write inhibited\n");
1000 			break;
1001 		default:
1002 			dev_warn(&device->cdev->dev,
1003 				    "FORMAT F - Reserved\n");
1004 		}
1005 		break;
1006 
1007 	default:	/* unknown message format - should not happen
1008 			   internal error 03 - unknown message format */
1009 		snprintf(errorstring, ERRORLENGTH, "03 %x02", msg_format);
1010 		dev_err(&device->cdev->dev,
1011 			 "An error occurred in the DASD device driver, "
1012 			 "reason=%s\n", errorstring);
1013 		break;
1014 	}			/* end switch message format */
1015 
1016 }				/* end dasd_3990_handle_env_data */
1017 
1018 /*
1019  * DASD_3990_ERP_COM_REJ
1020  *
1021  * DESCRIPTION
1022  *   Handles 24 byte 'Command Reject' error.
1023  *
1024  * PARAMETER
1025  *   erp		current erp_head
1026  *   sense		current sense data
1027  *
1028  * RETURN VALUES
1029  *   erp		'new' erp_head - pointer to new ERP
1030  */
1031 static struct dasd_ccw_req *
1032 dasd_3990_erp_com_rej(struct dasd_ccw_req * erp, char *sense)
1033 {
1034 
1035 	struct dasd_device *device = erp->startdev;
1036 
1037 	erp->function = dasd_3990_erp_com_rej;
1038 
1039 	/* env data present (ACTION 10 - retry should work) */
1040 	if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1041 
1042 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1043 			    "Command Reject - environmental data present");
1044 
1045 		dasd_3990_handle_env_data(erp, sense);
1046 
1047 		erp->retries = 5;
1048 
1049 	} else if (sense[1] & SNS1_WRITE_INHIBITED) {
1050 		dev_err(&device->cdev->dev, "An I/O request was rejected"
1051 			" because writing is inhibited\n");
1052 		erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
1053 	} else {
1054 		/* fatal error -  set status to FAILED
1055 		   internal error 09 - Command Reject */
1056 		if (!test_bit(DASD_CQR_SUPPRESS_CR, &erp->flags))
1057 			dev_err(&device->cdev->dev,
1058 				"An error occurred in the DASD device driver, reason=09\n");
1059 
1060 		erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
1061 	}
1062 
1063 	return erp;
1064 
1065 }				/* end dasd_3990_erp_com_rej */
1066 
1067 /*
1068  * DASD_3990_ERP_BUS_OUT
1069  *
1070  * DESCRIPTION
1071  *   Handles 24 byte 'Bus Out Parity Check' error.
1072  *
1073  * PARAMETER
1074  *   erp		current erp_head
1075  * RETURN VALUES
1076  *   erp		new erp_head - pointer to new ERP
1077  */
1078 static struct dasd_ccw_req *
1079 dasd_3990_erp_bus_out(struct dasd_ccw_req * erp)
1080 {
1081 
1082 	struct dasd_device *device = erp->startdev;
1083 
1084 	/* first time set initial retry counter and erp_function */
1085 	/* and retry once without blocking queue		 */
1086 	/* (this enables easier enqueing of the cqr)		 */
1087 	if (erp->function != dasd_3990_erp_bus_out) {
1088 		erp->retries = 256;
1089 		erp->function = dasd_3990_erp_bus_out;
1090 
1091 	} else {
1092 
1093 		/* issue a message and wait for 'device ready' interrupt */
1094 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1095 			    "bus out parity error or BOPC requested by "
1096 			    "channel");
1097 
1098 		dasd_3990_erp_block_queue(erp, 60*HZ);
1099 
1100 	}
1101 
1102 	return erp;
1103 
1104 }				/* end dasd_3990_erp_bus_out */
1105 
1106 /*
1107  * DASD_3990_ERP_EQUIP_CHECK
1108  *
1109  * DESCRIPTION
1110  *   Handles 24 byte 'Equipment Check' error.
1111  *
1112  * PARAMETER
1113  *   erp		current erp_head
1114  * RETURN VALUES
1115  *   erp		new erp_head - pointer to new ERP
1116  */
1117 static struct dasd_ccw_req *
1118 dasd_3990_erp_equip_check(struct dasd_ccw_req * erp, char *sense)
1119 {
1120 
1121 	struct dasd_device *device = erp->startdev;
1122 
1123 	erp->function = dasd_3990_erp_equip_check;
1124 
1125 	if (sense[1] & SNS1_WRITE_INHIBITED) {
1126 		dev_info(&device->cdev->dev,
1127 			    "Write inhibited path encountered\n");
1128 
1129 		/* vary path offline
1130 		   internal error 04 - Path should be varied off-line.*/
1131 		dev_err(&device->cdev->dev, "An error occurred in the DASD "
1132 			"device driver, reason=%s\n", "04");
1133 
1134 		erp = dasd_3990_erp_action_1(erp);
1135 
1136 	} else if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1137 
1138 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1139 			    "Equipment Check - " "environmental data present");
1140 
1141 		dasd_3990_handle_env_data(erp, sense);
1142 
1143 		erp = dasd_3990_erp_action_4(erp, sense);
1144 
1145 	} else if (sense[1] & SNS1_PERM_ERR) {
1146 
1147 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1148 			    "Equipment Check - retry exhausted or "
1149 			    "undesirable");
1150 
1151 		erp = dasd_3990_erp_action_1(erp);
1152 
1153 	} else {
1154 		/* all other equipment checks - Action 5 */
1155 		/* rest is done when retries == 0 */
1156 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1157 			    "Equipment check or processing error");
1158 
1159 		erp = dasd_3990_erp_action_5(erp);
1160 	}
1161 	return erp;
1162 
1163 }				/* end dasd_3990_erp_equip_check */
1164 
1165 /*
1166  * DASD_3990_ERP_DATA_CHECK
1167  *
1168  * DESCRIPTION
1169  *   Handles 24 byte 'Data Check' error.
1170  *
1171  * PARAMETER
1172  *   erp		current erp_head
1173  * RETURN VALUES
1174  *   erp		new erp_head - pointer to new ERP
1175  */
1176 static struct dasd_ccw_req *
1177 dasd_3990_erp_data_check(struct dasd_ccw_req * erp, char *sense)
1178 {
1179 
1180 	struct dasd_device *device = erp->startdev;
1181 
1182 	erp->function = dasd_3990_erp_data_check;
1183 
1184 	if (sense[2] & SNS2_CORRECTABLE) {	/* correctable data check */
1185 
1186 		/* issue message that the data has been corrected */
1187 		dev_emerg(&device->cdev->dev,
1188 			    "Data recovered during retry with PCI "
1189 			    "fetch mode active\n");
1190 
1191 		/* not possible to handle this situation in Linux */
1192 		panic("No way to inform application about the possibly "
1193 		      "incorrect data");
1194 
1195 	} else if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1196 
1197 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1198 			    "Uncorrectable data check recovered secondary "
1199 			    "addr of duplex pair");
1200 
1201 		erp = dasd_3990_erp_action_4(erp, sense);
1202 
1203 	} else if (sense[1] & SNS1_PERM_ERR) {
1204 
1205 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1206 			    "Uncorrectable data check with internal "
1207 			    "retry exhausted");
1208 
1209 		erp = dasd_3990_erp_action_1(erp);
1210 
1211 	} else {
1212 		/* all other data checks */
1213 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1214 			    "Uncorrectable data check with retry count "
1215 			    "exhausted...");
1216 
1217 		erp = dasd_3990_erp_action_5(erp);
1218 	}
1219 
1220 	return erp;
1221 
1222 }				/* end dasd_3990_erp_data_check */
1223 
1224 /*
1225  * DASD_3990_ERP_OVERRUN
1226  *
1227  * DESCRIPTION
1228  *   Handles 24 byte 'Overrun' error.
1229  *
1230  * PARAMETER
1231  *   erp		current erp_head
1232  * RETURN VALUES
1233  *   erp		new erp_head - pointer to new ERP
1234  */
1235 static struct dasd_ccw_req *
1236 dasd_3990_erp_overrun(struct dasd_ccw_req * erp, char *sense)
1237 {
1238 
1239 	struct dasd_device *device = erp->startdev;
1240 
1241 	erp->function = dasd_3990_erp_overrun;
1242 
1243 	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1244 		    "Overrun - service overrun or overrun"
1245 		    " error requested by channel");
1246 
1247 	erp = dasd_3990_erp_action_5(erp);
1248 
1249 	return erp;
1250 
1251 }				/* end dasd_3990_erp_overrun */
1252 
1253 /*
1254  * DASD_3990_ERP_INV_FORMAT
1255  *
1256  * DESCRIPTION
1257  *   Handles 24 byte 'Invalid Track Format' error.
1258  *
1259  * PARAMETER
1260  *   erp		current erp_head
1261  * RETURN VALUES
1262  *   erp		new erp_head - pointer to new ERP
1263  */
1264 static struct dasd_ccw_req *
1265 dasd_3990_erp_inv_format(struct dasd_ccw_req * erp, char *sense)
1266 {
1267 
1268 	struct dasd_device *device = erp->startdev;
1269 
1270 	erp->function = dasd_3990_erp_inv_format;
1271 
1272 	if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1273 
1274 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1275 			    "Track format error when destaging or "
1276 			    "staging data");
1277 
1278 		dasd_3990_handle_env_data(erp, sense);
1279 
1280 		erp = dasd_3990_erp_action_4(erp, sense);
1281 
1282 	} else {
1283 		/* internal error 06 - The track format is not valid*/
1284 		dev_err(&device->cdev->dev,
1285 			"An error occurred in the DASD device driver, "
1286 			"reason=%s\n", "06");
1287 
1288 		erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
1289 	}
1290 
1291 	return erp;
1292 
1293 }				/* end dasd_3990_erp_inv_format */
1294 
1295 /*
1296  * DASD_3990_ERP_EOC
1297  *
1298  * DESCRIPTION
1299  *   Handles 24 byte 'End-of-Cylinder' error.
1300  *
1301  * PARAMETER
1302  *   erp		already added default erp
1303  * RETURN VALUES
1304  *   erp		pointer to original (failed) cqr.
1305  */
1306 static struct dasd_ccw_req *
1307 dasd_3990_erp_EOC(struct dasd_ccw_req * default_erp, char *sense)
1308 {
1309 
1310 	struct dasd_device *device = default_erp->startdev;
1311 
1312 	dev_err(&device->cdev->dev,
1313 		"The cylinder data for accessing the DASD is inconsistent\n");
1314 
1315 	/* implement action 7 - BUG */
1316 	return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1317 
1318 }				/* end dasd_3990_erp_EOC */
1319 
1320 /*
1321  * DASD_3990_ERP_ENV_DATA
1322  *
1323  * DESCRIPTION
1324  *   Handles 24 byte 'Environmental-Data Present' error.
1325  *
1326  * PARAMETER
1327  *   erp		current erp_head
1328  * RETURN VALUES
1329  *   erp		new erp_head - pointer to new ERP
1330  */
1331 static struct dasd_ccw_req *
1332 dasd_3990_erp_env_data(struct dasd_ccw_req * erp, char *sense)
1333 {
1334 
1335 	struct dasd_device *device = erp->startdev;
1336 
1337 	erp->function = dasd_3990_erp_env_data;
1338 
1339 	DBF_DEV_EVENT(DBF_WARNING, device, "%s", "Environmental data present");
1340 
1341 	dasd_3990_handle_env_data(erp, sense);
1342 
1343 	/* don't retry on disabled interface */
1344 	if (sense[7] != 0x0F) {
1345 		erp = dasd_3990_erp_action_4(erp, sense);
1346 	} else {
1347 		erp->status = DASD_CQR_FILLED;
1348 	}
1349 
1350 	return erp;
1351 
1352 }				/* end dasd_3990_erp_env_data */
1353 
1354 /*
1355  * DASD_3990_ERP_NO_REC
1356  *
1357  * DESCRIPTION
1358  *   Handles 24 byte 'No Record Found' error.
1359  *
1360  * PARAMETER
1361  *   erp		already added default ERP
1362  *
1363  * RETURN VALUES
1364  *   erp		new erp_head - pointer to new ERP
1365  */
1366 static struct dasd_ccw_req *
1367 dasd_3990_erp_no_rec(struct dasd_ccw_req * default_erp, char *sense)
1368 {
1369 
1370 	struct dasd_device *device = default_erp->startdev;
1371 
1372 	/*
1373 	 * In some cases the 'No Record Found' error might be expected and
1374 	 * log messages shouldn't be written then.
1375 	 * Check if the according suppress bit is set.
1376 	 */
1377 	if (!test_bit(DASD_CQR_SUPPRESS_NRF, &default_erp->flags))
1378 		dev_err(&device->cdev->dev,
1379 			"The specified record was not found\n");
1380 
1381 	return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1382 
1383 }				/* end dasd_3990_erp_no_rec */
1384 
1385 /*
1386  * DASD_3990_ERP_FILE_PROT
1387  *
1388  * DESCRIPTION
1389  *   Handles 24 byte 'File Protected' error.
1390  *   Note: Seek related recovery is not implemented because
1391  *	   wee don't use the seek command yet.
1392  *
1393  * PARAMETER
1394  *   erp		current erp_head
1395  * RETURN VALUES
1396  *   erp		new erp_head - pointer to new ERP
1397  */
1398 static struct dasd_ccw_req *
1399 dasd_3990_erp_file_prot(struct dasd_ccw_req * erp)
1400 {
1401 
1402 	struct dasd_device *device = erp->startdev;
1403 
1404 	/*
1405 	 * In some cases the 'File Protected' error might be expected and
1406 	 * log messages shouldn't be written then.
1407 	 * Check if the according suppress bit is set.
1408 	 */
1409 	if (!test_bit(DASD_CQR_SUPPRESS_FP, &erp->flags))
1410 		dev_err(&device->cdev->dev,
1411 			"Accessing the DASD failed because of a hardware error\n");
1412 
1413 	return dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
1414 
1415 }				/* end dasd_3990_erp_file_prot */
1416 
1417 /*
1418  * DASD_3990_ERP_INSPECT_ALIAS
1419  *
1420  * DESCRIPTION
1421  *   Checks if the original request was started on an alias device.
1422  *   If yes, it modifies the original and the erp request so that
1423  *   the erp request can be started on a base device.
1424  *
1425  * PARAMETER
1426  *   erp		pointer to the currently created default ERP
1427  *
1428  * RETURN VALUES
1429  *   erp		pointer to the modified ERP, or NULL
1430  */
1431 
1432 static struct dasd_ccw_req *dasd_3990_erp_inspect_alias(
1433 						struct dasd_ccw_req *erp)
1434 {
1435 	struct dasd_ccw_req *cqr = erp->refers;
1436 	char *sense;
1437 
1438 	if (cqr->block &&
1439 	    (cqr->block->base != cqr->startdev)) {
1440 
1441 		sense = dasd_get_sense(&erp->refers->irb);
1442 		/*
1443 		 * dynamic pav may have changed base alias mapping
1444 		 */
1445 		if (!test_bit(DASD_FLAG_OFFLINE, &cqr->startdev->flags) && sense
1446 		    && (sense[0] == 0x10) && (sense[7] == 0x0F)
1447 		    && (sense[8] == 0x67)) {
1448 			/*
1449 			 * remove device from alias handling to prevent new
1450 			 * requests from being scheduled on the
1451 			 * wrong alias device
1452 			 */
1453 			dasd_alias_remove_device(cqr->startdev);
1454 
1455 			/* schedule worker to reload device */
1456 			dasd_reload_device(cqr->startdev);
1457 		}
1458 
1459 		if (cqr->startdev->features & DASD_FEATURE_ERPLOG) {
1460 			DBF_DEV_EVENT(DBF_ERR, cqr->startdev,
1461 				    "ERP on alias device for request %p,"
1462 				    " recover on base device %s", cqr,
1463 				    dev_name(&cqr->block->base->cdev->dev));
1464 		}
1465 		dasd_eckd_reset_ccw_to_base_io(cqr);
1466 		erp->startdev = cqr->block->base;
1467 		erp->function = dasd_3990_erp_inspect_alias;
1468 		return erp;
1469 	} else
1470 		return NULL;
1471 }
1472 
1473 
1474 /*
1475  * DASD_3990_ERP_INSPECT_24
1476  *
1477  * DESCRIPTION
1478  *   Does a detailed inspection of the 24 byte sense data
1479  *   and sets up a related error recovery action.
1480  *
1481  * PARAMETER
1482  *   sense		sense data of the actual error
1483  *   erp		pointer to the currently created default ERP
1484  *
1485  * RETURN VALUES
1486  *   erp		pointer to the (addtitional) ERP
1487  */
1488 static struct dasd_ccw_req *
1489 dasd_3990_erp_inspect_24(struct dasd_ccw_req * erp, char *sense)
1490 {
1491 
1492 	struct dasd_ccw_req *erp_filled = NULL;
1493 
1494 	/* Check sense for ....	   */
1495 	/* 'Command Reject'	   */
1496 	if ((erp_filled == NULL) && (sense[0] & SNS0_CMD_REJECT)) {
1497 		erp_filled = dasd_3990_erp_com_rej(erp, sense);
1498 	}
1499 	/* 'Intervention Required' */
1500 	if ((erp_filled == NULL) && (sense[0] & SNS0_INTERVENTION_REQ)) {
1501 		erp_filled = dasd_3990_erp_int_req(erp);
1502 	}
1503 	/* 'Bus Out Parity Check'  */
1504 	if ((erp_filled == NULL) && (sense[0] & SNS0_BUS_OUT_CHECK)) {
1505 		erp_filled = dasd_3990_erp_bus_out(erp);
1506 	}
1507 	/* 'Equipment Check'	   */
1508 	if ((erp_filled == NULL) && (sense[0] & SNS0_EQUIPMENT_CHECK)) {
1509 		erp_filled = dasd_3990_erp_equip_check(erp, sense);
1510 	}
1511 	/* 'Data Check'		   */
1512 	if ((erp_filled == NULL) && (sense[0] & SNS0_DATA_CHECK)) {
1513 		erp_filled = dasd_3990_erp_data_check(erp, sense);
1514 	}
1515 	/* 'Overrun'		   */
1516 	if ((erp_filled == NULL) && (sense[0] & SNS0_OVERRUN)) {
1517 		erp_filled = dasd_3990_erp_overrun(erp, sense);
1518 	}
1519 	/* 'Invalid Track Format'  */
1520 	if ((erp_filled == NULL) && (sense[1] & SNS1_INV_TRACK_FORMAT)) {
1521 		erp_filled = dasd_3990_erp_inv_format(erp, sense);
1522 	}
1523 	/* 'End-of-Cylinder'	   */
1524 	if ((erp_filled == NULL) && (sense[1] & SNS1_EOC)) {
1525 		erp_filled = dasd_3990_erp_EOC(erp, sense);
1526 	}
1527 	/* 'Environmental Data'	   */
1528 	if ((erp_filled == NULL) && (sense[2] & SNS2_ENV_DATA_PRESENT)) {
1529 		erp_filled = dasd_3990_erp_env_data(erp, sense);
1530 	}
1531 	/* 'No Record Found'	   */
1532 	if ((erp_filled == NULL) && (sense[1] & SNS1_NO_REC_FOUND)) {
1533 		erp_filled = dasd_3990_erp_no_rec(erp, sense);
1534 	}
1535 	/* 'File Protected'	   */
1536 	if ((erp_filled == NULL) && (sense[1] & SNS1_FILE_PROTECTED)) {
1537 		erp_filled = dasd_3990_erp_file_prot(erp);
1538 	}
1539 	/* other (unknown) error - do default ERP */
1540 	if (erp_filled == NULL) {
1541 
1542 		erp_filled = erp;
1543 	}
1544 
1545 	return erp_filled;
1546 
1547 }				/* END dasd_3990_erp_inspect_24 */
1548 
1549 /*
1550  *****************************************************************************
1551  * 32 byte sense ERP functions (only)
1552  *****************************************************************************
1553  */
1554 
1555 /*
1556  * DASD_3990_ERPACTION_10_32
1557  *
1558  * DESCRIPTION
1559  *   Handles 32 byte 'Action 10' of Single Program Action Codes.
1560  *   Just retry and if retry doesn't work, return with error.
1561  *
1562  * PARAMETER
1563  *   erp		current erp_head
1564  *   sense		current sense data
1565  * RETURN VALUES
1566  *   erp		modified erp_head
1567  */
1568 static struct dasd_ccw_req *
1569 dasd_3990_erp_action_10_32(struct dasd_ccw_req * erp, char *sense)
1570 {
1571 
1572 	struct dasd_device *device = erp->startdev;
1573 
1574 	erp->retries = 256;
1575 	erp->function = dasd_3990_erp_action_10_32;
1576 
1577 	DBF_DEV_EVENT(DBF_WARNING, device, "%s", "Perform logging requested");
1578 
1579 	return erp;
1580 
1581 }				/* end dasd_3990_erp_action_10_32 */
1582 
1583 /*
1584  * DASD_3990_ERP_ACTION_1B_32
1585  *
1586  * DESCRIPTION
1587  *   Handles 32 byte 'Action 1B' of Single Program Action Codes.
1588  *   A write operation could not be finished because of an unexpected
1589  *   condition.
1590  *   The already created 'default erp' is used to get the link to
1591  *   the erp chain, but it can not be used for this recovery
1592  *   action because it contains no DE/LO data space.
1593  *
1594  * PARAMETER
1595  *   default_erp	already added default erp.
1596  *   sense		current sense data
1597  *
1598  * RETURN VALUES
1599  *   erp		new erp or
1600  *			default_erp in case of imprecise ending or error
1601  */
1602 static struct dasd_ccw_req *
1603 dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
1604 {
1605 
1606 	struct dasd_device *device = default_erp->startdev;
1607 	__u32 cpa = 0;
1608 	struct dasd_ccw_req *cqr;
1609 	struct dasd_ccw_req *erp;
1610 	struct DE_eckd_data *DE_data;
1611 	struct PFX_eckd_data *PFX_data;
1612 	char *LO_data;		/* LO_eckd_data_t */
1613 	struct ccw1 *ccw, *oldccw;
1614 
1615 	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1616 		    "Write not finished because of unexpected condition");
1617 
1618 	default_erp->function = dasd_3990_erp_action_1B_32;
1619 
1620 	/* determine the original cqr */
1621 	cqr = default_erp;
1622 
1623 	while (cqr->refers != NULL) {
1624 		cqr = cqr->refers;
1625 	}
1626 
1627 	if (scsw_is_tm(&cqr->irb.scsw)) {
1628 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1629 			      "32 bit sense, action 1B is not defined"
1630 			      " in transport mode - just retry");
1631 		return default_erp;
1632 	}
1633 
1634 	/* for imprecise ending just do default erp */
1635 	if (sense[1] & 0x01) {
1636 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1637 			    "Imprecise ending is set - just retry");
1638 
1639 		return default_erp;
1640 	}
1641 
1642 	/* determine the address of the CCW to be restarted */
1643 	/* Imprecise ending is not set -> addr from IRB-SCSW */
1644 	cpa = default_erp->refers->irb.scsw.cmd.cpa;
1645 
1646 	if (cpa == 0) {
1647 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1648 			    "Unable to determine address of the CCW "
1649 			    "to be restarted");
1650 
1651 		return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1652 	}
1653 
1654 	/* Build new ERP request including DE/LO */
1655 	erp = dasd_alloc_erp_request((char *) &cqr->magic,
1656 				     2 + 1,/* DE/LO + TIC */
1657 				     sizeof(struct DE_eckd_data) +
1658 				     sizeof(struct LO_eckd_data), device);
1659 
1660 	if (IS_ERR(erp)) {
1661 		/* internal error 01 - Unable to allocate ERP */
1662 		dev_err(&device->cdev->dev, "An error occurred in the DASD "
1663 			"device driver, reason=%s\n", "01");
1664 		return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1665 	}
1666 
1667 	/* use original DE */
1668 	DE_data = erp->data;
1669 	oldccw = cqr->cpaddr;
1670 	if (oldccw->cmd_code == DASD_ECKD_CCW_PFX) {
1671 		PFX_data = cqr->data;
1672 		memcpy(DE_data, &PFX_data->define_extent,
1673 		       sizeof(struct DE_eckd_data));
1674 	} else
1675 		memcpy(DE_data, cqr->data, sizeof(struct DE_eckd_data));
1676 
1677 	/* create LO */
1678 	LO_data = erp->data + sizeof(struct DE_eckd_data);
1679 
1680 	if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) {
1681 		/* should not */
1682 		return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1683 	}
1684 
1685 	if ((sense[7] & 0x3F) == 0x01) {
1686 		/* operation code is WRITE DATA -> data area orientation */
1687 		LO_data[0] = 0x81;
1688 
1689 	} else if ((sense[7] & 0x3F) == 0x03) {
1690 		/* operation code is FORMAT WRITE -> index orientation */
1691 		LO_data[0] = 0xC3;
1692 
1693 	} else {
1694 		LO_data[0] = sense[7];	/* operation */
1695 	}
1696 
1697 	LO_data[1] = sense[8];	/* auxiliary */
1698 	LO_data[2] = sense[9];
1699 	LO_data[3] = sense[3];	/* count */
1700 	LO_data[4] = sense[29];	/* seek_addr.cyl */
1701 	LO_data[5] = sense[30];	/* seek_addr.cyl 2nd byte */
1702 	LO_data[7] = sense[31];	/* seek_addr.head 2nd byte */
1703 
1704 	memcpy(&(LO_data[8]), &(sense[11]), 8);
1705 
1706 	/* create DE ccw */
1707 	ccw = erp->cpaddr;
1708 	memset(ccw, 0, sizeof(struct ccw1));
1709 	ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT;
1710 	ccw->flags = CCW_FLAG_CC;
1711 	ccw->count = 16;
1712 	ccw->cda = (__u32)(addr_t) DE_data;
1713 
1714 	/* create LO ccw */
1715 	ccw++;
1716 	memset(ccw, 0, sizeof(struct ccw1));
1717 	ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD;
1718 	ccw->flags = CCW_FLAG_CC;
1719 	ccw->count = 16;
1720 	ccw->cda = (__u32)(addr_t) LO_data;
1721 
1722 	/* TIC to the failed ccw */
1723 	ccw++;
1724 	ccw->cmd_code = CCW_CMD_TIC;
1725 	ccw->cda = cpa;
1726 
1727 	/* fill erp related fields */
1728 	erp->flags = default_erp->flags;
1729 	erp->function = dasd_3990_erp_action_1B_32;
1730 	erp->refers = default_erp->refers;
1731 	erp->startdev = device;
1732 	erp->memdev = device;
1733 	erp->magic = default_erp->magic;
1734 	erp->expires = default_erp->expires;
1735 	erp->retries = 256;
1736 	erp->buildclk = get_tod_clock();
1737 	erp->status = DASD_CQR_FILLED;
1738 
1739 	/* remove the default erp */
1740 	dasd_free_erp_request(default_erp, device);
1741 
1742 	return erp;
1743 
1744 }				/* end dasd_3990_erp_action_1B_32 */
1745 
1746 /*
1747  * DASD_3990_UPDATE_1B
1748  *
1749  * DESCRIPTION
1750  *   Handles the update to the 32 byte 'Action 1B' of Single Program
1751  *   Action Codes in case the first action was not successful.
1752  *   The already created 'previous_erp' is the currently not successful
1753  *   ERP.
1754  *
1755  * PARAMETER
1756  *   previous_erp	already created previous erp.
1757  *   sense		current sense data
1758  * RETURN VALUES
1759  *   erp		modified erp
1760  */
1761 static struct dasd_ccw_req *
1762 dasd_3990_update_1B(struct dasd_ccw_req * previous_erp, char *sense)
1763 {
1764 
1765 	struct dasd_device *device = previous_erp->startdev;
1766 	__u32 cpa = 0;
1767 	struct dasd_ccw_req *cqr;
1768 	struct dasd_ccw_req *erp;
1769 	char *LO_data;		/* struct LO_eckd_data */
1770 	struct ccw1 *ccw;
1771 
1772 	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1773 		    "Write not finished because of unexpected condition"
1774 		    " - follow on");
1775 
1776 	/* determine the original cqr */
1777 	cqr = previous_erp;
1778 
1779 	while (cqr->refers != NULL) {
1780 		cqr = cqr->refers;
1781 	}
1782 
1783 	if (scsw_is_tm(&cqr->irb.scsw)) {
1784 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1785 			      "32 bit sense, action 1B, update,"
1786 			      " in transport mode - just retry");
1787 		return previous_erp;
1788 	}
1789 
1790 	/* for imprecise ending just do default erp */
1791 	if (sense[1] & 0x01) {
1792 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
1793 			    "Imprecise ending is set - just retry");
1794 
1795 		previous_erp->status = DASD_CQR_FILLED;
1796 
1797 		return previous_erp;
1798 	}
1799 
1800 	/* determine the address of the CCW to be restarted */
1801 	/* Imprecise ending is not set -> addr from IRB-SCSW */
1802 	cpa = previous_erp->irb.scsw.cmd.cpa;
1803 
1804 	if (cpa == 0) {
1805 		/* internal error 02 -
1806 		   Unable to determine address of the CCW to be restarted */
1807 		dev_err(&device->cdev->dev, "An error occurred in the DASD "
1808 			"device driver, reason=%s\n", "02");
1809 
1810 		previous_erp->status = DASD_CQR_FAILED;
1811 
1812 		return previous_erp;
1813 	}
1814 
1815 	erp = previous_erp;
1816 
1817 	/* update the LO with the new returned sense data  */
1818 	LO_data = erp->data + sizeof(struct DE_eckd_data);
1819 
1820 	if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) {
1821 		/* should not happen */
1822 		previous_erp->status = DASD_CQR_FAILED;
1823 
1824 		return previous_erp;
1825 	}
1826 
1827 	if ((sense[7] & 0x3F) == 0x01) {
1828 		/* operation code is WRITE DATA -> data area orientation */
1829 		LO_data[0] = 0x81;
1830 
1831 	} else if ((sense[7] & 0x3F) == 0x03) {
1832 		/* operation code is FORMAT WRITE -> index orientation */
1833 		LO_data[0] = 0xC3;
1834 
1835 	} else {
1836 		LO_data[0] = sense[7];	/* operation */
1837 	}
1838 
1839 	LO_data[1] = sense[8];	/* auxiliary */
1840 	LO_data[2] = sense[9];
1841 	LO_data[3] = sense[3];	/* count */
1842 	LO_data[4] = sense[29];	/* seek_addr.cyl */
1843 	LO_data[5] = sense[30];	/* seek_addr.cyl 2nd byte */
1844 	LO_data[7] = sense[31];	/* seek_addr.head 2nd byte */
1845 
1846 	memcpy(&(LO_data[8]), &(sense[11]), 8);
1847 
1848 	/* TIC to the failed ccw */
1849 	ccw = erp->cpaddr;	/* addr of DE ccw */
1850 	ccw++;			/* addr of LE ccw */
1851 	ccw++;			/* addr of TIC ccw */
1852 	ccw->cda = cpa;
1853 
1854 	erp->status = DASD_CQR_FILLED;
1855 
1856 	return erp;
1857 
1858 }				/* end dasd_3990_update_1B */
1859 
1860 /*
1861  * DASD_3990_ERP_COMPOUND_RETRY
1862  *
1863  * DESCRIPTION
1864  *   Handles the compound ERP action retry code.
1865  *   NOTE: At least one retry is done even if zero is specified
1866  *	   by the sense data. This makes enqueueing of the request
1867  *	   easier.
1868  *
1869  * PARAMETER
1870  *   sense		sense data of the actual error
1871  *   erp		pointer to the currently created ERP
1872  *
1873  * RETURN VALUES
1874  *   erp		modified ERP pointer
1875  *
1876  */
1877 static void
1878 dasd_3990_erp_compound_retry(struct dasd_ccw_req * erp, char *sense)
1879 {
1880 
1881 	switch (sense[25] & 0x03) {
1882 	case 0x00:		/* no not retry */
1883 		erp->retries = 1;
1884 		break;
1885 
1886 	case 0x01:		/* retry 2 times */
1887 		erp->retries = 2;
1888 		break;
1889 
1890 	case 0x02:		/* retry 10 times */
1891 		erp->retries = 10;
1892 		break;
1893 
1894 	case 0x03:		/* retry 256 times */
1895 		erp->retries = 256;
1896 		break;
1897 
1898 	default:
1899 		BUG();
1900 	}
1901 
1902 	erp->function = dasd_3990_erp_compound_retry;
1903 
1904 }				/* end dasd_3990_erp_compound_retry */
1905 
1906 /*
1907  * DASD_3990_ERP_COMPOUND_PATH
1908  *
1909  * DESCRIPTION
1910  *   Handles the compound ERP action for retry on alternate
1911  *   channel path.
1912  *
1913  * PARAMETER
1914  *   sense		sense data of the actual error
1915  *   erp		pointer to the currently created ERP
1916  *
1917  * RETURN VALUES
1918  *   erp		modified ERP pointer
1919  *
1920  */
1921 static void
1922 dasd_3990_erp_compound_path(struct dasd_ccw_req * erp, char *sense)
1923 {
1924 	if (sense[25] & DASD_SENSE_BIT_3) {
1925 		dasd_3990_erp_alternate_path(erp);
1926 
1927 		if (erp->status == DASD_CQR_FAILED &&
1928 		    !test_bit(DASD_CQR_VERIFY_PATH, &erp->flags)) {
1929 			/* reset the lpm and the status to be able to
1930 			 * try further actions. */
1931 			erp->lpm = dasd_path_get_opm(erp->startdev);
1932 			erp->status = DASD_CQR_NEED_ERP;
1933 		}
1934 	}
1935 
1936 	erp->function = dasd_3990_erp_compound_path;
1937 
1938 }				/* end dasd_3990_erp_compound_path */
1939 
1940 /*
1941  * DASD_3990_ERP_COMPOUND_CODE
1942  *
1943  * DESCRIPTION
1944  *   Handles the compound ERP action for retry code.
1945  *
1946  * PARAMETER
1947  *   sense		sense data of the actual error
1948  *   erp		pointer to the currently created ERP
1949  *
1950  * RETURN VALUES
1951  *   erp		NEW ERP pointer
1952  *
1953  */
1954 static struct dasd_ccw_req *
1955 dasd_3990_erp_compound_code(struct dasd_ccw_req * erp, char *sense)
1956 {
1957 
1958 	if (sense[25] & DASD_SENSE_BIT_2) {
1959 
1960 		switch (sense[28]) {
1961 		case 0x17:
1962 			/* issue a Diagnostic Control command with an
1963 			 * Inhibit Write subcommand and controller modifier */
1964 			erp = dasd_3990_erp_DCTL(erp, 0x20);
1965 			break;
1966 
1967 		case 0x25:
1968 			/* wait for 5 seconds and retry again */
1969 			erp->retries = 1;
1970 
1971 			dasd_3990_erp_block_queue (erp, 5*HZ);
1972 			break;
1973 
1974 		default:
1975 			/* should not happen - continue */
1976 			break;
1977 		}
1978 	}
1979 
1980 	erp->function = dasd_3990_erp_compound_code;
1981 
1982 	return erp;
1983 
1984 }				/* end dasd_3990_erp_compound_code */
1985 
1986 /*
1987  * DASD_3990_ERP_COMPOUND_CONFIG
1988  *
1989  * DESCRIPTION
1990  *   Handles the compound ERP action for configruation
1991  *   dependent error.
1992  *   Note: duplex handling is not implemented (yet).
1993  *
1994  * PARAMETER
1995  *   sense		sense data of the actual error
1996  *   erp		pointer to the currently created ERP
1997  *
1998  * RETURN VALUES
1999  *   erp		modified ERP pointer
2000  *
2001  */
2002 static void
2003 dasd_3990_erp_compound_config(struct dasd_ccw_req * erp, char *sense)
2004 {
2005 
2006 	if ((sense[25] & DASD_SENSE_BIT_1) && (sense[26] & DASD_SENSE_BIT_2)) {
2007 
2008 		/* set to suspended duplex state then restart
2009 		   internal error 05 - Set device to suspended duplex state
2010 		   should be done */
2011 		struct dasd_device *device = erp->startdev;
2012 		dev_err(&device->cdev->dev,
2013 			"An error occurred in the DASD device driver, "
2014 			"reason=%s\n", "05");
2015 
2016 	}
2017 
2018 	erp->function = dasd_3990_erp_compound_config;
2019 
2020 }				/* end dasd_3990_erp_compound_config */
2021 
2022 /*
2023  * DASD_3990_ERP_COMPOUND
2024  *
2025  * DESCRIPTION
2026  *   Does the further compound program action if
2027  *   compound retry was not successful.
2028  *
2029  * PARAMETER
2030  *   sense		sense data of the actual error
2031  *   erp		pointer to the current (failed) ERP
2032  *
2033  * RETURN VALUES
2034  *   erp		(additional) ERP pointer
2035  *
2036  */
2037 static struct dasd_ccw_req *
2038 dasd_3990_erp_compound(struct dasd_ccw_req * erp, char *sense)
2039 {
2040 
2041 	if ((erp->function == dasd_3990_erp_compound_retry) &&
2042 	    (erp->status == DASD_CQR_NEED_ERP)) {
2043 
2044 		dasd_3990_erp_compound_path(erp, sense);
2045 	}
2046 
2047 	if ((erp->function == dasd_3990_erp_compound_path) &&
2048 	    (erp->status == DASD_CQR_NEED_ERP)) {
2049 
2050 		erp = dasd_3990_erp_compound_code(erp, sense);
2051 	}
2052 
2053 	if ((erp->function == dasd_3990_erp_compound_code) &&
2054 	    (erp->status == DASD_CQR_NEED_ERP)) {
2055 
2056 		dasd_3990_erp_compound_config(erp, sense);
2057 	}
2058 
2059 	/* if no compound action ERP specified, the request failed */
2060 	if (erp->status == DASD_CQR_NEED_ERP)
2061 		erp->status = DASD_CQR_FAILED;
2062 
2063 	return erp;
2064 
2065 }				/* end dasd_3990_erp_compound */
2066 
2067 /*
2068  *DASD_3990_ERP_HANDLE_SIM
2069  *
2070  *DESCRIPTION
2071  *  inspects the SIM SENSE data and starts an appropriate action
2072  *
2073  * PARAMETER
2074  *   sense	   sense data of the actual error
2075  *
2076  * RETURN VALUES
2077  *   none
2078  */
2079 void
2080 dasd_3990_erp_handle_sim(struct dasd_device *device, char *sense)
2081 {
2082 	/* print message according to log or message to operator mode */
2083 	if ((sense[24] & DASD_SIM_MSG_TO_OP) || (sense[1] & 0x10)) {
2084 		/* print SIM SRC from RefCode */
2085 		dev_err(&device->cdev->dev, "SIM - SRC: "
2086 			    "%02x%02x%02x%02x\n", sense[22],
2087 			    sense[23], sense[11], sense[12]);
2088 	} else if (sense[24] & DASD_SIM_LOG) {
2089 		/* print SIM SRC Refcode */
2090 		dev_warn(&device->cdev->dev, "log SIM - SRC: "
2091 			    "%02x%02x%02x%02x\n", sense[22],
2092 			    sense[23], sense[11], sense[12]);
2093 	}
2094 }
2095 
2096 /*
2097  * DASD_3990_ERP_INSPECT_32
2098  *
2099  * DESCRIPTION
2100  *   Does a detailed inspection of the 32 byte sense data
2101  *   and sets up a related error recovery action.
2102  *
2103  * PARAMETER
2104  *   sense		sense data of the actual error
2105  *   erp		pointer to the currently created default ERP
2106  *
2107  * RETURN VALUES
2108  *   erp_filled		pointer to the ERP
2109  *
2110  */
2111 static struct dasd_ccw_req *
2112 dasd_3990_erp_inspect_32(struct dasd_ccw_req * erp, char *sense)
2113 {
2114 
2115 	struct dasd_device *device = erp->startdev;
2116 
2117 	erp->function = dasd_3990_erp_inspect_32;
2118 
2119 	/* check for SIM sense data */
2120 	if ((sense[6] & DASD_SIM_SENSE) == DASD_SIM_SENSE)
2121 		dasd_3990_erp_handle_sim(device, sense);
2122 
2123 	if (sense[25] & DASD_SENSE_BIT_0) {
2124 
2125 		/* compound program action codes (byte25 bit 0 == '1') */
2126 		dasd_3990_erp_compound_retry(erp, sense);
2127 
2128 	} else {
2129 
2130 		/* single program action codes (byte25 bit 0 == '0') */
2131 		switch (sense[25]) {
2132 
2133 		case 0x00:	/* success - use default ERP for retries */
2134 			DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
2135 				    "ERP called for successful request"
2136 				    " - just retry");
2137 			break;
2138 
2139 		case 0x01:	/* fatal error */
2140 			dev_err(&device->cdev->dev,
2141 				    "ERP failed for the DASD\n");
2142 
2143 			erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
2144 			break;
2145 
2146 		case 0x02:	/* intervention required */
2147 		case 0x03:	/* intervention required during dual copy */
2148 			erp = dasd_3990_erp_int_req(erp);
2149 			break;
2150 
2151 		case 0x0F:  /* length mismatch during update write command
2152 			       internal error 08 - update write command error*/
2153 			dev_err(&device->cdev->dev, "An error occurred in the "
2154 				"DASD device driver, reason=%s\n", "08");
2155 
2156 			erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
2157 			break;
2158 
2159 		case 0x10:  /* logging required for other channel program */
2160 			erp = dasd_3990_erp_action_10_32(erp, sense);
2161 			break;
2162 
2163 		case 0x15:	/* next track outside defined extend
2164 				   internal error 07 - The next track is not
2165 				   within the defined storage extent */
2166 			dev_err(&device->cdev->dev,
2167 				"An error occurred in the DASD device driver, "
2168 				"reason=%s\n", "07");
2169 
2170 			erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
2171 			break;
2172 
2173 		case 0x1B:	/* unexpected condition during write */
2174 
2175 			erp = dasd_3990_erp_action_1B_32(erp, sense);
2176 			break;
2177 
2178 		case 0x1C:	/* invalid data */
2179 			dev_emerg(&device->cdev->dev,
2180 				    "Data recovered during retry with PCI "
2181 				    "fetch mode active\n");
2182 
2183 			/* not possible to handle this situation in Linux */
2184 			panic
2185 			    ("Invalid data - No way to inform application "
2186 			     "about the possibly incorrect data");
2187 			break;
2188 
2189 		case 0x1D:	/* state-change pending */
2190 			DBF_DEV_EVENT(DBF_WARNING, device, "%s",
2191 				    "A State change pending condition exists "
2192 				    "for the subsystem or device");
2193 
2194 			erp = dasd_3990_erp_action_4(erp, sense);
2195 			break;
2196 
2197 		case 0x1E:	/* busy */
2198 			DBF_DEV_EVENT(DBF_WARNING, device, "%s",
2199 				    "Busy condition exists "
2200 				    "for the subsystem or device");
2201                         erp = dasd_3990_erp_action_4(erp, sense);
2202 			break;
2203 
2204 		default:	/* all others errors - default erp  */
2205 			break;
2206 		}
2207 	}
2208 
2209 	return erp;
2210 
2211 }				/* end dasd_3990_erp_inspect_32 */
2212 
2213 static void dasd_3990_erp_disable_path(struct dasd_device *device, __u8 lpum)
2214 {
2215 	int pos = pathmask_to_pos(lpum);
2216 
2217 	if (!(device->features & DASD_FEATURE_PATH_AUTODISABLE)) {
2218 		dev_err(&device->cdev->dev,
2219 			"Path %x.%02x (pathmask %02x) is operational despite excessive IFCCs\n",
2220 			device->path[pos].cssid, device->path[pos].chpid, lpum);
2221 		goto out;
2222 	}
2223 
2224 	/* no remaining path, cannot disable */
2225 	if (!(dasd_path_get_opm(device) & ~lpum)) {
2226 		dev_err(&device->cdev->dev,
2227 			"Last path %x.%02x (pathmask %02x) is operational despite excessive IFCCs\n",
2228 			device->path[pos].cssid, device->path[pos].chpid, lpum);
2229 		goto out;
2230 	}
2231 
2232 	dev_err(&device->cdev->dev,
2233 		"Path %x.%02x (pathmask %02x) is disabled - IFCC threshold exceeded\n",
2234 		device->path[pos].cssid, device->path[pos].chpid, lpum);
2235 	dasd_path_remove_opm(device, lpum);
2236 	dasd_path_add_ifccpm(device, lpum);
2237 
2238 out:
2239 	device->path[pos].errorclk = 0;
2240 	atomic_set(&device->path[pos].error_count, 0);
2241 }
2242 
2243 static void dasd_3990_erp_account_error(struct dasd_ccw_req *erp)
2244 {
2245 	struct dasd_device *device = erp->startdev;
2246 	__u8 lpum = erp->refers->irb.esw.esw1.lpum;
2247 	int pos = pathmask_to_pos(lpum);
2248 	unsigned long clk;
2249 
2250 	if (!device->path_thrhld)
2251 		return;
2252 
2253 	clk = get_tod_clock();
2254 	/*
2255 	 * check if the last error is longer ago than the timeout,
2256 	 * if so reset error state
2257 	 */
2258 	if ((tod_to_ns(clk - device->path[pos].errorclk) / NSEC_PER_SEC)
2259 	    >= device->path_interval) {
2260 		atomic_set(&device->path[pos].error_count, 0);
2261 		device->path[pos].errorclk = 0;
2262 	}
2263 	atomic_inc(&device->path[pos].error_count);
2264 	device->path[pos].errorclk = clk;
2265 	/* threshold exceeded disable path if possible */
2266 	if (atomic_read(&device->path[pos].error_count) >=
2267 	    device->path_thrhld)
2268 		dasd_3990_erp_disable_path(device, lpum);
2269 }
2270 
2271 /*
2272  *****************************************************************************
2273  * main ERP control functions (24 and 32 byte sense)
2274  *****************************************************************************
2275  */
2276 
2277 /*
2278  * DASD_3990_ERP_CONTROL_CHECK
2279  *
2280  * DESCRIPTION
2281  *   Does a generic inspection if a control check occurred and sets up
2282  *   the related error recovery procedure
2283  *
2284  * PARAMETER
2285  *   erp		pointer to the currently created default ERP
2286  *
2287  * RETURN VALUES
2288  *   erp_filled		pointer to the erp
2289  */
2290 
2291 static struct dasd_ccw_req *
2292 dasd_3990_erp_control_check(struct dasd_ccw_req *erp)
2293 {
2294 	struct dasd_device *device = erp->startdev;
2295 
2296 	if (scsw_cstat(&erp->refers->irb.scsw) & (SCHN_STAT_INTF_CTRL_CHK
2297 					   | SCHN_STAT_CHN_CTRL_CHK)) {
2298 		DBF_DEV_EVENT(DBF_WARNING, device, "%s",
2299 			    "channel or interface control check");
2300 		dasd_3990_erp_account_error(erp);
2301 		erp = dasd_3990_erp_action_4(erp, NULL);
2302 	}
2303 	return erp;
2304 }
2305 
2306 /*
2307  * DASD_3990_ERP_INSPECT
2308  *
2309  * DESCRIPTION
2310  *   Does a detailed inspection for sense data by calling either
2311  *   the 24-byte or the 32-byte inspection routine.
2312  *
2313  * PARAMETER
2314  *   erp		pointer to the currently created default ERP
2315  * RETURN VALUES
2316  *   erp_new		contens was possibly modified
2317  */
2318 static struct dasd_ccw_req *
2319 dasd_3990_erp_inspect(struct dasd_ccw_req *erp)
2320 {
2321 
2322 	struct dasd_ccw_req *erp_new = NULL;
2323 	char *sense;
2324 
2325 	/* if this problem occurred on an alias retry on base */
2326 	erp_new = dasd_3990_erp_inspect_alias(erp);
2327 	if (erp_new)
2328 		return erp_new;
2329 
2330 	/* sense data are located in the refers record of the
2331 	 * already set up new ERP !
2332 	 * check if concurrent sens is available
2333 	 */
2334 	sense = dasd_get_sense(&erp->refers->irb);
2335 	if (!sense)
2336 		erp_new = dasd_3990_erp_control_check(erp);
2337 	/* distinguish between 24 and 32 byte sense data */
2338 	else if (sense[27] & DASD_SENSE_BIT_0) {
2339 
2340 		/* inspect the 24 byte sense data */
2341 		erp_new = dasd_3990_erp_inspect_24(erp, sense);
2342 
2343 	} else {
2344 
2345 		/* inspect the 32 byte sense data */
2346 		erp_new = dasd_3990_erp_inspect_32(erp, sense);
2347 
2348 	}	/* end distinguish between 24 and 32 byte sense data */
2349 
2350 	return erp_new;
2351 }
2352 
2353 /*
2354  * DASD_3990_ERP_ADD_ERP
2355  *
2356  * DESCRIPTION
2357  *   This function adds an additional request block (ERP) to the head of
2358  *   the given cqr (or erp).
2359  *   For a command mode cqr the erp is initialized as an default erp
2360  *   (retry TIC).
2361  *   For transport mode we make a copy of the original TCW (points to
2362  *   the original TCCB, TIDALs, etc.) but give it a fresh
2363  *   TSB so the original sense data will not be changed.
2364  *
2365  * PARAMETER
2366  *   cqr		head of the current ERP-chain (or single cqr if
2367  *			first error)
2368  * RETURN VALUES
2369  *   erp		pointer to new ERP-chain head
2370  */
2371 static struct dasd_ccw_req *dasd_3990_erp_add_erp(struct dasd_ccw_req *cqr)
2372 {
2373 
2374 	struct dasd_device *device = cqr->startdev;
2375 	struct ccw1 *ccw;
2376 	struct dasd_ccw_req *erp;
2377 	int cplength, datasize;
2378 	struct tcw *tcw;
2379 	struct tsb *tsb;
2380 
2381 	if (cqr->cpmode == 1) {
2382 		cplength = 0;
2383 		/* TCW needs to be 64 byte aligned, so leave enough room */
2384 		datasize = 64 + sizeof(struct tcw) + sizeof(struct tsb);
2385 	} else {
2386 		cplength = 2;
2387 		datasize = 0;
2388 	}
2389 
2390 	/* allocate additional request block */
2391 	erp = dasd_alloc_erp_request((char *) &cqr->magic,
2392 				     cplength, datasize, device);
2393 	if (IS_ERR(erp)) {
2394                 if (cqr->retries <= 0) {
2395 			DBF_DEV_EVENT(DBF_ERR, device, "%s",
2396 				    "Unable to allocate ERP request");
2397 			cqr->status = DASD_CQR_FAILED;
2398 			cqr->stopclk = get_tod_clock();
2399 		} else {
2400 			DBF_DEV_EVENT(DBF_ERR, device,
2401                                      "Unable to allocate ERP request "
2402 				     "(%i retries left)",
2403                                      cqr->retries);
2404 			dasd_block_set_timer(device->block, (HZ << 3));
2405                 }
2406 		return erp;
2407 	}
2408 
2409 	ccw = cqr->cpaddr;
2410 	if (cqr->cpmode == 1) {
2411 		/* make a shallow copy of the original tcw but set new tsb */
2412 		erp->cpmode = 1;
2413 		erp->cpaddr = PTR_ALIGN(erp->data, 64);
2414 		tcw = erp->cpaddr;
2415 		tsb = (struct tsb *) &tcw[1];
2416 		*tcw = *((struct tcw *)cqr->cpaddr);
2417 		tcw->tsb = (long)tsb;
2418 	} else if (ccw->cmd_code == DASD_ECKD_CCW_PSF) {
2419 		/* PSF cannot be chained from NOOP/TIC */
2420 		erp->cpaddr = cqr->cpaddr;
2421 	} else {
2422 		/* initialize request with default TIC to current ERP/CQR */
2423 		ccw = erp->cpaddr;
2424 		ccw->cmd_code = CCW_CMD_NOOP;
2425 		ccw->flags = CCW_FLAG_CC;
2426 		ccw++;
2427 		ccw->cmd_code = CCW_CMD_TIC;
2428 		ccw->cda      = (long)(cqr->cpaddr);
2429 	}
2430 
2431 	erp->flags = cqr->flags;
2432 	erp->function = dasd_3990_erp_add_erp;
2433 	erp->refers   = cqr;
2434 	erp->startdev = device;
2435 	erp->memdev   = device;
2436 	erp->block    = cqr->block;
2437 	erp->magic    = cqr->magic;
2438 	erp->expires  = cqr->expires;
2439 	erp->retries  = 256;
2440 	erp->buildclk = get_tod_clock();
2441 	erp->status = DASD_CQR_FILLED;
2442 
2443 	return erp;
2444 }
2445 
2446 /*
2447  * DASD_3990_ERP_ADDITIONAL_ERP
2448  *
2449  * DESCRIPTION
2450  *   An additional ERP is needed to handle the current error.
2451  *   Add ERP to the head of the ERP-chain containing the ERP processing
2452  *   determined based on the sense data.
2453  *
2454  * PARAMETER
2455  *   cqr		head of the current ERP-chain (or single cqr if
2456  *			first error)
2457  *
2458  * RETURN VALUES
2459  *   erp		pointer to new ERP-chain head
2460  */
2461 static struct dasd_ccw_req *
2462 dasd_3990_erp_additional_erp(struct dasd_ccw_req * cqr)
2463 {
2464 
2465 	struct dasd_ccw_req *erp = NULL;
2466 
2467 	/* add erp and initialize with default TIC */
2468 	erp = dasd_3990_erp_add_erp(cqr);
2469 
2470 	if (IS_ERR(erp))
2471 		return erp;
2472 
2473 	/* inspect sense, determine specific ERP if possible */
2474 	if (erp != cqr) {
2475 
2476 		erp = dasd_3990_erp_inspect(erp);
2477 	}
2478 
2479 	return erp;
2480 
2481 }				/* end dasd_3990_erp_additional_erp */
2482 
2483 /*
2484  * DASD_3990_ERP_ERROR_MATCH
2485  *
2486  * DESCRIPTION
2487  *   Check if the device status of the given cqr is the same.
2488  *   This means that the failed CCW and the relevant sense data
2489  *   must match.
2490  *   I don't distinguish between 24 and 32 byte sense because in case of
2491  *   24 byte sense byte 25 and 27 is set as well.
2492  *
2493  * PARAMETER
2494  *   cqr1		first cqr, which will be compared with the
2495  *   cqr2		second cqr.
2496  *
2497  * RETURN VALUES
2498  *   match		'boolean' for match found
2499  *			returns 1 if match found, otherwise 0.
2500  */
2501 static int dasd_3990_erp_error_match(struct dasd_ccw_req *cqr1,
2502 				     struct dasd_ccw_req *cqr2)
2503 {
2504 	char *sense1, *sense2;
2505 
2506 	if (cqr1->startdev != cqr2->startdev)
2507 		return 0;
2508 
2509 	sense1 = dasd_get_sense(&cqr1->irb);
2510 	sense2 = dasd_get_sense(&cqr2->irb);
2511 
2512 	/* one request has sense data, the other not -> no match, return 0 */
2513 	if (!sense1 != !sense2)
2514 		return 0;
2515 	/* no sense data in both cases -> check cstat for IFCC */
2516 	if (!sense1 && !sense2)	{
2517 		if ((scsw_cstat(&cqr1->irb.scsw) & (SCHN_STAT_INTF_CTRL_CHK |
2518 						    SCHN_STAT_CHN_CTRL_CHK)) ==
2519 		    (scsw_cstat(&cqr2->irb.scsw) & (SCHN_STAT_INTF_CTRL_CHK |
2520 						    SCHN_STAT_CHN_CTRL_CHK)))
2521 			return 1; /* match with ifcc*/
2522 	}
2523 	/* check sense data; byte 0-2,25,27 */
2524 	if (!(sense1 && sense2 &&
2525 	      (memcmp(sense1, sense2, 3) == 0) &&
2526 	      (sense1[27] == sense2[27]) &&
2527 	      (sense1[25] == sense2[25]))) {
2528 
2529 		return 0;	/* sense doesn't match */
2530 	}
2531 
2532 	return 1;		/* match */
2533 
2534 }				/* end dasd_3990_erp_error_match */
2535 
2536 /*
2537  * DASD_3990_ERP_IN_ERP
2538  *
2539  * DESCRIPTION
2540  *   check if the current error already happened before.
2541  *   quick exit if current cqr is not an ERP (cqr->refers=NULL)
2542  *
2543  * PARAMETER
2544  *   cqr		failed cqr (either original cqr or already an erp)
2545  *
2546  * RETURN VALUES
2547  *   erp		erp-pointer to the already defined error
2548  *			recovery procedure OR
2549  *			NULL if a 'new' error occurred.
2550  */
2551 static struct dasd_ccw_req *
2552 dasd_3990_erp_in_erp(struct dasd_ccw_req *cqr)
2553 {
2554 
2555 	struct dasd_ccw_req *erp_head = cqr,	/* save erp chain head */
2556 	*erp_match = NULL;	/* save erp chain head */
2557 	int match = 0;		/* 'boolean' for matching error found */
2558 
2559 	if (cqr->refers == NULL) {	/* return if not in erp */
2560 		return NULL;
2561 	}
2562 
2563 	/* check the erp/cqr chain for current error */
2564 	do {
2565 		match = dasd_3990_erp_error_match(erp_head, cqr->refers);
2566 		erp_match = cqr;	/* save possible matching erp  */
2567 		cqr = cqr->refers;	/* check next erp/cqr in queue */
2568 
2569 	} while ((cqr->refers != NULL) && (!match));
2570 
2571 	if (!match) {
2572 		return NULL;	/* no match was found */
2573 	}
2574 
2575 	return erp_match;	/* return address of matching erp */
2576 
2577 }				/* END dasd_3990_erp_in_erp */
2578 
2579 /*
2580  * DASD_3990_ERP_FURTHER_ERP (24 & 32 byte sense)
2581  *
2582  * DESCRIPTION
2583  *   No retry is left for the current ERP. Check what has to be done
2584  *   with the ERP.
2585  *     - do further defined ERP action or
2586  *     - wait for interrupt or
2587  *     - exit with permanent error
2588  *
2589  * PARAMETER
2590  *   erp		ERP which is in progress with no retry left
2591  *
2592  * RETURN VALUES
2593  *   erp		modified/additional ERP
2594  */
2595 static struct dasd_ccw_req *
2596 dasd_3990_erp_further_erp(struct dasd_ccw_req *erp)
2597 {
2598 
2599 	struct dasd_device *device = erp->startdev;
2600 	char *sense = dasd_get_sense(&erp->irb);
2601 
2602 	/* check for 24 byte sense ERP */
2603 	if ((erp->function == dasd_3990_erp_bus_out) ||
2604 	    (erp->function == dasd_3990_erp_action_1) ||
2605 	    (erp->function == dasd_3990_erp_action_4)) {
2606 
2607 		erp = dasd_3990_erp_action_1(erp);
2608 
2609 	} else if (erp->function == dasd_3990_erp_action_1_sec) {
2610 		erp = dasd_3990_erp_action_1_sec(erp);
2611 	} else if (erp->function == dasd_3990_erp_action_5) {
2612 
2613 		/* retries have not been successful */
2614 		/* prepare erp for retry on different channel path */
2615 		erp = dasd_3990_erp_action_1(erp);
2616 
2617 		if (sense && !(sense[2] & DASD_SENSE_BIT_0)) {
2618 
2619 			/* issue a Diagnostic Control command with an
2620 			 * Inhibit Write subcommand */
2621 
2622 			switch (sense[25]) {
2623 			case 0x17:
2624 			case 0x57:{	/* controller */
2625 					erp = dasd_3990_erp_DCTL(erp, 0x20);
2626 					break;
2627 				}
2628 			case 0x18:
2629 			case 0x58:{	/* channel path */
2630 					erp = dasd_3990_erp_DCTL(erp, 0x40);
2631 					break;
2632 				}
2633 			case 0x19:
2634 			case 0x59:{	/* storage director */
2635 					erp = dasd_3990_erp_DCTL(erp, 0x80);
2636 					break;
2637 				}
2638 			default:
2639 				DBF_DEV_EVENT(DBF_WARNING, device,
2640 					    "invalid subcommand modifier 0x%x "
2641 					    "for Diagnostic Control Command",
2642 					    sense[25]);
2643 			}
2644 		}
2645 
2646 		/* check for 32 byte sense ERP */
2647 	} else if (sense &&
2648 		   ((erp->function == dasd_3990_erp_compound_retry) ||
2649 		    (erp->function == dasd_3990_erp_compound_path) ||
2650 		    (erp->function == dasd_3990_erp_compound_code) ||
2651 		    (erp->function == dasd_3990_erp_compound_config))) {
2652 
2653 		erp = dasd_3990_erp_compound(erp, sense);
2654 
2655 	} else {
2656 		/*
2657 		 * No retry left and no additional special handling
2658 		 * necessary
2659 		 */
2660 		dev_err(&device->cdev->dev,
2661 			"ERP %p has run out of retries and failed\n", erp);
2662 
2663 		erp->status = DASD_CQR_FAILED;
2664 	}
2665 
2666 	return erp;
2667 
2668 }				/* end dasd_3990_erp_further_erp */
2669 
2670 /*
2671  * DASD_3990_ERP_HANDLE_MATCH_ERP
2672  *
2673  * DESCRIPTION
2674  *   An error occurred again and an ERP has been detected which is already
2675  *   used to handle this error (e.g. retries).
2676  *   All prior ERP's are asumed to be successful and therefore removed
2677  *   from queue.
2678  *   If retry counter of matching erp is already 0, it is checked if further
2679  *   action is needed (besides retry) or if the ERP has failed.
2680  *
2681  * PARAMETER
2682  *   erp_head		first ERP in ERP-chain
2683  *   erp		ERP that handles the actual error.
2684  *			(matching erp)
2685  *
2686  * RETURN VALUES
2687  *   erp		modified/additional ERP
2688  */
2689 static struct dasd_ccw_req *
2690 dasd_3990_erp_handle_match_erp(struct dasd_ccw_req *erp_head,
2691 			       struct dasd_ccw_req *erp)
2692 {
2693 
2694 	struct dasd_device *device = erp_head->startdev;
2695 	struct dasd_ccw_req *erp_done = erp_head;	/* finished req */
2696 	struct dasd_ccw_req *erp_free = NULL;	/* req to be freed */
2697 
2698 	/* loop over successful ERPs and remove them from chanq */
2699 	while (erp_done != erp) {
2700 
2701 		if (erp_done == NULL)	/* end of chain reached */
2702 			panic(PRINTK_HEADER "Programming error in ERP! The "
2703 			      "original request was lost\n");
2704 
2705 		/* remove the request from the device queue */
2706 		list_del(&erp_done->blocklist);
2707 
2708 		erp_free = erp_done;
2709 		erp_done = erp_done->refers;
2710 
2711 		/* free the finished erp request */
2712 		dasd_free_erp_request(erp_free, erp_free->memdev);
2713 
2714 	}			/* end while */
2715 
2716 	if (erp->retries > 0) {
2717 
2718 		char *sense = dasd_get_sense(&erp->refers->irb);
2719 
2720 		/* check for special retries */
2721 		if (sense && erp->function == dasd_3990_erp_action_4) {
2722 
2723 			erp = dasd_3990_erp_action_4(erp, sense);
2724 
2725 		} else if (sense &&
2726 			   erp->function == dasd_3990_erp_action_1B_32) {
2727 
2728 			erp = dasd_3990_update_1B(erp, sense);
2729 
2730 		} else if (sense && erp->function == dasd_3990_erp_int_req) {
2731 
2732 			erp = dasd_3990_erp_int_req(erp);
2733 
2734 		} else {
2735 			/* simple retry	  */
2736 			DBF_DEV_EVENT(DBF_DEBUG, device,
2737 				    "%i retries left for erp %p",
2738 				    erp->retries, erp);
2739 
2740 			/* handle the request again... */
2741 			erp->status = DASD_CQR_FILLED;
2742 		}
2743 
2744 	} else {
2745 		/* no retry left - check for further necessary action	 */
2746 		/* if no further actions, handle rest as permanent error */
2747 		erp = dasd_3990_erp_further_erp(erp);
2748 	}
2749 
2750 	return erp;
2751 
2752 }				/* end dasd_3990_erp_handle_match_erp */
2753 
2754 /*
2755  * DASD_3990_ERP_ACTION
2756  *
2757  * DESCRIPTION
2758  *   control routine for 3990 erp actions.
2759  *   Has to be called with the queue lock (namely the s390_irq_lock) acquired.
2760  *
2761  * PARAMETER
2762  *   cqr		failed cqr (either original cqr or already an erp)
2763  *
2764  * RETURN VALUES
2765  *   erp		erp-pointer to the head of the ERP action chain.
2766  *			This means:
2767  *			 - either a ptr to an additional ERP cqr or
2768  *			 - the original given cqr (which's status might
2769  *			   be modified)
2770  */
2771 struct dasd_ccw_req *
2772 dasd_3990_erp_action(struct dasd_ccw_req * cqr)
2773 {
2774 	struct dasd_ccw_req *erp = NULL;
2775 	struct dasd_device *device = cqr->startdev;
2776 	struct dasd_ccw_req *temp_erp = NULL;
2777 
2778 	if (device->features & DASD_FEATURE_ERPLOG) {
2779 		/* print current erp_chain */
2780 		dev_err(&device->cdev->dev,
2781 			    "ERP chain at BEGINNING of ERP-ACTION\n");
2782 		for (temp_erp = cqr;
2783 		     temp_erp != NULL; temp_erp = temp_erp->refers) {
2784 
2785 			dev_err(&device->cdev->dev,
2786 				    "ERP %p (%02x) refers to %p\n",
2787 				    temp_erp, temp_erp->status,
2788 				    temp_erp->refers);
2789 		}
2790 	}
2791 
2792 	/* double-check if current erp/cqr was successful */
2793 	if ((scsw_cstat(&cqr->irb.scsw) == 0x00) &&
2794 	    (scsw_dstat(&cqr->irb.scsw) ==
2795 	     (DEV_STAT_CHN_END | DEV_STAT_DEV_END))) {
2796 
2797 		DBF_DEV_EVENT(DBF_DEBUG, device,
2798 			    "ERP called for successful request %p"
2799 			    " - NO ERP necessary", cqr);
2800 
2801 		cqr->status = DASD_CQR_DONE;
2802 
2803 		return cqr;
2804 	}
2805 
2806 	/* check if error happened before */
2807 	erp = dasd_3990_erp_in_erp(cqr);
2808 
2809 	if (erp == NULL) {
2810 		/* no matching erp found - set up erp */
2811 		erp = dasd_3990_erp_additional_erp(cqr);
2812 		if (IS_ERR(erp))
2813 			return erp;
2814 	} else {
2815 		/* matching erp found - set all leading erp's to DONE */
2816 		erp = dasd_3990_erp_handle_match_erp(cqr, erp);
2817 	}
2818 
2819 
2820 	/*
2821 	 * For path verification work we need to stick with the path that was
2822 	 * originally chosen so that the per path configuration data is
2823 	 * assigned correctly.
2824 	 */
2825 	if (test_bit(DASD_CQR_VERIFY_PATH, &erp->flags) && cqr->lpm) {
2826 		erp->lpm = cqr->lpm;
2827 	}
2828 
2829 	if (device->features & DASD_FEATURE_ERPLOG) {
2830 		/* print current erp_chain */
2831 		dev_err(&device->cdev->dev,
2832 			    "ERP chain at END of ERP-ACTION\n");
2833 		for (temp_erp = erp;
2834 		     temp_erp != NULL; temp_erp = temp_erp->refers) {
2835 
2836 			dev_err(&device->cdev->dev,
2837 				    "ERP %p (%02x) refers to %p\n",
2838 				    temp_erp, temp_erp->status,
2839 				    temp_erp->refers);
2840 		}
2841 	}
2842 
2843 	/* enqueue ERP request if it's a new one */
2844 	if (list_empty(&erp->blocklist)) {
2845 		cqr->status = DASD_CQR_IN_ERP;
2846 		/* add erp request before the cqr */
2847 		list_add_tail(&erp->blocklist, &cqr->blocklist);
2848 	}
2849 
2850 
2851 
2852 	return erp;
2853 
2854 }				/* end dasd_3990_erp_action */
2855