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