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