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