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