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