git.oblomov.eu Git - linux-2.6/blob - 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                         /* call extended error reporting (EER) */
1112                         dasd_eer_write(device, erp->refers,
1113                                        DASD_EER_PPRCSUSPEND);
1114                         break;
1115                 case 0x0C:
1116                         DEV_MESSAGE(KERN_WARNING, device, "%s",
1117                                     "FORMAT F - Subsystem status connot be "
1118                                     "determined");
1119                         break;
1120                 case 0x0D:
1121                         DEV_MESSAGE(KERN_WARNING, device, "%s",
1122                                     "FORMAT F - Caching status reset to "
1123                                     "default");
1124                         break;
1125                 case 0x0E:
1126                         DEV_MESSAGE(KERN_WARNING, device, "%s",
1127                                     "FORMAT F - DASD Fast Write inhibited");
1128                         break;
1129                 default:
1130                         DEV_MESSAGE(KERN_WARNING, device, "%s",
1131                                     "FORMAT D - Reserved");
1132                 }
1133                 break;
1134
1135         default:        /* unknown message format - should not happen */
1136                 DEV_MESSAGE (KERN_WARNING, device,
1137                              "unknown message format %02x",
1138                              msg_format);
1139                 break;
1140         }                       /* end switch message format */
1141
1142 }                               /* end dasd_3990_handle_env_data */
1143
1144 /*
1145  * DASD_3990_ERP_COM_REJ
1146  *
1147  * DESCRIPTION
1148  *   Handles 24 byte 'Command Reject' error.
1149  *
1150  * PARAMETER
1151  *   erp                current erp_head
1152  *   sense              current sense data
1153  *
1154  * RETURN VALUES
1155  *   erp                'new' erp_head - pointer to new ERP
1156  */
1157 static struct dasd_ccw_req *
1158 dasd_3990_erp_com_rej(struct dasd_ccw_req * erp, char *sense)
1159 {
1160
1161         struct dasd_device *device = erp->device;
1162
1163         erp->function = dasd_3990_erp_com_rej;
1164
1165         /* env data present (ACTION 10 - retry should work) */
1166         if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1167
1168                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1169                             "Command Reject - environmental data present");
1170
1171                 dasd_3990_handle_env_data(erp, sense);
1172
1173                 erp->retries = 5;
1174
1175         } else {
1176                 /* fatal error -  set status to FAILED */
1177                 DEV_MESSAGE(KERN_ERR, device, "%s",
1178                             "Command Reject - Fatal error");
1179
1180                 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
1181         }
1182
1183         return erp;
1184
1185 }                               /* end dasd_3990_erp_com_rej */
1186
1187 /*
1188  * DASD_3990_ERP_BUS_OUT
1189  *
1190  * DESCRIPTION
1191  *   Handles 24 byte 'Bus Out Parity Check' error.
1192  *
1193  * PARAMETER
1194  *   erp                current erp_head
1195  * RETURN VALUES
1196  *   erp                new erp_head - pointer to new ERP
1197  */
1198 static struct dasd_ccw_req *
1199 dasd_3990_erp_bus_out(struct dasd_ccw_req * erp)
1200 {
1201
1202         struct dasd_device *device = erp->device;
1203
1204         /* first time set initial retry counter and erp_function */
1205         /* and retry once without blocking queue                 */
1206         /* (this enables easier enqueing of the cqr)             */
1207         if (erp->function != dasd_3990_erp_bus_out) {
1208                 erp->retries = 256;
1209                 erp->function = dasd_3990_erp_bus_out;
1210
1211         } else {
1212
1213                 /* issue a message and wait for 'device ready' interrupt */
1214                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1215                             "bus out parity error or BOPC requested by "
1216                             "channel");
1217
1218                 dasd_3990_erp_block_queue(erp, 60*HZ);
1219
1220         }
1221
1222         return erp;
1223
1224 }                               /* end dasd_3990_erp_bus_out */
1225
1226 /*
1227  * DASD_3990_ERP_EQUIP_CHECK
1228  *
1229  * DESCRIPTION
1230  *   Handles 24 byte 'Equipment Check' error.
1231  *
1232  * PARAMETER
1233  *   erp                current erp_head
1234  * RETURN VALUES
1235  *   erp                new erp_head - pointer to new ERP
1236  */
1237 static struct dasd_ccw_req *
1238 dasd_3990_erp_equip_check(struct dasd_ccw_req * erp, char *sense)
1239 {
1240
1241         struct dasd_device *device = erp->device;
1242
1243         erp->function = dasd_3990_erp_equip_check;
1244
1245         if (sense[1] & SNS1_WRITE_INHIBITED) {
1246
1247                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1248                             "Write inhibited path encountered");
1249
1250                 /* vary path offline */
1251                 DEV_MESSAGE(KERN_ERR, device, "%s",
1252                             "Path should be varied off-line. "
1253                             "This is not implemented yet \n - please report "
1254                             "to linux390@de.ibm.com");
1255
1256                 erp = dasd_3990_erp_action_1(erp);
1257
1258         } else if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1259
1260                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1261                             "Equipment Check - " "environmental data present");
1262
1263                 dasd_3990_handle_env_data(erp, sense);
1264
1265                 erp = dasd_3990_erp_action_4(erp, sense);
1266
1267         } else if (sense[1] & SNS1_PERM_ERR) {
1268
1269                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1270                             "Equipment Check - retry exhausted or "
1271                             "undesirable");
1272
1273                 erp = dasd_3990_erp_action_1(erp);
1274
1275         } else {
1276                 /* all other equipment checks - Action 5 */
1277                 /* rest is done when retries == 0 */
1278                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1279                             "Equipment check or processing error");
1280
1281                 erp = dasd_3990_erp_action_5(erp);
1282         }
1283
1284         return erp;
1285
1286 }                               /* end dasd_3990_erp_equip_check */
1287
1288 /*
1289  * DASD_3990_ERP_DATA_CHECK
1290  *
1291  * DESCRIPTION
1292  *   Handles 24 byte 'Data Check' error.
1293  *
1294  * PARAMETER
1295  *   erp                current erp_head
1296  * RETURN VALUES
1297  *   erp                new erp_head - pointer to new ERP
1298  */
1299 static struct dasd_ccw_req *
1300 dasd_3990_erp_data_check(struct dasd_ccw_req * erp, char *sense)
1301 {
1302
1303         struct dasd_device *device = erp->device;
1304
1305         erp->function = dasd_3990_erp_data_check;
1306
1307         if (sense[2] & SNS2_CORRECTABLE) {      /* correctable data check */
1308
1309                 /* issue message that the data has been corrected */
1310                 DEV_MESSAGE(KERN_EMERG, device, "%s",
1311                             "Data recovered during retry with PCI "
1312                             "fetch mode active");
1313
1314                 /* not possible to handle this situation in Linux */
1315                 panic("No way to inform application about the possibly "
1316                       "incorrect data");
1317
1318         } else if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1319
1320                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1321                             "Uncorrectable data check recovered secondary "
1322                             "addr of duplex pair");
1323
1324                 erp = dasd_3990_erp_action_4(erp, sense);
1325
1326         } else if (sense[1] & SNS1_PERM_ERR) {
1327
1328                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1329                             "Uncorrectable data check with internal "
1330                             "retry exhausted");
1331
1332                 erp = dasd_3990_erp_action_1(erp);
1333
1334         } else {
1335                 /* all other data checks */
1336                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1337                             "Uncorrectable data check with retry count "
1338                             "exhausted...");
1339
1340                 erp = dasd_3990_erp_action_5(erp);
1341         }
1342
1343         return erp;
1344
1345 }                               /* end dasd_3990_erp_data_check */
1346
1347 /*
1348  * DASD_3990_ERP_OVERRUN
1349  *
1350  * DESCRIPTION
1351  *   Handles 24 byte 'Overrun' error.
1352  *
1353  * PARAMETER
1354  *   erp                current erp_head
1355  * RETURN VALUES
1356  *   erp                new erp_head - pointer to new ERP
1357  */
1358 static struct dasd_ccw_req *
1359 dasd_3990_erp_overrun(struct dasd_ccw_req * erp, char *sense)
1360 {
1361
1362         struct dasd_device *device = erp->device;
1363
1364         erp->function = dasd_3990_erp_overrun;
1365
1366         DEV_MESSAGE(KERN_DEBUG, device, "%s",
1367                     "Overrun - service overrun or overrun"
1368                     " error requested by channel");
1369
1370         erp = dasd_3990_erp_action_5(erp);
1371
1372         return erp;
1373
1374 }                               /* end dasd_3990_erp_overrun */
1375
1376 /*
1377  * DASD_3990_ERP_INV_FORMAT
1378  *
1379  * DESCRIPTION
1380  *   Handles 24 byte 'Invalid Track Format' error.
1381  *
1382  * PARAMETER
1383  *   erp                current erp_head
1384  * RETURN VALUES
1385  *   erp                new erp_head - pointer to new ERP
1386  */
1387 static struct dasd_ccw_req *
1388 dasd_3990_erp_inv_format(struct dasd_ccw_req * erp, char *sense)
1389 {
1390
1391         struct dasd_device *device = erp->device;
1392
1393         erp->function = dasd_3990_erp_inv_format;
1394
1395         if (sense[2] & SNS2_ENV_DATA_PRESENT) {
1396
1397                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1398                             "Track format error when destaging or "
1399                             "staging data");
1400
1401                 dasd_3990_handle_env_data(erp, sense);
1402
1403                 erp = dasd_3990_erp_action_4(erp, sense);
1404
1405         } else {
1406                 DEV_MESSAGE(KERN_ERR, device, "%s",
1407                             "Invalid Track Format - Fatal error should have "
1408                             "been handled within the interrupt handler");
1409
1410                 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
1411         }
1412
1413         return erp;
1414
1415 }                               /* end dasd_3990_erp_inv_format */
1416
1417 /*
1418  * DASD_3990_ERP_EOC
1419  *
1420  * DESCRIPTION
1421  *   Handles 24 byte 'End-of-Cylinder' error.
1422  *
1423  * PARAMETER
1424  *   erp                already added default erp
1425  * RETURN VALUES
1426  *   erp                pointer to original (failed) cqr.
1427  */
1428 static struct dasd_ccw_req *
1429 dasd_3990_erp_EOC(struct dasd_ccw_req * default_erp, char *sense)
1430 {
1431
1432         struct dasd_device *device = default_erp->device;
1433
1434         DEV_MESSAGE(KERN_ERR, device, "%s",
1435                     "End-of-Cylinder - must never happen");
1436
1437         /* implement action 7 - BUG */
1438         return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1439
1440 }                               /* end dasd_3990_erp_EOC */
1441
1442 /*
1443  * DASD_3990_ERP_ENV_DATA
1444  *
1445  * DESCRIPTION
1446  *   Handles 24 byte 'Environmental-Data Present' error.
1447  *
1448  * PARAMETER
1449  *   erp                current erp_head
1450  * RETURN VALUES
1451  *   erp                new erp_head - pointer to new ERP
1452  */
1453 static struct dasd_ccw_req *
1454 dasd_3990_erp_env_data(struct dasd_ccw_req * erp, char *sense)
1455 {
1456
1457         struct dasd_device *device = erp->device;
1458
1459         erp->function = dasd_3990_erp_env_data;
1460
1461         DEV_MESSAGE(KERN_DEBUG, device, "%s", "Environmental data present");
1462
1463         dasd_3990_handle_env_data(erp, sense);
1464
1465         /* don't retry on disabled interface */
1466         if (sense[7] != 0x0F) {
1467
1468                 erp = dasd_3990_erp_action_4(erp, sense);
1469         } else {
1470
1471                 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_IN_IO);
1472         }
1473
1474         return erp;
1475
1476 }                               /* end dasd_3990_erp_env_data */
1477
1478 /*
1479  * DASD_3990_ERP_NO_REC
1480  *
1481  * DESCRIPTION
1482  *   Handles 24 byte 'No Record Found' error.
1483  *
1484  * PARAMETER
1485  *   erp                already added default ERP
1486  *
1487  * RETURN VALUES
1488  *   erp                new erp_head - pointer to new ERP
1489  */
1490 static struct dasd_ccw_req *
1491 dasd_3990_erp_no_rec(struct dasd_ccw_req * default_erp, char *sense)
1492 {
1493
1494         struct dasd_device *device = default_erp->device;
1495
1496         DEV_MESSAGE(KERN_ERR, device, "%s",
1497                     "No Record Found - Fatal error should "
1498                     "have been handled within the interrupt handler");
1499
1500         return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1501
1502 }                               /* end dasd_3990_erp_no_rec */
1503
1504 /*
1505  * DASD_3990_ERP_FILE_PROT
1506  *
1507  * DESCRIPTION
1508  *   Handles 24 byte 'File Protected' error.
1509  *   Note: Seek related recovery is not implemented because
1510  *         wee don't use the seek command yet.
1511  *
1512  * PARAMETER
1513  *   erp                current erp_head
1514  * RETURN VALUES
1515  *   erp                new erp_head - pointer to new ERP
1516  */
1517 static struct dasd_ccw_req *
1518 dasd_3990_erp_file_prot(struct dasd_ccw_req * erp)
1519 {
1520
1521         struct dasd_device *device = erp->device;
1522
1523         DEV_MESSAGE(KERN_ERR, device, "%s", "File Protected");
1524
1525         return dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
1526
1527 }                               /* end dasd_3990_erp_file_prot */
1528
1529 /*
1530  * DASD_3990_ERP_INSPECT_24
1531  *
1532  * DESCRIPTION
1533  *   Does a detailed inspection of the 24 byte sense data
1534  *   and sets up a related error recovery action.
1535  *
1536  * PARAMETER
1537  *   sense              sense data of the actual error
1538  *   erp                pointer to the currently created default ERP
1539  *
1540  * RETURN VALUES
1541  *   erp                pointer to the (addtitional) ERP
1542  */
1543 static struct dasd_ccw_req *
1544 dasd_3990_erp_inspect_24(struct dasd_ccw_req * erp, char *sense)
1545 {
1546
1547         struct dasd_ccw_req *erp_filled = NULL;
1548
1549         /* Check sense for ....    */
1550         /* 'Command Reject'        */
1551         if ((erp_filled == NULL) && (sense[0] & SNS0_CMD_REJECT)) {
1552                 erp_filled = dasd_3990_erp_com_rej(erp, sense);
1553         }
1554         /* 'Intervention Required' */
1555         if ((erp_filled == NULL) && (sense[0] & SNS0_INTERVENTION_REQ)) {
1556                 erp_filled = dasd_3990_erp_int_req(erp);
1557         }
1558         /* 'Bus Out Parity Check'  */
1559         if ((erp_filled == NULL) && (sense[0] & SNS0_BUS_OUT_CHECK)) {
1560                 erp_filled = dasd_3990_erp_bus_out(erp);
1561         }
1562         /* 'Equipment Check'       */
1563         if ((erp_filled == NULL) && (sense[0] & SNS0_EQUIPMENT_CHECK)) {
1564                 erp_filled = dasd_3990_erp_equip_check(erp, sense);
1565         }
1566         /* 'Data Check'            */
1567         if ((erp_filled == NULL) && (sense[0] & SNS0_DATA_CHECK)) {
1568                 erp_filled = dasd_3990_erp_data_check(erp, sense);
1569         }
1570         /* 'Overrun'               */
1571         if ((erp_filled == NULL) && (sense[0] & SNS0_OVERRUN)) {
1572                 erp_filled = dasd_3990_erp_overrun(erp, sense);
1573         }
1574         /* 'Invalid Track Format'  */
1575         if ((erp_filled == NULL) && (sense[1] & SNS1_INV_TRACK_FORMAT)) {
1576                 erp_filled = dasd_3990_erp_inv_format(erp, sense);
1577         }
1578         /* 'End-of-Cylinder'       */
1579         if ((erp_filled == NULL) && (sense[1] & SNS1_EOC)) {
1580                 erp_filled = dasd_3990_erp_EOC(erp, sense);
1581         }
1582         /* 'Environmental Data'    */
1583         if ((erp_filled == NULL) && (sense[2] & SNS2_ENV_DATA_PRESENT)) {
1584                 erp_filled = dasd_3990_erp_env_data(erp, sense);
1585         }
1586         /* 'No Record Found'       */
1587         if ((erp_filled == NULL) && (sense[1] & SNS1_NO_REC_FOUND)) {
1588                 erp_filled = dasd_3990_erp_no_rec(erp, sense);
1589         }
1590         /* 'File Protected'        */
1591         if ((erp_filled == NULL) && (sense[1] & SNS1_FILE_PROTECTED)) {
1592                 erp_filled = dasd_3990_erp_file_prot(erp);
1593         }
1594         /* other (unknown) error - do default ERP */
1595         if (erp_filled == NULL) {
1596
1597                 erp_filled = erp;
1598         }
1599
1600         return erp_filled;
1601
1602 }                               /* END dasd_3990_erp_inspect_24 */
1603
1604 /*
1605  *****************************************************************************
1606  * 32 byte sense ERP functions (only)
1607  *****************************************************************************
1608  */
1609
1610 /*
1611  * DASD_3990_ERPACTION_10_32
1612  *
1613  * DESCRIPTION
1614  *   Handles 32 byte 'Action 10' of Single Program Action Codes.
1615  *   Just retry and if retry doesn't work, return with error.
1616  *
1617  * PARAMETER
1618  *   erp                current erp_head
1619  *   sense              current sense data
1620  * RETURN VALUES
1621  *   erp                modified erp_head
1622  */
1623 static struct dasd_ccw_req *
1624 dasd_3990_erp_action_10_32(struct dasd_ccw_req * erp, char *sense)
1625 {
1626
1627         struct dasd_device *device = erp->device;
1628
1629         erp->retries = 256;
1630         erp->function = dasd_3990_erp_action_10_32;
1631
1632         DEV_MESSAGE(KERN_DEBUG, device, "%s", "Perform logging requested");
1633
1634         return erp;
1635
1636 }                               /* end dasd_3990_erp_action_10_32 */
1637
1638 /*
1639  * DASD_3990_ERP_ACTION_1B_32
1640  *
1641  * DESCRIPTION
1642  *   Handles 32 byte 'Action 1B' of Single Program Action Codes.
1643  *   A write operation could not be finished because of an unexpected
1644  *   condition.
1645  *   The already created 'default erp' is used to get the link to
1646  *   the erp chain, but it can not be used for this recovery
1647  *   action because it contains no DE/LO data space.
1648  *
1649  * PARAMETER
1650  *   default_erp        already added default erp.
1651  *   sense              current sense data
1652  *
1653  * RETURN VALUES
1654  *   erp                new erp or
1655  *                      default_erp in case of imprecise ending or error
1656  */
1657 static struct dasd_ccw_req *
1658 dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
1659 {
1660
1661         struct dasd_device *device = default_erp->device;
1662         __u32 cpa = 0;
1663         struct dasd_ccw_req *cqr;
1664         struct dasd_ccw_req *erp;
1665         struct DE_eckd_data *DE_data;
1666         char *LO_data;          /* LO_eckd_data_t */
1667         struct ccw1 *ccw;
1668
1669         DEV_MESSAGE(KERN_DEBUG, device, "%s",
1670                     "Write not finished because of unexpected condition");
1671
1672         default_erp->function = dasd_3990_erp_action_1B_32;
1673
1674         /* determine the original cqr */
1675         cqr = default_erp;
1676
1677         while (cqr->refers != NULL) {
1678                 cqr = cqr->refers;
1679         }
1680
1681         /* for imprecise ending just do default erp */
1682         if (sense[1] & 0x01) {
1683
1684                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1685                             "Imprecise ending is set - just retry");
1686
1687                 return default_erp;
1688         }
1689
1690         /* determine the address of the CCW to be restarted */
1691         /* Imprecise ending is not set -> addr from IRB-SCSW */
1692         cpa = default_erp->refers->irb.scsw.cpa;
1693
1694         if (cpa == 0) {
1695
1696                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1697                             "Unable to determine address of the CCW "
1698                             "to be restarted");
1699
1700                 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1701         }
1702
1703         /* Build new ERP request including DE/LO */
1704         erp = dasd_alloc_erp_request((char *) &cqr->magic,
1705                                      2 + 1,/* DE/LO + TIC */
1706                                      sizeof (struct DE_eckd_data) +
1707                                      sizeof (struct LO_eckd_data), device);
1708
1709         if (IS_ERR(erp)) {
1710                 DEV_MESSAGE(KERN_ERR, device, "%s", "Unable to allocate ERP");
1711                 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1712         }
1713
1714         /* use original DE */
1715         DE_data = erp->data;
1716         memcpy(DE_data, cqr->data, sizeof (struct DE_eckd_data));
1717
1718         /* create LO */
1719         LO_data = erp->data + sizeof (struct DE_eckd_data);
1720
1721         if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) {
1722
1723                 DEV_MESSAGE(KERN_ERR, device, "%s",
1724                             "BUG - this should not happen");
1725
1726                 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED);
1727         }
1728
1729         if ((sense[7] & 0x3F) == 0x01) {
1730                 /* operation code is WRITE DATA -> data area orientation */
1731                 LO_data[0] = 0x81;
1732
1733         } else if ((sense[7] & 0x3F) == 0x03) {
1734                 /* operation code is FORMAT WRITE -> index orientation */
1735                 LO_data[0] = 0xC3;
1736
1737         } else {
1738                 LO_data[0] = sense[7];  /* operation */
1739         }
1740
1741         LO_data[1] = sense[8];  /* auxiliary */
1742         LO_data[2] = sense[9];
1743         LO_data[3] = sense[3];  /* count */
1744         LO_data[4] = sense[29]; /* seek_addr.cyl */
1745         LO_data[5] = sense[30]; /* seek_addr.cyl 2nd byte */
1746         LO_data[7] = sense[31]; /* seek_addr.head 2nd byte */
1747
1748         memcpy(&(LO_data[8]), &(sense[11]), 8);
1749
1750         /* create DE ccw */
1751         ccw = erp->cpaddr;
1752         memset(ccw, 0, sizeof (struct ccw1));
1753         ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT;
1754         ccw->flags = CCW_FLAG_CC;
1755         ccw->count = 16;
1756         ccw->cda = (__u32)(addr_t) DE_data;
1757
1758         /* create LO ccw */
1759         ccw++;
1760         memset(ccw, 0, sizeof (struct ccw1));
1761         ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD;
1762         ccw->flags = CCW_FLAG_CC;
1763         ccw->count = 16;
1764         ccw->cda = (__u32)(addr_t) LO_data;
1765
1766         /* TIC to the failed ccw */
1767         ccw++;
1768         ccw->cmd_code = CCW_CMD_TIC;
1769         ccw->cda = cpa;
1770
1771         /* fill erp related fields */
1772         erp->function = dasd_3990_erp_action_1B_32;
1773         erp->refers = default_erp->refers;
1774         erp->device = device;
1775         erp->magic = default_erp->magic;
1776         erp->expires = 0;
1777         erp->retries = 256;
1778         erp->buildclk = get_clock();
1779         erp->status = DASD_CQR_FILLED;
1780
1781         /* remove the default erp */
1782         dasd_free_erp_request(default_erp, device);
1783
1784         return erp;
1785
1786 }                               /* end dasd_3990_erp_action_1B_32 */
1787
1788 /*
1789  * DASD_3990_UPDATE_1B
1790  *
1791  * DESCRIPTION
1792  *   Handles the update to the 32 byte 'Action 1B' of Single Program
1793  *   Action Codes in case the first action was not successful.
1794  *   The already created 'previous_erp' is the currently not successful
1795  *   ERP.
1796  *
1797  * PARAMETER
1798  *   previous_erp       already created previous erp.
1799  *   sense              current sense data
1800  * RETURN VALUES
1801  *   erp                modified erp
1802  */
1803 static struct dasd_ccw_req *
1804 dasd_3990_update_1B(struct dasd_ccw_req * previous_erp, char *sense)
1805 {
1806
1807         struct dasd_device *device = previous_erp->device;
1808         __u32 cpa = 0;
1809         struct dasd_ccw_req *cqr;
1810         struct dasd_ccw_req *erp;
1811         char *LO_data;          /* struct LO_eckd_data */
1812         struct ccw1 *ccw;
1813
1814         DEV_MESSAGE(KERN_DEBUG, device, "%s",
1815                     "Write not finished because of unexpected condition"
1816                     " - follow on");
1817
1818         /* determine the original cqr */
1819         cqr = previous_erp;
1820
1821         while (cqr->refers != NULL) {
1822                 cqr = cqr->refers;
1823         }
1824
1825         /* for imprecise ending just do default erp */
1826         if (sense[1] & 0x01) {
1827
1828                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1829                             "Imprecise ending is set - just retry");
1830
1831                 previous_erp->status = DASD_CQR_QUEUED;
1832
1833                 return previous_erp;
1834         }
1835
1836         /* determine the address of the CCW to be restarted */
1837         /* Imprecise ending is not set -> addr from IRB-SCSW */
1838         cpa = previous_erp->irb.scsw.cpa;
1839
1840         if (cpa == 0) {
1841
1842                 DEV_MESSAGE(KERN_DEBUG, device, "%s",
1843                             "Unable to determine address of the CCW "
1844                             "to be restarted");
1845
1846                 previous_erp->status = DASD_CQR_FAILED;
1847
1848                 return previous_erp;
1849         }
1850
1851         erp = previous_erp;
1852
1853         /* update the LO with the new returned sense data  */
1854         LO_data = erp->data + sizeof (struct DE_eckd_data);
1855
1856         if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) {
1857
1858                 DEV_MESSAGE(KERN_ERR, device, "%s",
1859                             "BUG - this should not happen");
1860
1861                 previous_erp->status = DASD_CQR_FAILED;
1862
1863                 return previous_erp;
1864         }
1865
1866         if ((sense[7] & 0x3F) == 0x01) {
1867                 /* operation code is WRITE DATA -> data area orientation */
1868                 LO_data[0] = 0x81;
1869
1870         } else if ((sense[7] & 0x3F) == 0x03) {
1871                 /* operation code is FORMAT WRITE -> index orientation */
1872                 LO_data[0] = 0xC3;
1873
1874         } else {
1875                 LO_data[0] = sense[7];  /* operation */
1876         }
1877
1878         LO_data[1] = sense[8];  /* auxiliary */
1879         LO_data[2] = sense[9];
1880         LO_data[3] = sense[3];  /* count */
1881         LO_data[4] = sense[29]; /* seek_addr.cyl */
1882         LO_data[5] = sense[30]; /* seek_addr.cyl 2nd byte */
1883         LO_data[7] = sense[31]; /* seek_addr.head 2nd byte */
1884
1885         memcpy(&(LO_data[8]), &(sense[11]), 8);
1886
1887         /* TIC to the failed ccw */
1888         ccw = erp->cpaddr;      /* addr of DE ccw */
1889         ccw++;                  /* addr of LE ccw */
1890         ccw++;                  /* addr of TIC ccw */
1891         ccw->cda = cpa;
1892
1893         erp->status = DASD_CQR_QUEUED;
1894
1895         return erp;
1896
1897 }                               /* end dasd_3990_update_1B */
1898
1899 /*
1900  * DASD_3990_ERP_COMPOUND_RETRY
1901  *
1902  * DESCRIPTION
1903  *   Handles the compound ERP action retry code.
1904  *   NOTE: At least one retry is done even if zero is specified
1905  *         by the sense data. This makes enqueueing of the request
1906  *         easier.
1907  *
1908  * PARAMETER
1909  *   sense              sense data of the actual error
1910  *   erp                pointer to the currently created ERP
1911  *
1912  * RETURN VALUES
1913  *   erp                modified ERP pointer
1914  *
1915  */
1916 static void
1917 dasd_3990_erp_compound_retry(struct dasd_ccw_req * erp, char *sense)
1918 {
1919
1920         switch (sense[25] & 0x03) {
1921         case 0x00:              /* no not retry */
1922                 erp->retries = 1;
1923                 break;
1924
1925         case 0x01:              /* retry 2 times */
1926                 erp->retries = 2;
1927                 break;
1928
1929         case 0x02:              /* retry 10 times */
1930                 erp->retries = 10;
1931                 break;
1932
1933         case 0x03:              /* retry 256 times */
1934                 erp->retries = 256;
1935                 break;
1936
1937         default:
1938                 BUG();
1939         }
1940
1941         erp->function = dasd_3990_erp_compound_retry;
1942
1943 }                               /* end dasd_3990_erp_compound_retry */
1944
1945 /*
1946  * DASD_3990_ERP_COMPOUND_PATH
1947  *
1948  * DESCRIPTION
1949  *   Handles the compound ERP action for retry on alternate
1950  *   channel path.
1951  *
1952  * PARAMETER
1953  *   sense              sense data of the actual error
1954  *   erp                pointer to the currently created ERP
1955  *
1956  * RETURN VALUES
1957  *   erp                modified ERP pointer
1958  *
1959  */
1960 static void
1961 dasd_3990_erp_compound_path(struct dasd_ccw_req * erp, char *sense)
1962 {
1963
1964         if (sense[25] & DASD_SENSE_BIT_3) {
1965                 dasd_3990_erp_alternate_path(erp);
1966
1967                 if (erp->status == DASD_CQR_FAILED) {
1968                         /* reset the lpm and the status to be able to
1969                          * try further actions. */
1970
1971                         erp->lpm = 0;
1972
1973                         erp->status = DASD_CQR_ERROR;
1974
1975                 }
1976         }
1977
1978         erp->function = dasd_3990_erp_compound_path;
1979
1980 }                               /* end dasd_3990_erp_compound_path */
1981
1982 /*
1983  * DASD_3990_ERP_COMPOUND_CODE
1984  *
1985  * DESCRIPTION
1986  *   Handles the compound ERP action for retry code.
1987  *
1988  * PARAMETER
1989  *   sense              sense data of the actual error
1990  *   erp                pointer to the currently created ERP
1991  *
1992  * RETURN VALUES
1993  *   erp                NEW ERP pointer
1994  *
1995  */
1996 static struct dasd_ccw_req *
1997 dasd_3990_erp_compound_code(struct dasd_ccw_req * erp, char *sense)
1998 {
1999
2000         if (sense[25] & DASD_SENSE_BIT_2) {
2001
2002                 switch (sense[28]) {
2003                 case 0x17:
2004                         /* issue a Diagnostic Control command with an
2005                          * Inhibit Write subcommand and controler modifier */
2006                         erp = dasd_3990_erp_DCTL(erp, 0x20);
2007                         break;
2008
2009                 case 0x25:
2010                         /* wait for 5 seconds and retry again */
2011                         erp->retries = 1;
2012
2013                         dasd_3990_erp_block_queue (erp, 5*HZ);
2014                         break;
2015
2016                 default:
2017                         /* should not happen - continue */
2018                         break;
2019                 }
2020         }
2021
2022         erp->function = dasd_3990_erp_compound_code;
2023
2024         return erp;
2025
2026 }                               /* end dasd_3990_erp_compound_code */
2027
2028 /*
2029  * DASD_3990_ERP_COMPOUND_CONFIG
2030  *
2031  * DESCRIPTION
2032  *   Handles the compound ERP action for configruation
2033  *   dependent error.
2034  *   Note: duplex handling is not implemented (yet).
2035  *
2036  * PARAMETER
2037  *   sense              sense data of the actual error
2038  *   erp                pointer to the currently created ERP
2039  *
2040  * RETURN VALUES
2041  *   erp                modified ERP pointer
2042  *
2043  */
2044 static void
2045 dasd_3990_erp_compound_config(struct dasd_ccw_req * erp, char *sense)
2046 {
2047
2048         if ((sense[25] & DASD_SENSE_BIT_1) && (sense[26] & DASD_SENSE_BIT_2)) {
2049
2050                 /* set to suspended duplex state then restart */
2051                 struct dasd_device *device = erp->device;
2052
2053                 DEV_MESSAGE(KERN_ERR, device, "%s",
2054                             "Set device to suspended duplex state should be "
2055                             "done!\n"
2056                             "This is not implemented yet (for compound ERP)"
2057                             " - please report to linux390@de.ibm.com");
2058
2059         }
2060
2061         erp->function = dasd_3990_erp_compound_config;
2062
2063 }                               /* end dasd_3990_erp_compound_config */
2064
2065 /*
2066  * DASD_3990_ERP_COMPOUND
2067  *
2068  * DESCRIPTION
2069  *   Does the further compound program action if
2070  *   compound retry was not successful.
2071  *
2072  * PARAMETER
2073  *   sense              sense data of the actual error
2074  *   erp                pointer to the current (failed) ERP
2075  *
2076  * RETURN VALUES
2077  *   erp                (additional) ERP pointer
2078  *
2079  */
2080 static struct dasd_ccw_req *
2081 dasd_3990_erp_compound(struct dasd_ccw_req * erp, char *sense)
2082 {
2083
2084         if ((erp->function == dasd_3990_erp_compound_retry) &&
2085             (erp->status == DASD_CQR_ERROR)) {
2086
2087                 dasd_3990_erp_compound_path(erp, sense);
2088         }
2089
2090         if ((erp->function == dasd_3990_erp_compound_path) &&
2091             (erp->status == DASD_CQR_ERROR)) {
2092
2093                 erp = dasd_3990_erp_compound_code(erp, sense);
2094         }
2095
2096         if ((erp->function == dasd_3990_erp_compound_code) &&
2097             (erp->status == DASD_CQR_ERROR)) {
2098
2099                 dasd_3990_erp_compound_config(erp, sense);
2100         }
2101
2102         /* if no compound action ERP specified, the request failed */
2103         if (erp->status == DASD_CQR_ERROR) {
2104
2105                 erp->status = DASD_CQR_FAILED;
2106         }
2107
2108         return erp;
2109
2110 }                               /* end dasd_3990_erp_compound */
2111
2112 /*
2113  * DASD_3990_ERP_INSPECT_32
2114  *
2115  * DESCRIPTION
2116  *   Does a detailed inspection of the 32 byte sense data
2117  *   and sets up a related error recovery action.
2118  *
2119  * PARAMETER
2120  *   sense              sense data of the actual error
2121  *   erp                pointer to the currently created default ERP
2122  *
2123  * RETURN VALUES
2124  *   erp_filled         pointer to the ERP
2125  *
2126  */
2127 static struct dasd_ccw_req *
2128 dasd_3990_erp_inspect_32(struct dasd_ccw_req * erp, char *sense)
2129 {
2130
2131         struct dasd_device *device = erp->device;
2132
2133         erp->function = dasd_3990_erp_inspect_32;
2134
2135         if (sense[25] & DASD_SENSE_BIT_0) {
2136
2137                 /* compound program action codes (byte25 bit 0 == '1') */
2138                 dasd_3990_erp_compound_retry(erp, sense);
2139
2140         } else {
2141
2142                 /* single program action codes (byte25 bit 0 == '0') */
2143                 switch (sense[25]) {
2144
2145                 case 0x00:      /* success - use default ERP for retries */
2146                         DEV_MESSAGE(KERN_DEBUG, device, "%s",
2147                                     "ERP called for successful request"
2148                                     " - just retry");
2149                         break;
2150
2151                 case 0x01:      /* fatal error */
2152                         DEV_MESSAGE(KERN_ERR, device, "%s",
2153                                     "Fatal error should have been "
2154                                     "handled within the interrupt handler");
2155
2156                         erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
2157                         break;
2158
2159                 case 0x02:      /* intervention required */
2160                 case 0x03:      /* intervention required during dual copy */
2161                         erp = dasd_3990_erp_int_req(erp);
2162                         break;
2163
2164                 case 0x0F:  /* length mismatch during update write command */
2165                         DEV_MESSAGE(KERN_ERR, device, "%s",
2166                                     "update write command error - should not "
2167                                     "happen;\n"
2168                                     "Please send this message together with "
2169                                     "the above sense data to linux390@de."
2170                                     "ibm.com");
2171
2172                         erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
2173                         break;
2174
2175                 case 0x10:  /* logging required for other channel program */
2176                         erp = dasd_3990_erp_action_10_32(erp, sense);
2177                         break;
2178
2179                 case 0x15:      /* next track outside defined extend */
2180                         DEV_MESSAGE(KERN_ERR, device, "%s",
2181                                     "next track outside defined extend - "
2182                                     "should not happen;\n"
2183                                     "Please send this message together with "
2184                                     "the above sense data to linux390@de."
2185                                     "ibm.com");
2186
2187                         erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
2188                         break;
2189
2190                 case 0x1B:      /* unexpected condition during write */
2191
2192                         erp = dasd_3990_erp_action_1B_32(erp, sense);
2193                         break;
2194
2195                 case 0x1C:      /* invalid data */
2196                         DEV_MESSAGE(KERN_EMERG, device, "%s",
2197                                     "Data recovered during retry with PCI "
2198                                     "fetch mode active");
2199
2200                         /* not possible to handle this situation in Linux */
2201                         panic
2202                             ("Invalid data - No way to inform application "
2203                              "about the possibly incorrect data");
2204                         break;
2205
2206                 case 0x1D:      /* state-change pending */
2207                         DEV_MESSAGE(KERN_DEBUG, device, "%s",
2208                                     "A State change pending condition exists "
2209                                     "for the subsystem or device");
2210
2211                         erp = dasd_3990_erp_action_4(erp, sense);
2212                         break;
2213
2214                 case 0x1E:      /* busy */
2215                         DEV_MESSAGE(KERN_DEBUG, device, "%s",
2216                                     "Busy condition exists "
2217                                     "for the subsystem or device");
2218                         erp = dasd_3990_erp_action_4(erp, sense);
2219                         break;
2220
2221                 default:        /* all others errors - default erp  */
2222                         break;
2223                 }
2224         }
2225
2226         return erp;
2227
2228 }                               /* end dasd_3990_erp_inspect_32 */
2229
2230 /*
2231  *****************************************************************************
2232  * main ERP control fuctions (24 and 32 byte sense)
2233  *****************************************************************************
2234  */
2235
2236 /*
2237  * DASD_3990_ERP_INSPECT
2238  *
2239  * DESCRIPTION
2240  *   Does a detailed inspection for sense data by calling either
2241  *   the 24-byte or the 32-byte inspection routine.
2242  *
2243  * PARAMETER
2244  *   erp                pointer to the currently created default ERP
2245  * RETURN VALUES
2246  *   erp_new            contens was possibly modified
2247  */
2248 static struct dasd_ccw_req *
2249 dasd_3990_erp_inspect(struct dasd_ccw_req * erp)
2250 {
2251
2252         struct dasd_ccw_req *erp_new = NULL;
2253         /* sense data are located in the refers record of the */
2254         /* already set up new ERP !                           */
2255         char *sense = erp->refers->irb.ecw;
2256
2257         /* distinguish between 24 and 32 byte sense data */
2258         if (sense[27] & DASD_SENSE_BIT_0) {
2259
2260                 /* inspect the 24 byte sense data */
2261                 erp_new = dasd_3990_erp_inspect_24(erp, sense);
2262
2263         } else {
2264
2265                 /* inspect the 32 byte sense data */
2266                 erp_new = dasd_3990_erp_inspect_32(erp, sense);
2267
2268         }       /* end distinguish between 24 and 32 byte sense data */
2269
2270         return erp_new;
2271 }
2272
2273 /*
2274  * DASD_3990_ERP_ADD_ERP
2275  *
2276  * DESCRIPTION
2277  *   This funtion adds an additional request block (ERP) to the head of
2278  *   the given cqr (or erp).
2279  *   This erp is initialized as an default erp (retry TIC)
2280  *
2281  * PARAMETER
2282  *   cqr                head of the current ERP-chain (or single cqr if
2283  *                      first error)
2284  * RETURN VALUES
2285  *   erp                pointer to new ERP-chain head
2286  */
2287 static struct dasd_ccw_req *
2288 dasd_3990_erp_add_erp(struct dasd_ccw_req * cqr)
2289 {
2290
2291         struct dasd_device *device = cqr->device;
2292         struct ccw1 *ccw;
2293
2294         /* allocate additional request block */
2295         struct dasd_ccw_req *erp;
2296
2297         erp = dasd_alloc_erp_request((char *) &cqr->magic, 2, 0, cqr->device);
2298         if (IS_ERR(erp)) {
2299                 if (cqr->retries <= 0) {
2300                         DEV_MESSAGE(KERN_ERR, device, "%s",
2301                                     "Unable to allocate ERP request");
2302                         cqr->status = DASD_CQR_FAILED;
2303                         cqr->stopclk = get_clock ();
2304                 } else {
2305                         DEV_MESSAGE (KERN_ERR, device,
2306                                      "Unable to allocate ERP request "
2307                                      "(%i retries left)",
2308                                      cqr->retries);
2309                         dasd_set_timer(device, (HZ << 3));
2310                 }
2311                 return cqr;
2312         }
2313
2314         /* initialize request with default TIC to current ERP/CQR */
2315         ccw = erp->cpaddr;
2316         ccw->cmd_code = CCW_CMD_NOOP;
2317         ccw->flags = CCW_FLAG_CC;
2318         ccw++;
2319         ccw->cmd_code = CCW_CMD_TIC;
2320         ccw->cda      = (long)(cqr->cpaddr);
2321         erp->function = dasd_3990_erp_add_erp;
2322         erp->refers   = cqr;
2323         erp->device   = cqr->device;
2324         erp->magic    = cqr->magic;
2325         erp->expires  = 0;
2326         erp->retries  = 256;
2327         erp->buildclk = get_clock();
2328
2329         erp->status = DASD_CQR_FILLED;
2330
2331         return erp;
2332 }
2333
2334 /*
2335  * DASD_3990_ERP_ADDITIONAL_ERP
2336  *
2337  * DESCRIPTION
2338  *   An additional ERP is needed to handle the current error.
2339  *   Add ERP to the head of the ERP-chain containing the ERP processing
2340  *   determined based on the sense data.
2341  *
2342  * PARAMETER
2343  *   cqr                head of the current ERP-chain (or single cqr if
2344  *                      first error)
2345  *
2346  * RETURN VALUES
2347  *   erp                pointer to new ERP-chain head
2348  */
2349 static struct dasd_ccw_req *
2350 dasd_3990_erp_additional_erp(struct dasd_ccw_req * cqr)
2351 {
2352
2353         struct dasd_ccw_req *erp = NULL;
2354
2355         /* add erp and initialize with default TIC */
2356         erp = dasd_3990_erp_add_erp(cqr);
2357
2358         /* inspect sense, determine specific ERP if possible */
2359         if (erp != cqr) {
2360
2361                 erp = dasd_3990_erp_inspect(erp);
2362         }
2363
2364         return erp;
2365
2366 }                               /* end dasd_3990_erp_additional_erp */
2367
2368 /*
2369  * DASD_3990_ERP_ERROR_MATCH
2370  *
2371  * DESCRIPTION
2372  *   Check if the device status of the given cqr is the same.
2373  *   This means that the failed CCW and the relevant sense data
2374  *   must match.
2375  *   I don't distinguish between 24 and 32 byte sense because in case of
2376  *   24 byte sense byte 25 and 27 is set as well.
2377  *
2378  * PARAMETER
2379  *   cqr1               first cqr, which will be compared with the
2380  *   cqr2               second cqr.
2381  *
2382  * RETURN VALUES
2383  *   match              'boolean' for match found
2384  *                      returns 1 if match found, otherwise 0.
2385  */
2386 static int
2387 dasd_3990_erp_error_match(struct dasd_ccw_req *cqr1, struct dasd_ccw_req *cqr2)
2388 {
2389
2390         /* check failed CCW */
2391         if (cqr1->irb.scsw.cpa != cqr2->irb.scsw.cpa) {
2392                 //      return 0;       /* CCW doesn't match */
2393         }
2394
2395         /* check sense data; byte 0-2,25,27 */
2396         if (!((memcmp (cqr1->irb.ecw, cqr2->irb.ecw, 3) == 0) &&
2397               (cqr1->irb.ecw[27] == cqr2->irb.ecw[27]) &&
2398               (cqr1->irb.ecw[25] == cqr2->irb.ecw[25]))) {
2399
2400                 return 0;       /* sense doesn't match */
2401         }
2402
2403         return 1;               /* match */
2404
2405 }                               /* end dasd_3990_erp_error_match */
2406
2407 /*
2408  * DASD_3990_ERP_IN_ERP
2409  *
2410  * DESCRIPTION
2411  *   check if the current error already happened before.
2412  *   quick exit if current cqr is not an ERP (cqr->refers=NULL)
2413  *
2414  * PARAMETER
2415  *   cqr                failed cqr (either original cqr or already an erp)
2416  *
2417  * RETURN VALUES
2418  *   erp                erp-pointer to the already defined error
2419  *                      recovery procedure OR
2420  *                      NULL if a 'new' error occurred.
2421  */
2422 static struct dasd_ccw_req *
2423 dasd_3990_erp_in_erp(struct dasd_ccw_req *cqr)
2424 {
2425
2426         struct dasd_ccw_req *erp_head = cqr,    /* save erp chain head */
2427         *erp_match = NULL;      /* save erp chain head */
2428         int match = 0;          /* 'boolean' for matching error found */
2429
2430         if (cqr->refers == NULL) {      /* return if not in erp */
2431                 return NULL;
2432         }
2433
2434         /* check the erp/cqr chain for current error */
2435         do {
2436                 match = dasd_3990_erp_error_match(erp_head, cqr->refers);
2437                 erp_match = cqr;        /* save possible matching erp  */
2438                 cqr = cqr->refers;      /* check next erp/cqr in queue */
2439
2440         } while ((cqr->refers != NULL) && (!match));
2441
2442         if (!match) {
2443                 return NULL;    /* no match was found */
2444         }
2445
2446         return erp_match;       /* return address of matching erp */
2447
2448 }                               /* END dasd_3990_erp_in_erp */
2449
2450 /*
2451  * DASD_3990_ERP_FURTHER_ERP (24 & 32 byte sense)
2452  *
2453  * DESCRIPTION
2454  *   No retry is left for the current ERP. Check what has to be done
2455  *   with the ERP.
2456  *     - do further defined ERP action or
2457  *     - wait for interrupt or
2458  *     - exit with permanent error
2459  *
2460  * PARAMETER
2461  *   erp                ERP which is in progress with no retry left
2462  *
2463  * RETURN VALUES
2464  *   erp                modified/additional ERP
2465  */
2466 static struct dasd_ccw_req *
2467 dasd_3990_erp_further_erp(struct dasd_ccw_req *erp)
2468 {
2469
2470         struct dasd_device *device = erp->device;
2471         char *sense = erp->irb.ecw;
2472
2473         /* check for 24 byte sense ERP */
2474         if ((erp->function == dasd_3990_erp_bus_out) ||
2475             (erp->function == dasd_3990_erp_action_1) ||
2476             (erp->function == dasd_3990_erp_action_4)) {
2477
2478                 erp = dasd_3990_erp_action_1(erp);
2479
2480         } else if (erp->function == dasd_3990_erp_action_5) {
2481
2482                 /* retries have not been successful */
2483                 /* prepare erp for retry on different channel path */
2484                 erp = dasd_3990_erp_action_1(erp);
2485
2486                 if (!(sense[2] & DASD_SENSE_BIT_0)) {
2487
2488                         /* issue a Diagnostic Control command with an
2489                          * Inhibit Write subcommand */
2490
2491                         switch (sense[25]) {
2492                         case 0x17:
2493                         case 0x57:{     /* controller */
2494                                         erp = dasd_3990_erp_DCTL(erp, 0x20);
2495                                         break;
2496                                 }
2497                         case 0x18:
2498                         case 0x58:{     /* channel path */
2499                                         erp = dasd_3990_erp_DCTL(erp, 0x40);
2500                                         break;
2501                                 }
2502                         case 0x19:
2503                         case 0x59:{     /* storage director */
2504                                         erp = dasd_3990_erp_DCTL(erp, 0x80);
2505                                         break;
2506                                 }
2507                         default:
2508                                 DEV_MESSAGE(KERN_DEBUG, device,
2509                                             "invalid subcommand modifier 0x%x "
2510                                             "for Diagnostic Control Command",
2511                                             sense[25]);
2512                         }
2513                 }
2514
2515                 /* check for 32 byte sense ERP */
2516         } else if ((erp->function == dasd_3990_erp_compound_retry) ||
2517                    (erp->function == dasd_3990_erp_compound_path) ||
2518                    (erp->function == dasd_3990_erp_compound_code) ||
2519                    (erp->function == dasd_3990_erp_compound_config)) {
2520
2521                 erp = dasd_3990_erp_compound(erp, sense);
2522
2523         } else {
2524                 /* No retry left and no additional special handling */
2525                 /*necessary */
2526                 DEV_MESSAGE(KERN_ERR, device,
2527                             "no retries left for erp %p - "
2528                             "set status to FAILED", erp);
2529
2530                 erp->status = DASD_CQR_FAILED;
2531         }
2532
2533         return erp;
2534
2535 }                               /* end dasd_3990_erp_further_erp */
2536
2537 /*
2538  * DASD_3990_ERP_HANDLE_MATCH_ERP
2539  *
2540  * DESCRIPTION
2541  *   An error occurred again and an ERP has been detected which is already
2542  *   used to handle this error (e.g. retries).
2543  *   All prior ERP's are asumed to be successful and therefore removed
2544  *   from queue.
2545  *   If retry counter of matching erp is already 0, it is checked if further
2546  *   action is needed (besides retry) or if the ERP has failed.
2547  *
2548  * PARAMETER
2549  *   erp_head           first ERP in ERP-chain
2550  *   erp                ERP that handles the actual error.
2551  *                      (matching erp)
2552  *
2553  * RETURN VALUES
2554  *   erp                modified/additional ERP
2555  */
2556 static struct dasd_ccw_req *
2557 dasd_3990_erp_handle_match_erp(struct dasd_ccw_req *erp_head,
2558                                struct dasd_ccw_req *erp)
2559 {
2560
2561         struct dasd_device *device = erp_head->device;
2562         struct dasd_ccw_req *erp_done = erp_head;       /* finished req */
2563         struct dasd_ccw_req *erp_free = NULL;   /* req to be freed */
2564
2565         /* loop over successful ERPs and remove them from chanq */
2566         while (erp_done != erp) {
2567
2568                 if (erp_done == NULL)   /* end of chain reached */
2569                         panic(PRINTK_HEADER "Programming error in ERP! The "
2570                               "original request was lost\n");
2571
2572                 /* remove the request from the device queue */
2573                 list_del(&erp_done->list);
2574
2575                 erp_free = erp_done;
2576                 erp_done = erp_done->refers;
2577
2578                 /* free the finished erp request */
2579                 dasd_free_erp_request(erp_free, erp_free->device);
2580
2581         }                       /* end while */
2582
2583         if (erp->retries > 0) {
2584
2585                 char *sense = erp->refers->irb.ecw;
2586
2587                 /* check for special retries */
2588                 if (erp->function == dasd_3990_erp_action_4) {
2589
2590                         erp = dasd_3990_erp_action_4(erp, sense);
2591
2592                 } else if (erp->function == dasd_3990_erp_action_1B_32) {
2593
2594                         erp = dasd_3990_update_1B(erp, sense);
2595
2596                 } else if (erp->function == dasd_3990_erp_int_req) {
2597
2598                         erp = dasd_3990_erp_int_req(erp);
2599
2600                 } else {
2601                         /* simple retry   */
2602                         DEV_MESSAGE(KERN_DEBUG, device,
2603                                     "%i retries left for erp %p",
2604                                     erp->retries, erp);
2605
2606                         /* handle the request again... */
2607                         erp->status = DASD_CQR_QUEUED;
2608                 }
2609
2610         } else {
2611                 /* no retry left - check for further necessary action    */
2612                 /* if no further actions, handle rest as permanent error */
2613                 erp = dasd_3990_erp_further_erp(erp);
2614         }
2615
2616         return erp;
2617
2618 }                               /* end dasd_3990_erp_handle_match_erp */
2619
2620 /*
2621  * DASD_3990_ERP_ACTION
2622  *
2623  * DESCRIPTION
2624  *   controll routine for 3990 erp actions.
2625  *   Has to be called with the queue lock (namely the s390_irq_lock) acquired.
2626  *
2627  * PARAMETER
2628  *   cqr                failed cqr (either original cqr or already an erp)
2629  *
2630  * RETURN VALUES
2631  *   erp                erp-pointer to the head of the ERP action chain.
2632  *                      This means:
2633  *                       - either a ptr to an additional ERP cqr or
2634  *                       - the original given cqr (which's status might
2635  *                         be modified)
2636  */
2637 struct dasd_ccw_req *
2638 dasd_3990_erp_action(struct dasd_ccw_req * cqr)
2639 {
2640
2641         struct dasd_ccw_req *erp = NULL;
2642         struct dasd_device *device = cqr->device;
2643         __u32 cpa = cqr->irb.scsw.cpa;
2644
2645 #ifdef ERP_DEBUG
2646         /* print current erp_chain */
2647         DEV_MESSAGE(KERN_ERR, device, "%s",
2648                     "ERP chain at BEGINNING of ERP-ACTION");
2649         {
2650                 struct dasd_ccw_req *temp_erp = NULL;
2651
2652                 for (temp_erp = cqr;
2653                      temp_erp != NULL; temp_erp = temp_erp->refers) {
2654
2655                         DEV_MESSAGE(KERN_ERR, device,
2656                                     "   erp %p (%02x) refers to %p",
2657                                     temp_erp, temp_erp->status,
2658                                     temp_erp->refers);
2659                 }
2660         }
2661 #endif                          /* ERP_DEBUG */
2662
2663         /* double-check if current erp/cqr was successfull */
2664         if ((cqr->irb.scsw.cstat == 0x00) &&
2665             (cqr->irb.scsw.dstat == (DEV_STAT_CHN_END|DEV_STAT_DEV_END))) {
2666
2667                 DEV_MESSAGE(KERN_DEBUG, device,
2668                             "ERP called for successful request %p"
2669                             " - NO ERP necessary", cqr);
2670
2671                 cqr->status = DASD_CQR_DONE;
2672
2673                 return cqr;
2674         }
2675         /* check if sense data are available */
2676         if (!cqr->irb.ecw) {
2677                 DEV_MESSAGE(KERN_DEBUG, device,
2678                             "ERP called witout sense data avail ..."
2679                             "request %p - NO ERP possible", cqr);
2680
2681                 cqr->status = DASD_CQR_FAILED;
2682
2683                 return cqr;
2684
2685         }
2686
2687         /* check if error happened before */
2688         erp = dasd_3990_erp_in_erp(cqr);
2689
2690         if (erp == NULL) {
2691                 /* no matching erp found - set up erp */
2692                 erp = dasd_3990_erp_additional_erp(cqr);
2693         } else {
2694                 /* matching erp found - set all leading erp's to DONE */
2695                 erp = dasd_3990_erp_handle_match_erp(cqr, erp);
2696         }
2697
2698 #ifdef ERP_DEBUG
2699         /* print current erp_chain */
2700         DEV_MESSAGE(KERN_ERR, device, "%s", "ERP chain at END of ERP-ACTION");
2701         {
2702                 struct dasd_ccw_req *temp_erp = NULL;
2703                 for (temp_erp = erp;
2704                      temp_erp != NULL; temp_erp = temp_erp->refers) {
2705
2706                         DEV_MESSAGE(KERN_ERR, device,
2707                                     "   erp %p (%02x) refers to %p",
2708                                     temp_erp, temp_erp->status,
2709                                     temp_erp->refers);
2710                 }
2711         }
2712 #endif                          /* ERP_DEBUG */
2713
2714         if (erp->status == DASD_CQR_FAILED)
2715                 dasd_log_ccw(erp, 1, cpa);
2716
2717         /* enqueue added ERP request */
2718         if (erp->status == DASD_CQR_FILLED) {
2719                 erp->status = DASD_CQR_QUEUED;
2720                 list_add(&erp->list, &device->ccw_queue);
2721         }
2722
2723         return erp;
2724
2725 }                               /* end dasd_3990_erp_action */