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 */ 2716