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(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)virt_to_phys(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 if (sense[7] == SNS7_INVALID_ON_SEC) { 1054 dev_err(&device->cdev->dev, "An I/O request was rejected on a copy pair secondary device\n"); 1055 /* suppress dump of sense data for this error */ 1056 set_bit(DASD_CQR_SUPPRESS_CR, &erp->refers->flags); 1057 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED); 1058 } else { 1059 /* fatal error - set status to FAILED 1060 internal error 09 - Command Reject */ 1061 if (!test_bit(DASD_CQR_SUPPRESS_CR, &erp->flags)) 1062 dev_err(&device->cdev->dev, 1063 "An error occurred in the DASD device driver, reason=09\n"); 1064 1065 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED); 1066 } 1067 1068 return erp; 1069 1070 } /* end dasd_3990_erp_com_rej */ 1071 1072 /* 1073 * DASD_3990_ERP_BUS_OUT 1074 * 1075 * DESCRIPTION 1076 * Handles 24 byte 'Bus Out Parity Check' error. 1077 * 1078 * PARAMETER 1079 * erp current erp_head 1080 * RETURN VALUES 1081 * erp new erp_head - pointer to new ERP 1082 */ 1083 static struct dasd_ccw_req * 1084 dasd_3990_erp_bus_out(struct dasd_ccw_req * erp) 1085 { 1086 1087 struct dasd_device *device = erp->startdev; 1088 1089 /* first time set initial retry counter and erp_function */ 1090 /* and retry once without blocking queue */ 1091 /* (this enables easier enqueing of the cqr) */ 1092 if (erp->function != dasd_3990_erp_bus_out) { 1093 erp->retries = 256; 1094 erp->function = dasd_3990_erp_bus_out; 1095 1096 } else { 1097 1098 /* issue a message and wait for 'device ready' interrupt */ 1099 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1100 "bus out parity error or BOPC requested by " 1101 "channel"); 1102 1103 dasd_3990_erp_block_queue(erp, 60*HZ); 1104 1105 } 1106 1107 return erp; 1108 1109 } /* end dasd_3990_erp_bus_out */ 1110 1111 /* 1112 * DASD_3990_ERP_EQUIP_CHECK 1113 * 1114 * DESCRIPTION 1115 * Handles 24 byte 'Equipment Check' error. 1116 * 1117 * PARAMETER 1118 * erp current erp_head 1119 * RETURN VALUES 1120 * erp new erp_head - pointer to new ERP 1121 */ 1122 static struct dasd_ccw_req * 1123 dasd_3990_erp_equip_check(struct dasd_ccw_req * erp, char *sense) 1124 { 1125 1126 struct dasd_device *device = erp->startdev; 1127 1128 erp->function = dasd_3990_erp_equip_check; 1129 1130 if (sense[1] & SNS1_WRITE_INHIBITED) { 1131 dev_info(&device->cdev->dev, 1132 "Write inhibited path encountered\n"); 1133 1134 /* vary path offline 1135 internal error 04 - Path should be varied off-line.*/ 1136 dev_err(&device->cdev->dev, "An error occurred in the DASD " 1137 "device driver, reason=%s\n", "04"); 1138 1139 erp = dasd_3990_erp_action_1(erp); 1140 1141 } else if (sense[2] & SNS2_ENV_DATA_PRESENT) { 1142 1143 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1144 "Equipment Check - " "environmental data present"); 1145 1146 dasd_3990_handle_env_data(erp, sense); 1147 1148 erp = dasd_3990_erp_action_4(erp, sense); 1149 1150 } else if (sense[1] & SNS1_PERM_ERR) { 1151 1152 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1153 "Equipment Check - retry exhausted or " 1154 "undesirable"); 1155 1156 erp = dasd_3990_erp_action_1(erp); 1157 1158 } else { 1159 /* all other equipment checks - Action 5 */ 1160 /* rest is done when retries == 0 */ 1161 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1162 "Equipment check or processing error"); 1163 1164 erp = dasd_3990_erp_action_5(erp); 1165 } 1166 return erp; 1167 1168 } /* end dasd_3990_erp_equip_check */ 1169 1170 /* 1171 * DASD_3990_ERP_DATA_CHECK 1172 * 1173 * DESCRIPTION 1174 * Handles 24 byte 'Data Check' error. 1175 * 1176 * PARAMETER 1177 * erp current erp_head 1178 * RETURN VALUES 1179 * erp new erp_head - pointer to new ERP 1180 */ 1181 static struct dasd_ccw_req * 1182 dasd_3990_erp_data_check(struct dasd_ccw_req * erp, char *sense) 1183 { 1184 1185 struct dasd_device *device = erp->startdev; 1186 1187 erp->function = dasd_3990_erp_data_check; 1188 1189 if (sense[2] & SNS2_CORRECTABLE) { /* correctable data check */ 1190 1191 /* issue message that the data has been corrected */ 1192 dev_emerg(&device->cdev->dev, 1193 "Data recovered during retry with PCI " 1194 "fetch mode active\n"); 1195 1196 /* not possible to handle this situation in Linux */ 1197 panic("No way to inform application about the possibly " 1198 "incorrect data"); 1199 1200 } else if (sense[2] & SNS2_ENV_DATA_PRESENT) { 1201 1202 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1203 "Uncorrectable data check recovered secondary " 1204 "addr of duplex pair"); 1205 1206 erp = dasd_3990_erp_action_4(erp, sense); 1207 1208 } else if (sense[1] & SNS1_PERM_ERR) { 1209 1210 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1211 "Uncorrectable data check with internal " 1212 "retry exhausted"); 1213 1214 erp = dasd_3990_erp_action_1(erp); 1215 1216 } else { 1217 /* all other data checks */ 1218 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1219 "Uncorrectable data check with retry count " 1220 "exhausted..."); 1221 1222 erp = dasd_3990_erp_action_5(erp); 1223 } 1224 1225 return erp; 1226 1227 } /* end dasd_3990_erp_data_check */ 1228 1229 /* 1230 * DASD_3990_ERP_OVERRUN 1231 * 1232 * DESCRIPTION 1233 * Handles 24 byte 'Overrun' error. 1234 * 1235 * PARAMETER 1236 * erp current erp_head 1237 * RETURN VALUES 1238 * erp new erp_head - pointer to new ERP 1239 */ 1240 static struct dasd_ccw_req * 1241 dasd_3990_erp_overrun(struct dasd_ccw_req * erp, char *sense) 1242 { 1243 1244 struct dasd_device *device = erp->startdev; 1245 1246 erp->function = dasd_3990_erp_overrun; 1247 1248 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1249 "Overrun - service overrun or overrun" 1250 " error requested by channel"); 1251 1252 erp = dasd_3990_erp_action_5(erp); 1253 1254 return erp; 1255 1256 } /* end dasd_3990_erp_overrun */ 1257 1258 /* 1259 * DASD_3990_ERP_INV_FORMAT 1260 * 1261 * DESCRIPTION 1262 * Handles 24 byte 'Invalid Track Format' error. 1263 * 1264 * PARAMETER 1265 * erp current erp_head 1266 * RETURN VALUES 1267 * erp new erp_head - pointer to new ERP 1268 */ 1269 static struct dasd_ccw_req * 1270 dasd_3990_erp_inv_format(struct dasd_ccw_req * erp, char *sense) 1271 { 1272 1273 struct dasd_device *device = erp->startdev; 1274 1275 erp->function = dasd_3990_erp_inv_format; 1276 1277 if (sense[2] & SNS2_ENV_DATA_PRESENT) { 1278 1279 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1280 "Track format error when destaging or " 1281 "staging data"); 1282 1283 dasd_3990_handle_env_data(erp, sense); 1284 1285 erp = dasd_3990_erp_action_4(erp, sense); 1286 1287 } else { 1288 /* internal error 06 - The track format is not valid*/ 1289 dev_err(&device->cdev->dev, 1290 "An error occurred in the DASD device driver, " 1291 "reason=%s\n", "06"); 1292 1293 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED); 1294 } 1295 1296 return erp; 1297 1298 } /* end dasd_3990_erp_inv_format */ 1299 1300 /* 1301 * DASD_3990_ERP_EOC 1302 * 1303 * DESCRIPTION 1304 * Handles 24 byte 'End-of-Cylinder' error. 1305 * 1306 * PARAMETER 1307 * erp already added default erp 1308 * RETURN VALUES 1309 * erp pointer to original (failed) cqr. 1310 */ 1311 static struct dasd_ccw_req * 1312 dasd_3990_erp_EOC(struct dasd_ccw_req * default_erp, char *sense) 1313 { 1314 1315 struct dasd_device *device = default_erp->startdev; 1316 1317 dev_err(&device->cdev->dev, 1318 "The cylinder data for accessing the DASD is inconsistent\n"); 1319 1320 /* implement action 7 - BUG */ 1321 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED); 1322 1323 } /* end dasd_3990_erp_EOC */ 1324 1325 /* 1326 * DASD_3990_ERP_ENV_DATA 1327 * 1328 * DESCRIPTION 1329 * Handles 24 byte 'Environmental-Data Present' error. 1330 * 1331 * PARAMETER 1332 * erp current erp_head 1333 * RETURN VALUES 1334 * erp new erp_head - pointer to new ERP 1335 */ 1336 static struct dasd_ccw_req * 1337 dasd_3990_erp_env_data(struct dasd_ccw_req * erp, char *sense) 1338 { 1339 1340 struct dasd_device *device = erp->startdev; 1341 1342 erp->function = dasd_3990_erp_env_data; 1343 1344 DBF_DEV_EVENT(DBF_WARNING, device, "%s", "Environmental data present"); 1345 1346 dasd_3990_handle_env_data(erp, sense); 1347 1348 /* don't retry on disabled interface */ 1349 if (sense[7] != 0x0F) { 1350 erp = dasd_3990_erp_action_4(erp, sense); 1351 } else { 1352 erp->status = DASD_CQR_FILLED; 1353 } 1354 1355 return erp; 1356 1357 } /* end dasd_3990_erp_env_data */ 1358 1359 /* 1360 * DASD_3990_ERP_NO_REC 1361 * 1362 * DESCRIPTION 1363 * Handles 24 byte 'No Record Found' error. 1364 * 1365 * PARAMETER 1366 * erp already added default ERP 1367 * 1368 * RETURN VALUES 1369 * erp new erp_head - pointer to new ERP 1370 */ 1371 static struct dasd_ccw_req * 1372 dasd_3990_erp_no_rec(struct dasd_ccw_req * default_erp, char *sense) 1373 { 1374 1375 struct dasd_device *device = default_erp->startdev; 1376 1377 /* 1378 * In some cases the 'No Record Found' error might be expected and 1379 * log messages shouldn't be written then. 1380 * Check if the according suppress bit is set. 1381 */ 1382 if (!test_bit(DASD_CQR_SUPPRESS_NRF, &default_erp->flags)) 1383 dev_err(&device->cdev->dev, 1384 "The specified record was not found\n"); 1385 1386 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED); 1387 1388 } /* end dasd_3990_erp_no_rec */ 1389 1390 /* 1391 * DASD_3990_ERP_FILE_PROT 1392 * 1393 * DESCRIPTION 1394 * Handles 24 byte 'File Protected' error. 1395 * Note: Seek related recovery is not implemented because 1396 * wee don't use the seek command yet. 1397 * 1398 * PARAMETER 1399 * erp current erp_head 1400 * RETURN VALUES 1401 * erp new erp_head - pointer to new ERP 1402 */ 1403 static struct dasd_ccw_req * 1404 dasd_3990_erp_file_prot(struct dasd_ccw_req * erp) 1405 { 1406 1407 struct dasd_device *device = erp->startdev; 1408 1409 /* 1410 * In some cases the 'File Protected' error might be expected and 1411 * log messages shouldn't be written then. 1412 * Check if the according suppress bit is set. 1413 */ 1414 if (!test_bit(DASD_CQR_SUPPRESS_FP, &erp->flags)) 1415 dev_err(&device->cdev->dev, 1416 "Accessing the DASD failed because of a hardware error\n"); 1417 1418 return dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED); 1419 1420 } /* end dasd_3990_erp_file_prot */ 1421 1422 /* 1423 * DASD_3990_ERP_INSPECT_ALIAS 1424 * 1425 * DESCRIPTION 1426 * Checks if the original request was started on an alias device. 1427 * If yes, it modifies the original and the erp request so that 1428 * the erp request can be started on a base device. 1429 * 1430 * PARAMETER 1431 * erp pointer to the currently created default ERP 1432 * 1433 * RETURN VALUES 1434 * erp pointer to the modified ERP, or NULL 1435 */ 1436 1437 static struct dasd_ccw_req *dasd_3990_erp_inspect_alias( 1438 struct dasd_ccw_req *erp) 1439 { 1440 struct dasd_ccw_req *cqr = erp->refers; 1441 char *sense; 1442 1443 if (cqr->block && 1444 (cqr->block->base != cqr->startdev)) { 1445 1446 sense = dasd_get_sense(&erp->refers->irb); 1447 /* 1448 * dynamic pav may have changed base alias mapping 1449 */ 1450 if (!test_bit(DASD_FLAG_OFFLINE, &cqr->startdev->flags) && sense 1451 && (sense[0] == 0x10) && (sense[7] == 0x0F) 1452 && (sense[8] == 0x67)) { 1453 /* 1454 * remove device from alias handling to prevent new 1455 * requests from being scheduled on the 1456 * wrong alias device 1457 */ 1458 dasd_alias_remove_device(cqr->startdev); 1459 1460 /* schedule worker to reload device */ 1461 dasd_reload_device(cqr->startdev); 1462 } 1463 1464 if (cqr->startdev->features & DASD_FEATURE_ERPLOG) { 1465 DBF_DEV_EVENT(DBF_ERR, cqr->startdev, 1466 "ERP on alias device for request %p," 1467 " recover on base device %s", cqr, 1468 dev_name(&cqr->block->base->cdev->dev)); 1469 } 1470 dasd_eckd_reset_ccw_to_base_io(cqr); 1471 erp->startdev = cqr->block->base; 1472 erp->function = dasd_3990_erp_inspect_alias; 1473 return erp; 1474 } else 1475 return NULL; 1476 } 1477 1478 1479 /* 1480 * DASD_3990_ERP_INSPECT_24 1481 * 1482 * DESCRIPTION 1483 * Does a detailed inspection of the 24 byte sense data 1484 * and sets up a related error recovery action. 1485 * 1486 * PARAMETER 1487 * sense sense data of the actual error 1488 * erp pointer to the currently created default ERP 1489 * 1490 * RETURN VALUES 1491 * erp pointer to the (addtitional) ERP 1492 */ 1493 static struct dasd_ccw_req * 1494 dasd_3990_erp_inspect_24(struct dasd_ccw_req * erp, char *sense) 1495 { 1496 1497 struct dasd_ccw_req *erp_filled = NULL; 1498 1499 /* Check sense for .... */ 1500 /* 'Command Reject' */ 1501 if ((erp_filled == NULL) && (sense[0] & SNS0_CMD_REJECT)) { 1502 erp_filled = dasd_3990_erp_com_rej(erp, sense); 1503 } 1504 /* 'Intervention Required' */ 1505 if ((erp_filled == NULL) && (sense[0] & SNS0_INTERVENTION_REQ)) { 1506 erp_filled = dasd_3990_erp_int_req(erp); 1507 } 1508 /* 'Bus Out Parity Check' */ 1509 if ((erp_filled == NULL) && (sense[0] & SNS0_BUS_OUT_CHECK)) { 1510 erp_filled = dasd_3990_erp_bus_out(erp); 1511 } 1512 /* 'Equipment Check' */ 1513 if ((erp_filled == NULL) && (sense[0] & SNS0_EQUIPMENT_CHECK)) { 1514 erp_filled = dasd_3990_erp_equip_check(erp, sense); 1515 } 1516 /* 'Data Check' */ 1517 if ((erp_filled == NULL) && (sense[0] & SNS0_DATA_CHECK)) { 1518 erp_filled = dasd_3990_erp_data_check(erp, sense); 1519 } 1520 /* 'Overrun' */ 1521 if ((erp_filled == NULL) && (sense[0] & SNS0_OVERRUN)) { 1522 erp_filled = dasd_3990_erp_overrun(erp, sense); 1523 } 1524 /* 'Invalid Track Format' */ 1525 if ((erp_filled == NULL) && (sense[1] & SNS1_INV_TRACK_FORMAT)) { 1526 erp_filled = dasd_3990_erp_inv_format(erp, sense); 1527 } 1528 /* 'End-of-Cylinder' */ 1529 if ((erp_filled == NULL) && (sense[1] & SNS1_EOC)) { 1530 erp_filled = dasd_3990_erp_EOC(erp, sense); 1531 } 1532 /* 'Environmental Data' */ 1533 if ((erp_filled == NULL) && (sense[2] & SNS2_ENV_DATA_PRESENT)) { 1534 erp_filled = dasd_3990_erp_env_data(erp, sense); 1535 } 1536 /* 'No Record Found' */ 1537 if ((erp_filled == NULL) && (sense[1] & SNS1_NO_REC_FOUND)) { 1538 erp_filled = dasd_3990_erp_no_rec(erp, sense); 1539 } 1540 /* 'File Protected' */ 1541 if ((erp_filled == NULL) && (sense[1] & SNS1_FILE_PROTECTED)) { 1542 erp_filled = dasd_3990_erp_file_prot(erp); 1543 } 1544 /* other (unknown) error - do default ERP */ 1545 if (erp_filled == NULL) { 1546 1547 erp_filled = erp; 1548 } 1549 1550 return erp_filled; 1551 1552 } /* END dasd_3990_erp_inspect_24 */ 1553 1554 /* 1555 ***************************************************************************** 1556 * 32 byte sense ERP functions (only) 1557 ***************************************************************************** 1558 */ 1559 1560 /* 1561 * DASD_3990_ERPACTION_10_32 1562 * 1563 * DESCRIPTION 1564 * Handles 32 byte 'Action 10' of Single Program Action Codes. 1565 * Just retry and if retry doesn't work, return with error. 1566 * 1567 * PARAMETER 1568 * erp current erp_head 1569 * sense current sense data 1570 * RETURN VALUES 1571 * erp modified erp_head 1572 */ 1573 static struct dasd_ccw_req * 1574 dasd_3990_erp_action_10_32(struct dasd_ccw_req * erp, char *sense) 1575 { 1576 1577 struct dasd_device *device = erp->startdev; 1578 1579 erp->retries = 256; 1580 erp->function = dasd_3990_erp_action_10_32; 1581 1582 DBF_DEV_EVENT(DBF_WARNING, device, "%s", "Perform logging requested"); 1583 1584 return erp; 1585 1586 } /* end dasd_3990_erp_action_10_32 */ 1587 1588 /* 1589 * DASD_3990_ERP_ACTION_1B_32 1590 * 1591 * DESCRIPTION 1592 * Handles 32 byte 'Action 1B' of Single Program Action Codes. 1593 * A write operation could not be finished because of an unexpected 1594 * condition. 1595 * The already created 'default erp' is used to get the link to 1596 * the erp chain, but it can not be used for this recovery 1597 * action because it contains no DE/LO data space. 1598 * 1599 * PARAMETER 1600 * default_erp already added default erp. 1601 * sense current sense data 1602 * 1603 * RETURN VALUES 1604 * erp new erp or 1605 * default_erp in case of imprecise ending or error 1606 */ 1607 static struct dasd_ccw_req * 1608 dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense) 1609 { 1610 1611 struct dasd_device *device = default_erp->startdev; 1612 __u32 cpa = 0; 1613 struct dasd_ccw_req *cqr; 1614 struct dasd_ccw_req *erp; 1615 struct DE_eckd_data *DE_data; 1616 struct PFX_eckd_data *PFX_data; 1617 char *LO_data; /* LO_eckd_data_t */ 1618 struct ccw1 *ccw, *oldccw; 1619 1620 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1621 "Write not finished because of unexpected condition"); 1622 1623 default_erp->function = dasd_3990_erp_action_1B_32; 1624 1625 /* determine the original cqr */ 1626 cqr = default_erp; 1627 1628 while (cqr->refers != NULL) { 1629 cqr = cqr->refers; 1630 } 1631 1632 if (scsw_is_tm(&cqr->irb.scsw)) { 1633 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1634 "32 bit sense, action 1B is not defined" 1635 " in transport mode - just retry"); 1636 return default_erp; 1637 } 1638 1639 /* for imprecise ending just do default erp */ 1640 if (sense[1] & 0x01) { 1641 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1642 "Imprecise ending is set - just retry"); 1643 1644 return default_erp; 1645 } 1646 1647 /* determine the address of the CCW to be restarted */ 1648 /* Imprecise ending is not set -> addr from IRB-SCSW */ 1649 cpa = default_erp->refers->irb.scsw.cmd.cpa; 1650 1651 if (cpa == 0) { 1652 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1653 "Unable to determine address of the CCW " 1654 "to be restarted"); 1655 1656 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED); 1657 } 1658 1659 /* Build new ERP request including DE/LO */ 1660 erp = dasd_alloc_erp_request(cqr->magic, 1661 2 + 1,/* DE/LO + TIC */ 1662 sizeof(struct DE_eckd_data) + 1663 sizeof(struct LO_eckd_data), device); 1664 1665 if (IS_ERR(erp)) { 1666 /* internal error 01 - Unable to allocate ERP */ 1667 dev_err(&device->cdev->dev, "An error occurred in the DASD " 1668 "device driver, reason=%s\n", "01"); 1669 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED); 1670 } 1671 1672 /* use original DE */ 1673 DE_data = erp->data; 1674 oldccw = cqr->cpaddr; 1675 if (oldccw->cmd_code == DASD_ECKD_CCW_PFX) { 1676 PFX_data = cqr->data; 1677 memcpy(DE_data, &PFX_data->define_extent, 1678 sizeof(struct DE_eckd_data)); 1679 } else 1680 memcpy(DE_data, cqr->data, sizeof(struct DE_eckd_data)); 1681 1682 /* create LO */ 1683 LO_data = erp->data + sizeof(struct DE_eckd_data); 1684 1685 if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) { 1686 /* should not */ 1687 return dasd_3990_erp_cleanup(default_erp, DASD_CQR_FAILED); 1688 } 1689 1690 if ((sense[7] & 0x3F) == 0x01) { 1691 /* operation code is WRITE DATA -> data area orientation */ 1692 LO_data[0] = 0x81; 1693 1694 } else if ((sense[7] & 0x3F) == 0x03) { 1695 /* operation code is FORMAT WRITE -> index orientation */ 1696 LO_data[0] = 0xC3; 1697 1698 } else { 1699 LO_data[0] = sense[7]; /* operation */ 1700 } 1701 1702 LO_data[1] = sense[8]; /* auxiliary */ 1703 LO_data[2] = sense[9]; 1704 LO_data[3] = sense[3]; /* count */ 1705 LO_data[4] = sense[29]; /* seek_addr.cyl */ 1706 LO_data[5] = sense[30]; /* seek_addr.cyl 2nd byte */ 1707 LO_data[7] = sense[31]; /* seek_addr.head 2nd byte */ 1708 1709 memcpy(&(LO_data[8]), &(sense[11]), 8); 1710 1711 /* create DE ccw */ 1712 ccw = erp->cpaddr; 1713 memset(ccw, 0, sizeof(struct ccw1)); 1714 ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT; 1715 ccw->flags = CCW_FLAG_CC; 1716 ccw->count = 16; 1717 ccw->cda = (__u32)virt_to_phys(DE_data); 1718 1719 /* create LO ccw */ 1720 ccw++; 1721 memset(ccw, 0, sizeof(struct ccw1)); 1722 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD; 1723 ccw->flags = CCW_FLAG_CC; 1724 ccw->count = 16; 1725 ccw->cda = (__u32)virt_to_phys(LO_data); 1726 1727 /* TIC to the failed ccw */ 1728 ccw++; 1729 ccw->cmd_code = CCW_CMD_TIC; 1730 ccw->cda = cpa; 1731 1732 /* fill erp related fields */ 1733 erp->flags = default_erp->flags; 1734 erp->function = dasd_3990_erp_action_1B_32; 1735 erp->refers = default_erp->refers; 1736 erp->startdev = device; 1737 erp->memdev = device; 1738 erp->magic = default_erp->magic; 1739 erp->expires = default_erp->expires; 1740 erp->retries = 256; 1741 erp->buildclk = get_tod_clock(); 1742 erp->status = DASD_CQR_FILLED; 1743 1744 /* remove the default erp */ 1745 dasd_free_erp_request(default_erp, device); 1746 1747 return erp; 1748 1749 } /* end dasd_3990_erp_action_1B_32 */ 1750 1751 /* 1752 * DASD_3990_UPDATE_1B 1753 * 1754 * DESCRIPTION 1755 * Handles the update to the 32 byte 'Action 1B' of Single Program 1756 * Action Codes in case the first action was not successful. 1757 * The already created 'previous_erp' is the currently not successful 1758 * ERP. 1759 * 1760 * PARAMETER 1761 * previous_erp already created previous erp. 1762 * sense current sense data 1763 * RETURN VALUES 1764 * erp modified erp 1765 */ 1766 static struct dasd_ccw_req * 1767 dasd_3990_update_1B(struct dasd_ccw_req * previous_erp, char *sense) 1768 { 1769 1770 struct dasd_device *device = previous_erp->startdev; 1771 __u32 cpa = 0; 1772 struct dasd_ccw_req *cqr; 1773 struct dasd_ccw_req *erp; 1774 char *LO_data; /* struct LO_eckd_data */ 1775 struct ccw1 *ccw; 1776 1777 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1778 "Write not finished because of unexpected condition" 1779 " - follow on"); 1780 1781 /* determine the original cqr */ 1782 cqr = previous_erp; 1783 1784 while (cqr->refers != NULL) { 1785 cqr = cqr->refers; 1786 } 1787 1788 if (scsw_is_tm(&cqr->irb.scsw)) { 1789 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1790 "32 bit sense, action 1B, update," 1791 " in transport mode - just retry"); 1792 return previous_erp; 1793 } 1794 1795 /* for imprecise ending just do default erp */ 1796 if (sense[1] & 0x01) { 1797 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1798 "Imprecise ending is set - just retry"); 1799 1800 previous_erp->status = DASD_CQR_FILLED; 1801 1802 return previous_erp; 1803 } 1804 1805 /* determine the address of the CCW to be restarted */ 1806 /* Imprecise ending is not set -> addr from IRB-SCSW */ 1807 cpa = previous_erp->irb.scsw.cmd.cpa; 1808 1809 if (cpa == 0) { 1810 /* internal error 02 - 1811 Unable to determine address of the CCW to be restarted */ 1812 dev_err(&device->cdev->dev, "An error occurred in the DASD " 1813 "device driver, reason=%s\n", "02"); 1814 1815 previous_erp->status = DASD_CQR_FAILED; 1816 1817 return previous_erp; 1818 } 1819 1820 erp = previous_erp; 1821 1822 /* update the LO with the new returned sense data */ 1823 LO_data = erp->data + sizeof(struct DE_eckd_data); 1824 1825 if ((sense[3] == 0x01) && (LO_data[1] & 0x01)) { 1826 /* should not happen */ 1827 previous_erp->status = DASD_CQR_FAILED; 1828 1829 return previous_erp; 1830 } 1831 1832 if ((sense[7] & 0x3F) == 0x01) { 1833 /* operation code is WRITE DATA -> data area orientation */ 1834 LO_data[0] = 0x81; 1835 1836 } else if ((sense[7] & 0x3F) == 0x03) { 1837 /* operation code is FORMAT WRITE -> index orientation */ 1838 LO_data[0] = 0xC3; 1839 1840 } else { 1841 LO_data[0] = sense[7]; /* operation */ 1842 } 1843 1844 LO_data[1] = sense[8]; /* auxiliary */ 1845 LO_data[2] = sense[9]; 1846 LO_data[3] = sense[3]; /* count */ 1847 LO_data[4] = sense[29]; /* seek_addr.cyl */ 1848 LO_data[5] = sense[30]; /* seek_addr.cyl 2nd byte */ 1849 LO_data[7] = sense[31]; /* seek_addr.head 2nd byte */ 1850 1851 memcpy(&(LO_data[8]), &(sense[11]), 8); 1852 1853 /* TIC to the failed ccw */ 1854 ccw = erp->cpaddr; /* addr of DE ccw */ 1855 ccw++; /* addr of LE ccw */ 1856 ccw++; /* addr of TIC ccw */ 1857 ccw->cda = cpa; 1858 1859 erp->status = DASD_CQR_FILLED; 1860 1861 return erp; 1862 1863 } /* end dasd_3990_update_1B */ 1864 1865 /* 1866 * DASD_3990_ERP_COMPOUND_RETRY 1867 * 1868 * DESCRIPTION 1869 * Handles the compound ERP action retry code. 1870 * NOTE: At least one retry is done even if zero is specified 1871 * by the sense data. This makes enqueueing of the request 1872 * easier. 1873 * 1874 * PARAMETER 1875 * sense sense data of the actual error 1876 * erp pointer to the currently created ERP 1877 * 1878 * RETURN VALUES 1879 * erp modified ERP pointer 1880 * 1881 */ 1882 static void 1883 dasd_3990_erp_compound_retry(struct dasd_ccw_req * erp, char *sense) 1884 { 1885 1886 switch (sense[25] & 0x03) { 1887 case 0x00: /* no not retry */ 1888 erp->retries = 1; 1889 break; 1890 1891 case 0x01: /* retry 2 times */ 1892 erp->retries = 2; 1893 break; 1894 1895 case 0x02: /* retry 10 times */ 1896 erp->retries = 10; 1897 break; 1898 1899 case 0x03: /* retry 256 times */ 1900 erp->retries = 256; 1901 break; 1902 1903 default: 1904 BUG(); 1905 } 1906 1907 erp->function = dasd_3990_erp_compound_retry; 1908 1909 } /* end dasd_3990_erp_compound_retry */ 1910 1911 /* 1912 * DASD_3990_ERP_COMPOUND_PATH 1913 * 1914 * DESCRIPTION 1915 * Handles the compound ERP action for retry on alternate 1916 * channel path. 1917 * 1918 * PARAMETER 1919 * sense sense data of the actual error 1920 * erp pointer to the currently created ERP 1921 * 1922 * RETURN VALUES 1923 * erp modified ERP pointer 1924 * 1925 */ 1926 static void 1927 dasd_3990_erp_compound_path(struct dasd_ccw_req * erp, char *sense) 1928 { 1929 if (sense[25] & DASD_SENSE_BIT_3) { 1930 dasd_3990_erp_alternate_path(erp); 1931 1932 if (erp->status == DASD_CQR_FAILED && 1933 !test_bit(DASD_CQR_VERIFY_PATH, &erp->flags)) { 1934 /* reset the lpm and the status to be able to 1935 * try further actions. */ 1936 erp->lpm = dasd_path_get_opm(erp->startdev); 1937 erp->status = DASD_CQR_NEED_ERP; 1938 } 1939 } 1940 1941 erp->function = dasd_3990_erp_compound_path; 1942 1943 } /* end dasd_3990_erp_compound_path */ 1944 1945 /* 1946 * DASD_3990_ERP_COMPOUND_CODE 1947 * 1948 * DESCRIPTION 1949 * Handles the compound ERP action for retry code. 1950 * 1951 * PARAMETER 1952 * sense sense data of the actual error 1953 * erp pointer to the currently created ERP 1954 * 1955 * RETURN VALUES 1956 * erp NEW ERP pointer 1957 * 1958 */ 1959 static struct dasd_ccw_req * 1960 dasd_3990_erp_compound_code(struct dasd_ccw_req * erp, char *sense) 1961 { 1962 1963 if (sense[25] & DASD_SENSE_BIT_2) { 1964 1965 switch (sense[28]) { 1966 case 0x17: 1967 /* issue a Diagnostic Control command with an 1968 * Inhibit Write subcommand and controller modifier */ 1969 erp = dasd_3990_erp_DCTL(erp, 0x20); 1970 break; 1971 1972 case 0x25: 1973 /* wait for 5 seconds and retry again */ 1974 erp->retries = 1; 1975 1976 dasd_3990_erp_block_queue (erp, 5*HZ); 1977 break; 1978 1979 default: 1980 /* should not happen - continue */ 1981 break; 1982 } 1983 } 1984 1985 erp->function = dasd_3990_erp_compound_code; 1986 1987 return erp; 1988 1989 } /* end dasd_3990_erp_compound_code */ 1990 1991 /* 1992 * DASD_3990_ERP_COMPOUND_CONFIG 1993 * 1994 * DESCRIPTION 1995 * Handles the compound ERP action for configuration 1996 * dependent error. 1997 * Note: duplex handling is not implemented (yet). 1998 * 1999 * PARAMETER 2000 * sense sense data of the actual error 2001 * erp pointer to the currently created ERP 2002 * 2003 * RETURN VALUES 2004 * erp modified ERP pointer 2005 * 2006 */ 2007 static void 2008 dasd_3990_erp_compound_config(struct dasd_ccw_req * erp, char *sense) 2009 { 2010 2011 if ((sense[25] & DASD_SENSE_BIT_1) && (sense[26] & DASD_SENSE_BIT_2)) { 2012 2013 /* set to suspended duplex state then restart 2014 internal error 05 - Set device to suspended duplex state 2015 should be done */ 2016 struct dasd_device *device = erp->startdev; 2017 dev_err(&device->cdev->dev, 2018 "An error occurred in the DASD device driver, " 2019 "reason=%s\n", "05"); 2020 2021 } 2022 2023 erp->function = dasd_3990_erp_compound_config; 2024 2025 } /* end dasd_3990_erp_compound_config */ 2026 2027 /* 2028 * DASD_3990_ERP_COMPOUND 2029 * 2030 * DESCRIPTION 2031 * Does the further compound program action if 2032 * compound retry was not successful. 2033 * 2034 * PARAMETER 2035 * sense sense data of the actual error 2036 * erp pointer to the current (failed) ERP 2037 * 2038 * RETURN VALUES 2039 * erp (additional) ERP pointer 2040 * 2041 */ 2042 static struct dasd_ccw_req * 2043 dasd_3990_erp_compound(struct dasd_ccw_req * erp, char *sense) 2044 { 2045 2046 if ((erp->function == dasd_3990_erp_compound_retry) && 2047 (erp->status == DASD_CQR_NEED_ERP)) { 2048 2049 dasd_3990_erp_compound_path(erp, sense); 2050 } 2051 2052 if ((erp->function == dasd_3990_erp_compound_path) && 2053 (erp->status == DASD_CQR_NEED_ERP)) { 2054 2055 erp = dasd_3990_erp_compound_code(erp, sense); 2056 } 2057 2058 if ((erp->function == dasd_3990_erp_compound_code) && 2059 (erp->status == DASD_CQR_NEED_ERP)) { 2060 2061 dasd_3990_erp_compound_config(erp, sense); 2062 } 2063 2064 /* if no compound action ERP specified, the request failed */ 2065 if (erp->status == DASD_CQR_NEED_ERP) 2066 erp->status = DASD_CQR_FAILED; 2067 2068 return erp; 2069 2070 } /* end dasd_3990_erp_compound */ 2071 2072 /* 2073 *DASD_3990_ERP_HANDLE_SIM 2074 * 2075 *DESCRIPTION 2076 * inspects the SIM SENSE data and starts an appropriate action 2077 * 2078 * PARAMETER 2079 * sense sense data of the actual error 2080 * 2081 * RETURN VALUES 2082 * none 2083 */ 2084 void 2085 dasd_3990_erp_handle_sim(struct dasd_device *device, char *sense) 2086 { 2087 /* print message according to log or message to operator mode */ 2088 if ((sense[24] & DASD_SIM_MSG_TO_OP) || (sense[1] & 0x10)) { 2089 /* print SIM SRC from RefCode */ 2090 dev_err(&device->cdev->dev, "SIM - SRC: " 2091 "%02x%02x%02x%02x\n", sense[22], 2092 sense[23], sense[11], sense[12]); 2093 } else if (sense[24] & DASD_SIM_LOG) { 2094 /* print SIM SRC Refcode */ 2095 dev_warn(&device->cdev->dev, "log SIM - SRC: " 2096 "%02x%02x%02x%02x\n", sense[22], 2097 sense[23], sense[11], sense[12]); 2098 } 2099 } 2100 2101 /* 2102 * DASD_3990_ERP_INSPECT_32 2103 * 2104 * DESCRIPTION 2105 * Does a detailed inspection of the 32 byte sense data 2106 * and sets up a related error recovery action. 2107 * 2108 * PARAMETER 2109 * sense sense data of the actual error 2110 * erp pointer to the currently created default ERP 2111 * 2112 * RETURN VALUES 2113 * erp_filled pointer to the ERP 2114 * 2115 */ 2116 static struct dasd_ccw_req * 2117 dasd_3990_erp_inspect_32(struct dasd_ccw_req * erp, char *sense) 2118 { 2119 2120 struct dasd_device *device = erp->startdev; 2121 2122 erp->function = dasd_3990_erp_inspect_32; 2123 2124 /* check for SIM sense data */ 2125 if ((sense[6] & DASD_SIM_SENSE) == DASD_SIM_SENSE) 2126 dasd_3990_erp_handle_sim(device, sense); 2127 2128 if (sense[25] & DASD_SENSE_BIT_0) { 2129 2130 /* compound program action codes (byte25 bit 0 == '1') */ 2131 dasd_3990_erp_compound_retry(erp, sense); 2132 2133 } else { 2134 2135 /* single program action codes (byte25 bit 0 == '0') */ 2136 switch (sense[25]) { 2137 2138 case 0x00: /* success - use default ERP for retries */ 2139 DBF_DEV_EVENT(DBF_DEBUG, device, "%s", 2140 "ERP called for successful request" 2141 " - just retry"); 2142 break; 2143 2144 case 0x01: /* fatal error */ 2145 dev_err(&device->cdev->dev, 2146 "ERP failed for the DASD\n"); 2147 2148 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED); 2149 break; 2150 2151 case 0x02: /* intervention required */ 2152 case 0x03: /* intervention required during dual copy */ 2153 erp = dasd_3990_erp_int_req(erp); 2154 break; 2155 2156 case 0x0F: /* length mismatch during update write command 2157 internal error 08 - update write command error*/ 2158 dev_err(&device->cdev->dev, "An error occurred in the " 2159 "DASD device driver, reason=%s\n", "08"); 2160 2161 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED); 2162 break; 2163 2164 case 0x10: /* logging required for other channel program */ 2165 erp = dasd_3990_erp_action_10_32(erp, sense); 2166 break; 2167 2168 case 0x15: /* next track outside defined extend 2169 internal error 07 - The next track is not 2170 within the defined storage extent */ 2171 dev_err(&device->cdev->dev, 2172 "An error occurred in the DASD device driver, " 2173 "reason=%s\n", "07"); 2174 2175 erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED); 2176 break; 2177 2178 case 0x1B: /* unexpected condition during write */ 2179 2180 erp = dasd_3990_erp_action_1B_32(erp, sense); 2181 break; 2182 2183 case 0x1C: /* invalid data */ 2184 dev_emerg(&device->cdev->dev, 2185 "Data recovered during retry with PCI " 2186 "fetch mode active\n"); 2187 2188 /* not possible to handle this situation in Linux */ 2189 panic 2190 ("Invalid data - No way to inform application " 2191 "about the possibly incorrect data"); 2192 break; 2193 2194 case 0x1D: /* state-change pending */ 2195 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2196 "A State change pending condition exists " 2197 "for the subsystem or device"); 2198 2199 erp = dasd_3990_erp_action_4(erp, sense); 2200 break; 2201 2202 case 0x1E: /* busy */ 2203 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2204 "Busy condition exists " 2205 "for the subsystem or device"); 2206 erp = dasd_3990_erp_action_4(erp, sense); 2207 break; 2208 2209 default: /* all others errors - default erp */ 2210 break; 2211 } 2212 } 2213 2214 return erp; 2215 2216 } /* end dasd_3990_erp_inspect_32 */ 2217 2218 static void dasd_3990_erp_disable_path(struct dasd_device *device, __u8 lpum) 2219 { 2220 int pos = pathmask_to_pos(lpum); 2221 2222 if (!(device->features & DASD_FEATURE_PATH_AUTODISABLE)) { 2223 dev_err(&device->cdev->dev, 2224 "Path %x.%02x (pathmask %02x) is operational despite excessive IFCCs\n", 2225 device->path[pos].cssid, device->path[pos].chpid, lpum); 2226 goto out; 2227 } 2228 2229 /* no remaining path, cannot disable */ 2230 if (!(dasd_path_get_opm(device) & ~lpum)) { 2231 dev_err(&device->cdev->dev, 2232 "Last path %x.%02x (pathmask %02x) is operational despite excessive IFCCs\n", 2233 device->path[pos].cssid, device->path[pos].chpid, lpum); 2234 goto out; 2235 } 2236 2237 dev_err(&device->cdev->dev, 2238 "Path %x.%02x (pathmask %02x) is disabled - IFCC threshold exceeded\n", 2239 device->path[pos].cssid, device->path[pos].chpid, lpum); 2240 dasd_path_remove_opm(device, lpum); 2241 dasd_path_add_ifccpm(device, lpum); 2242 2243 out: 2244 device->path[pos].errorclk = 0; 2245 atomic_set(&device->path[pos].error_count, 0); 2246 } 2247 2248 static void dasd_3990_erp_account_error(struct dasd_ccw_req *erp) 2249 { 2250 struct dasd_device *device = erp->startdev; 2251 __u8 lpum = erp->refers->irb.esw.esw1.lpum; 2252 int pos = pathmask_to_pos(lpum); 2253 unsigned long clk; 2254 2255 if (!device->path_thrhld) 2256 return; 2257 2258 clk = get_tod_clock(); 2259 /* 2260 * check if the last error is longer ago than the timeout, 2261 * if so reset error state 2262 */ 2263 if ((tod_to_ns(clk - device->path[pos].errorclk) / NSEC_PER_SEC) 2264 >= device->path_interval) { 2265 atomic_set(&device->path[pos].error_count, 0); 2266 device->path[pos].errorclk = 0; 2267 } 2268 atomic_inc(&device->path[pos].error_count); 2269 device->path[pos].errorclk = clk; 2270 /* threshold exceeded disable path if possible */ 2271 if (atomic_read(&device->path[pos].error_count) >= 2272 device->path_thrhld) 2273 dasd_3990_erp_disable_path(device, lpum); 2274 } 2275 2276 /* 2277 ***************************************************************************** 2278 * main ERP control functions (24 and 32 byte sense) 2279 ***************************************************************************** 2280 */ 2281 2282 /* 2283 * DASD_3990_ERP_CONTROL_CHECK 2284 * 2285 * DESCRIPTION 2286 * Does a generic inspection if a control check occurred and sets up 2287 * the related error recovery procedure 2288 * 2289 * PARAMETER 2290 * erp pointer to the currently created default ERP 2291 * 2292 * RETURN VALUES 2293 * erp_filled pointer to the erp 2294 */ 2295 2296 static struct dasd_ccw_req * 2297 dasd_3990_erp_control_check(struct dasd_ccw_req *erp) 2298 { 2299 struct dasd_device *device = erp->startdev; 2300 2301 if (scsw_cstat(&erp->refers->irb.scsw) & (SCHN_STAT_INTF_CTRL_CHK 2302 | SCHN_STAT_CHN_CTRL_CHK)) { 2303 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2304 "channel or interface control check"); 2305 dasd_3990_erp_account_error(erp); 2306 erp = dasd_3990_erp_action_4(erp, NULL); 2307 } 2308 return erp; 2309 } 2310 2311 /* 2312 * DASD_3990_ERP_INSPECT 2313 * 2314 * DESCRIPTION 2315 * Does a detailed inspection for sense data by calling either 2316 * the 24-byte or the 32-byte inspection routine. 2317 * 2318 * PARAMETER 2319 * erp pointer to the currently created default ERP 2320 * RETURN VALUES 2321 * erp_new contens was possibly modified 2322 */ 2323 static struct dasd_ccw_req * 2324 dasd_3990_erp_inspect(struct dasd_ccw_req *erp) 2325 { 2326 2327 struct dasd_ccw_req *erp_new = NULL; 2328 char *sense; 2329 2330 /* if this problem occurred on an alias retry on base */ 2331 erp_new = dasd_3990_erp_inspect_alias(erp); 2332 if (erp_new) 2333 return erp_new; 2334 2335 /* sense data are located in the refers record of the 2336 * already set up new ERP ! 2337 * check if concurrent sens is available 2338 */ 2339 sense = dasd_get_sense(&erp->refers->irb); 2340 if (!sense) 2341 erp_new = dasd_3990_erp_control_check(erp); 2342 /* distinguish between 24 and 32 byte sense data */ 2343 else if (sense[27] & DASD_SENSE_BIT_0) { 2344 2345 /* inspect the 24 byte sense data */ 2346 erp_new = dasd_3990_erp_inspect_24(erp, sense); 2347 2348 } else { 2349 2350 /* inspect the 32 byte sense data */ 2351 erp_new = dasd_3990_erp_inspect_32(erp, sense); 2352 2353 } /* end distinguish between 24 and 32 byte sense data */ 2354 2355 return erp_new; 2356 } 2357 2358 /* 2359 * DASD_3990_ERP_ADD_ERP 2360 * 2361 * DESCRIPTION 2362 * This function adds an additional request block (ERP) to the head of 2363 * the given cqr (or erp). 2364 * For a command mode cqr the erp is initialized as an default erp 2365 * (retry TIC). 2366 * For transport mode we make a copy of the original TCW (points to 2367 * the original TCCB, TIDALs, etc.) but give it a fresh 2368 * TSB so the original sense data will not be changed. 2369 * 2370 * PARAMETER 2371 * cqr head of the current ERP-chain (or single cqr if 2372 * first error) 2373 * RETURN VALUES 2374 * erp pointer to new ERP-chain head 2375 */ 2376 static struct dasd_ccw_req *dasd_3990_erp_add_erp(struct dasd_ccw_req *cqr) 2377 { 2378 2379 struct dasd_device *device = cqr->startdev; 2380 struct ccw1 *ccw; 2381 struct dasd_ccw_req *erp; 2382 int cplength, datasize; 2383 struct tcw *tcw; 2384 struct tsb *tsb; 2385 2386 if (cqr->cpmode == 1) { 2387 cplength = 0; 2388 /* TCW needs to be 64 byte aligned, so leave enough room */ 2389 datasize = 64 + sizeof(struct tcw) + sizeof(struct tsb); 2390 } else { 2391 cplength = 2; 2392 datasize = 0; 2393 } 2394 2395 /* allocate additional request block */ 2396 erp = dasd_alloc_erp_request(cqr->magic, 2397 cplength, datasize, device); 2398 if (IS_ERR(erp)) { 2399 if (cqr->retries <= 0) { 2400 DBF_DEV_EVENT(DBF_ERR, device, "%s", 2401 "Unable to allocate ERP request"); 2402 cqr->status = DASD_CQR_FAILED; 2403 cqr->stopclk = get_tod_clock(); 2404 } else { 2405 DBF_DEV_EVENT(DBF_ERR, device, 2406 "Unable to allocate ERP request " 2407 "(%i retries left)", 2408 cqr->retries); 2409 dasd_block_set_timer(device->block, (HZ << 3)); 2410 } 2411 return erp; 2412 } 2413 2414 ccw = cqr->cpaddr; 2415 if (cqr->cpmode == 1) { 2416 /* make a shallow copy of the original tcw but set new tsb */ 2417 erp->cpmode = 1; 2418 erp->cpaddr = PTR_ALIGN(erp->data, 64); 2419 tcw = erp->cpaddr; 2420 tsb = (struct tsb *) &tcw[1]; 2421 *tcw = *((struct tcw *)cqr->cpaddr); 2422 tcw->tsb = virt_to_phys(tsb); 2423 } else if (ccw->cmd_code == DASD_ECKD_CCW_PSF) { 2424 /* PSF cannot be chained from NOOP/TIC */ 2425 erp->cpaddr = cqr->cpaddr; 2426 } else { 2427 /* initialize request with default TIC to current ERP/CQR */ 2428 ccw = erp->cpaddr; 2429 ccw->cmd_code = CCW_CMD_NOOP; 2430 ccw->flags = CCW_FLAG_CC; 2431 ccw++; 2432 ccw->cmd_code = CCW_CMD_TIC; 2433 ccw->cda = (__u32)virt_to_phys(cqr->cpaddr); 2434 } 2435 2436 erp->flags = cqr->flags; 2437 erp->function = dasd_3990_erp_add_erp; 2438 erp->refers = cqr; 2439 erp->startdev = device; 2440 erp->memdev = device; 2441 erp->block = cqr->block; 2442 erp->magic = cqr->magic; 2443 erp->expires = cqr->expires; 2444 erp->retries = device->default_retries; 2445 erp->buildclk = get_tod_clock(); 2446 erp->status = DASD_CQR_FILLED; 2447 2448 return erp; 2449 } 2450 2451 /* 2452 * DASD_3990_ERP_ADDITIONAL_ERP 2453 * 2454 * DESCRIPTION 2455 * An additional ERP is needed to handle the current error. 2456 * Add ERP to the head of the ERP-chain containing the ERP processing 2457 * determined based on the sense data. 2458 * 2459 * PARAMETER 2460 * cqr head of the current ERP-chain (or single cqr if 2461 * first error) 2462 * 2463 * RETURN VALUES 2464 * erp pointer to new ERP-chain head 2465 */ 2466 static struct dasd_ccw_req * 2467 dasd_3990_erp_additional_erp(struct dasd_ccw_req * cqr) 2468 { 2469 2470 struct dasd_ccw_req *erp = NULL; 2471 2472 /* add erp and initialize with default TIC */ 2473 erp = dasd_3990_erp_add_erp(cqr); 2474 2475 if (IS_ERR(erp)) 2476 return erp; 2477 2478 /* inspect sense, determine specific ERP if possible */ 2479 if (erp != cqr) { 2480 2481 erp = dasd_3990_erp_inspect(erp); 2482 } 2483 2484 return erp; 2485 2486 } /* end dasd_3990_erp_additional_erp */ 2487 2488 /* 2489 * DASD_3990_ERP_ERROR_MATCH 2490 * 2491 * DESCRIPTION 2492 * Check if the device status of the given cqr is the same. 2493 * This means that the failed CCW and the relevant sense data 2494 * must match. 2495 * I don't distinguish between 24 and 32 byte sense because in case of 2496 * 24 byte sense byte 25 and 27 is set as well. 2497 * 2498 * PARAMETER 2499 * cqr1 first cqr, which will be compared with the 2500 * cqr2 second cqr. 2501 * 2502 * RETURN VALUES 2503 * match 'boolean' for match found 2504 * returns 1 if match found, otherwise 0. 2505 */ 2506 static int dasd_3990_erp_error_match(struct dasd_ccw_req *cqr1, 2507 struct dasd_ccw_req *cqr2) 2508 { 2509 char *sense1, *sense2; 2510 2511 if (cqr1->startdev != cqr2->startdev) 2512 return 0; 2513 2514 sense1 = dasd_get_sense(&cqr1->irb); 2515 sense2 = dasd_get_sense(&cqr2->irb); 2516 2517 /* one request has sense data, the other not -> no match, return 0 */ 2518 if (!sense1 != !sense2) 2519 return 0; 2520 /* no sense data in both cases -> check cstat for IFCC */ 2521 if (!sense1 && !sense2) { 2522 if ((scsw_cstat(&cqr1->irb.scsw) & (SCHN_STAT_INTF_CTRL_CHK | 2523 SCHN_STAT_CHN_CTRL_CHK)) == 2524 (scsw_cstat(&cqr2->irb.scsw) & (SCHN_STAT_INTF_CTRL_CHK | 2525 SCHN_STAT_CHN_CTRL_CHK))) 2526 return 1; /* match with ifcc*/ 2527 } 2528 /* check sense data; byte 0-2,25,27 */ 2529 if (!(sense1 && sense2 && 2530 (memcmp(sense1, sense2, 3) == 0) && 2531 (sense1[27] == sense2[27]) && 2532 (sense1[25] == sense2[25]))) { 2533 2534 return 0; /* sense doesn't match */ 2535 } 2536 2537 return 1; /* match */ 2538 2539 } /* end dasd_3990_erp_error_match */ 2540 2541 /* 2542 * DASD_3990_ERP_IN_ERP 2543 * 2544 * DESCRIPTION 2545 * check if the current error already happened before. 2546 * quick exit if current cqr is not an ERP (cqr->refers=NULL) 2547 * 2548 * PARAMETER 2549 * cqr failed cqr (either original cqr or already an erp) 2550 * 2551 * RETURN VALUES 2552 * erp erp-pointer to the already defined error 2553 * recovery procedure OR 2554 * NULL if a 'new' error occurred. 2555 */ 2556 static struct dasd_ccw_req * 2557 dasd_3990_erp_in_erp(struct dasd_ccw_req *cqr) 2558 { 2559 2560 struct dasd_ccw_req *erp_head = cqr, /* save erp chain head */ 2561 *erp_match = NULL; /* save erp chain head */ 2562 int match = 0; /* 'boolean' for matching error found */ 2563 2564 if (cqr->refers == NULL) { /* return if not in erp */ 2565 return NULL; 2566 } 2567 2568 /* check the erp/cqr chain for current error */ 2569 do { 2570 match = dasd_3990_erp_error_match(erp_head, cqr->refers); 2571 erp_match = cqr; /* save possible matching erp */ 2572 cqr = cqr->refers; /* check next erp/cqr in queue */ 2573 2574 } while ((cqr->refers != NULL) && (!match)); 2575 2576 if (!match) { 2577 return NULL; /* no match was found */ 2578 } 2579 2580 return erp_match; /* return address of matching erp */ 2581 2582 } /* END dasd_3990_erp_in_erp */ 2583 2584 /* 2585 * DASD_3990_ERP_FURTHER_ERP (24 & 32 byte sense) 2586 * 2587 * DESCRIPTION 2588 * No retry is left for the current ERP. Check what has to be done 2589 * with the ERP. 2590 * - do further defined ERP action or 2591 * - wait for interrupt or 2592 * - exit with permanent error 2593 * 2594 * PARAMETER 2595 * erp ERP which is in progress with no retry left 2596 * 2597 * RETURN VALUES 2598 * erp modified/additional ERP 2599 */ 2600 static struct dasd_ccw_req * 2601 dasd_3990_erp_further_erp(struct dasd_ccw_req *erp) 2602 { 2603 2604 struct dasd_device *device = erp->startdev; 2605 char *sense = dasd_get_sense(&erp->irb); 2606 2607 /* check for 24 byte sense ERP */ 2608 if ((erp->function == dasd_3990_erp_bus_out) || 2609 (erp->function == dasd_3990_erp_action_1) || 2610 (erp->function == dasd_3990_erp_action_4)) { 2611 2612 erp = dasd_3990_erp_action_1(erp); 2613 2614 } else if (erp->function == dasd_3990_erp_action_1_sec) { 2615 erp = dasd_3990_erp_action_1_sec(erp); 2616 } else if (erp->function == dasd_3990_erp_action_5) { 2617 2618 /* retries have not been successful */ 2619 /* prepare erp for retry on different channel path */ 2620 erp = dasd_3990_erp_action_1(erp); 2621 2622 if (sense && !(sense[2] & DASD_SENSE_BIT_0)) { 2623 2624 /* issue a Diagnostic Control command with an 2625 * Inhibit Write subcommand */ 2626 2627 switch (sense[25]) { 2628 case 0x17: 2629 case 0x57:{ /* controller */ 2630 erp = dasd_3990_erp_DCTL(erp, 0x20); 2631 break; 2632 } 2633 case 0x18: 2634 case 0x58:{ /* channel path */ 2635 erp = dasd_3990_erp_DCTL(erp, 0x40); 2636 break; 2637 } 2638 case 0x19: 2639 case 0x59:{ /* storage director */ 2640 erp = dasd_3990_erp_DCTL(erp, 0x80); 2641 break; 2642 } 2643 default: 2644 DBF_DEV_EVENT(DBF_WARNING, device, 2645 "invalid subcommand modifier 0x%x " 2646 "for Diagnostic Control Command", 2647 sense[25]); 2648 } 2649 } 2650 2651 /* check for 32 byte sense ERP */ 2652 } else if (sense && 2653 ((erp->function == dasd_3990_erp_compound_retry) || 2654 (erp->function == dasd_3990_erp_compound_path) || 2655 (erp->function == dasd_3990_erp_compound_code) || 2656 (erp->function == dasd_3990_erp_compound_config))) { 2657 2658 erp = dasd_3990_erp_compound(erp, sense); 2659 2660 } else { 2661 /* 2662 * No retry left and no additional special handling 2663 * necessary 2664 */ 2665 dev_err(&device->cdev->dev, 2666 "ERP %p has run out of retries and failed\n", erp); 2667 2668 erp->status = DASD_CQR_FAILED; 2669 } 2670 2671 return erp; 2672 2673 } /* end dasd_3990_erp_further_erp */ 2674 2675 /* 2676 * DASD_3990_ERP_HANDLE_MATCH_ERP 2677 * 2678 * DESCRIPTION 2679 * An error occurred again and an ERP has been detected which is already 2680 * used to handle this error (e.g. retries). 2681 * All prior ERP's are asumed to be successful and therefore removed 2682 * from queue. 2683 * If retry counter of matching erp is already 0, it is checked if further 2684 * action is needed (besides retry) or if the ERP has failed. 2685 * 2686 * PARAMETER 2687 * erp_head first ERP in ERP-chain 2688 * erp ERP that handles the actual error. 2689 * (matching erp) 2690 * 2691 * RETURN VALUES 2692 * erp modified/additional ERP 2693 */ 2694 static struct dasd_ccw_req * 2695 dasd_3990_erp_handle_match_erp(struct dasd_ccw_req *erp_head, 2696 struct dasd_ccw_req *erp) 2697 { 2698 2699 struct dasd_device *device = erp_head->startdev; 2700 struct dasd_ccw_req *erp_done = erp_head; /* finished req */ 2701 struct dasd_ccw_req *erp_free = NULL; /* req to be freed */ 2702 2703 /* loop over successful ERPs and remove them from chanq */ 2704 while (erp_done != erp) { 2705 2706 if (erp_done == NULL) /* end of chain reached */ 2707 panic(PRINTK_HEADER "Programming error in ERP! The " 2708 "original request was lost\n"); 2709 2710 /* remove the request from the device queue */ 2711 list_del(&erp_done->blocklist); 2712 2713 erp_free = erp_done; 2714 erp_done = erp_done->refers; 2715 2716 /* free the finished erp request */ 2717 dasd_free_erp_request(erp_free, erp_free->memdev); 2718 2719 } /* end while */ 2720 2721 if (erp->retries > 0) { 2722 2723 char *sense = dasd_get_sense(&erp->refers->irb); 2724 2725 /* check for special retries */ 2726 if (sense && erp->function == dasd_3990_erp_action_4) { 2727 2728 erp = dasd_3990_erp_action_4(erp, sense); 2729 2730 } else if (sense && 2731 erp->function == dasd_3990_erp_action_1B_32) { 2732 2733 erp = dasd_3990_update_1B(erp, sense); 2734 2735 } else if (sense && erp->function == dasd_3990_erp_int_req) { 2736 2737 erp = dasd_3990_erp_int_req(erp); 2738 2739 } else { 2740 /* simple retry */ 2741 DBF_DEV_EVENT(DBF_DEBUG, device, 2742 "%i retries left for erp %p", 2743 erp->retries, erp); 2744 2745 /* handle the request again... */ 2746 erp->status = DASD_CQR_FILLED; 2747 } 2748 2749 } else { 2750 /* no retry left - check for further necessary action */ 2751 /* if no further actions, handle rest as permanent error */ 2752 erp = dasd_3990_erp_further_erp(erp); 2753 } 2754 2755 return erp; 2756 2757 } /* end dasd_3990_erp_handle_match_erp */ 2758 2759 /* 2760 * DASD_3990_ERP_ACTION 2761 * 2762 * DESCRIPTION 2763 * control routine for 3990 erp actions. 2764 * Has to be called with the queue lock (namely the s390_irq_lock) acquired. 2765 * 2766 * PARAMETER 2767 * cqr failed cqr (either original cqr or already an erp) 2768 * 2769 * RETURN VALUES 2770 * erp erp-pointer to the head of the ERP action chain. 2771 * This means: 2772 * - either a ptr to an additional ERP cqr or 2773 * - the original given cqr (which's status might 2774 * be modified) 2775 */ 2776 struct dasd_ccw_req * 2777 dasd_3990_erp_action(struct dasd_ccw_req * cqr) 2778 { 2779 struct dasd_ccw_req *erp = NULL; 2780 struct dasd_device *device = cqr->startdev; 2781 struct dasd_ccw_req *temp_erp = NULL; 2782 2783 if (device->features & DASD_FEATURE_ERPLOG) { 2784 /* print current erp_chain */ 2785 dev_err(&device->cdev->dev, 2786 "ERP chain at BEGINNING of ERP-ACTION\n"); 2787 for (temp_erp = cqr; 2788 temp_erp != NULL; temp_erp = temp_erp->refers) { 2789 2790 dev_err(&device->cdev->dev, 2791 "ERP %p (%02x) refers to %p\n", 2792 temp_erp, temp_erp->status, 2793 temp_erp->refers); 2794 } 2795 } 2796 2797 /* double-check if current erp/cqr was successful */ 2798 if ((scsw_cstat(&cqr->irb.scsw) == 0x00) && 2799 (scsw_dstat(&cqr->irb.scsw) == 2800 (DEV_STAT_CHN_END | DEV_STAT_DEV_END))) { 2801 2802 DBF_DEV_EVENT(DBF_DEBUG, device, 2803 "ERP called for successful request %p" 2804 " - NO ERP necessary", cqr); 2805 2806 cqr->status = DASD_CQR_DONE; 2807 2808 return cqr; 2809 } 2810 2811 /* check if error happened before */ 2812 erp = dasd_3990_erp_in_erp(cqr); 2813 2814 if (erp == NULL) { 2815 /* no matching erp found - set up erp */ 2816 erp = dasd_3990_erp_additional_erp(cqr); 2817 if (IS_ERR(erp)) 2818 return erp; 2819 } else { 2820 /* matching erp found - set all leading erp's to DONE */ 2821 erp = dasd_3990_erp_handle_match_erp(cqr, erp); 2822 } 2823 2824 2825 /* 2826 * For path verification work we need to stick with the path that was 2827 * originally chosen so that the per path configuration data is 2828 * assigned correctly. 2829 */ 2830 if (test_bit(DASD_CQR_VERIFY_PATH, &erp->flags) && cqr->lpm) { 2831 erp->lpm = cqr->lpm; 2832 } 2833 2834 if (device->features & DASD_FEATURE_ERPLOG) { 2835 /* print current erp_chain */ 2836 dev_err(&device->cdev->dev, 2837 "ERP chain at END of ERP-ACTION\n"); 2838 for (temp_erp = erp; 2839 temp_erp != NULL; temp_erp = temp_erp->refers) { 2840 2841 dev_err(&device->cdev->dev, 2842 "ERP %p (%02x) refers to %p\n", 2843 temp_erp, temp_erp->status, 2844 temp_erp->refers); 2845 } 2846 } 2847 2848 /* enqueue ERP request if it's a new one */ 2849 if (list_empty(&erp->blocklist)) { 2850 cqr->status = DASD_CQR_IN_ERP; 2851 /* add erp request before the cqr */ 2852 list_add_tail(&erp->blocklist, &cqr->blocklist); 2853 } 2854 2855 2856 2857 return erp; 2858 2859 } /* end dasd_3990_erp_action */ 2860