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