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