1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * libata-eh.c - libata error handling 4 * 5 * Copyright 2006 Tejun Heo <htejun@gmail.com> 6 * 7 * libata documentation is available via 'make {ps|pdf}docs', 8 * as Documentation/driver-api/libata.rst 9 * 10 * Hardware documentation available from http://www.t13.org/ and 11 * http://www.sata-io.org/ 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/blkdev.h> 16 #include <linux/export.h> 17 #include <linux/pci.h> 18 #include <scsi/scsi.h> 19 #include <scsi/scsi_host.h> 20 #include <scsi/scsi_eh.h> 21 #include <scsi/scsi_device.h> 22 #include <scsi/scsi_cmnd.h> 23 #include <scsi/scsi_dbg.h> 24 #include "../scsi/scsi_transport_api.h" 25 26 #include <linux/libata.h> 27 28 #include <trace/events/libata.h> 29 #include "libata.h" 30 31 enum { 32 /* speed down verdicts */ 33 ATA_EH_SPDN_NCQ_OFF = (1 << 0), 34 ATA_EH_SPDN_SPEED_DOWN = (1 << 1), 35 ATA_EH_SPDN_FALLBACK_TO_PIO = (1 << 2), 36 ATA_EH_SPDN_KEEP_ERRORS = (1 << 3), 37 38 /* error flags */ 39 ATA_EFLAG_IS_IO = (1 << 0), 40 ATA_EFLAG_DUBIOUS_XFER = (1 << 1), 41 ATA_EFLAG_OLD_ER = (1 << 31), 42 43 /* error categories */ 44 ATA_ECAT_NONE = 0, 45 ATA_ECAT_ATA_BUS = 1, 46 ATA_ECAT_TOUT_HSM = 2, 47 ATA_ECAT_UNK_DEV = 3, 48 ATA_ECAT_DUBIOUS_NONE = 4, 49 ATA_ECAT_DUBIOUS_ATA_BUS = 5, 50 ATA_ECAT_DUBIOUS_TOUT_HSM = 6, 51 ATA_ECAT_DUBIOUS_UNK_DEV = 7, 52 ATA_ECAT_NR = 8, 53 54 ATA_EH_CMD_DFL_TIMEOUT = 5000, 55 56 /* always put at least this amount of time between resets */ 57 ATA_EH_RESET_COOL_DOWN = 5000, 58 59 /* Waiting in ->prereset can never be reliable. It's 60 * sometimes nice to wait there but it can't be depended upon; 61 * otherwise, we wouldn't be resetting. Just give it enough 62 * time for most drives to spin up. 63 */ 64 ATA_EH_PRERESET_TIMEOUT = 10000, 65 ATA_EH_FASTDRAIN_INTERVAL = 3000, 66 67 ATA_EH_UA_TRIES = 5, 68 69 /* probe speed down parameters, see ata_eh_schedule_probe() */ 70 ATA_EH_PROBE_TRIAL_INTERVAL = 60000, /* 1 min */ 71 ATA_EH_PROBE_TRIALS = 2, 72 }; 73 74 /* The following table determines how we sequence resets. Each entry 75 * represents timeout for that try. The first try can be soft or 76 * hardreset. All others are hardreset if available. In most cases 77 * the first reset w/ 10sec timeout should succeed. Following entries 78 * are mostly for error handling, hotplug and those outlier devices that 79 * take an exceptionally long time to recover from reset. 80 */ 81 static const unsigned long ata_eh_reset_timeouts[] = { 82 10000, /* most drives spin up by 10sec */ 83 10000, /* > 99% working drives spin up before 20sec */ 84 35000, /* give > 30 secs of idleness for outlier devices */ 85 5000, /* and sweet one last chance */ 86 ULONG_MAX, /* > 1 min has elapsed, give up */ 87 }; 88 89 static const unsigned long ata_eh_identify_timeouts[] = { 90 5000, /* covers > 99% of successes and not too boring on failures */ 91 10000, /* combined time till here is enough even for media access */ 92 30000, /* for true idiots */ 93 ULONG_MAX, 94 }; 95 96 static const unsigned long ata_eh_flush_timeouts[] = { 97 15000, /* be generous with flush */ 98 15000, /* ditto */ 99 30000, /* and even more generous */ 100 ULONG_MAX, 101 }; 102 103 static const unsigned long ata_eh_other_timeouts[] = { 104 5000, /* same rationale as identify timeout */ 105 10000, /* ditto */ 106 /* but no merciful 30sec for other commands, it just isn't worth it */ 107 ULONG_MAX, 108 }; 109 110 struct ata_eh_cmd_timeout_ent { 111 const u8 *commands; 112 const unsigned long *timeouts; 113 }; 114 115 /* The following table determines timeouts to use for EH internal 116 * commands. Each table entry is a command class and matches the 117 * commands the entry applies to and the timeout table to use. 118 * 119 * On the retry after a command timed out, the next timeout value from 120 * the table is used. If the table doesn't contain further entries, 121 * the last value is used. 122 * 123 * ehc->cmd_timeout_idx keeps track of which timeout to use per 124 * command class, so if SET_FEATURES times out on the first try, the 125 * next try will use the second timeout value only for that class. 126 */ 127 #define CMDS(cmds...) (const u8 []){ cmds, 0 } 128 static const struct ata_eh_cmd_timeout_ent 129 ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = { 130 { .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI), 131 .timeouts = ata_eh_identify_timeouts, }, 132 { .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT), 133 .timeouts = ata_eh_other_timeouts, }, 134 { .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT), 135 .timeouts = ata_eh_other_timeouts, }, 136 { .commands = CMDS(ATA_CMD_SET_FEATURES), 137 .timeouts = ata_eh_other_timeouts, }, 138 { .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS), 139 .timeouts = ata_eh_other_timeouts, }, 140 { .commands = CMDS(ATA_CMD_FLUSH, ATA_CMD_FLUSH_EXT), 141 .timeouts = ata_eh_flush_timeouts }, 142 }; 143 #undef CMDS 144 145 static void __ata_port_freeze(struct ata_port *ap); 146 #ifdef CONFIG_PM 147 static void ata_eh_handle_port_suspend(struct ata_port *ap); 148 static void ata_eh_handle_port_resume(struct ata_port *ap); 149 #else /* CONFIG_PM */ 150 static void ata_eh_handle_port_suspend(struct ata_port *ap) 151 { } 152 153 static void ata_eh_handle_port_resume(struct ata_port *ap) 154 { } 155 #endif /* CONFIG_PM */ 156 157 static __printf(2, 0) void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, 158 const char *fmt, va_list args) 159 { 160 ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len, 161 ATA_EH_DESC_LEN - ehi->desc_len, 162 fmt, args); 163 } 164 165 /** 166 * __ata_ehi_push_desc - push error description without adding separator 167 * @ehi: target EHI 168 * @fmt: printf format string 169 * 170 * Format string according to @fmt and append it to @ehi->desc. 171 * 172 * LOCKING: 173 * spin_lock_irqsave(host lock) 174 */ 175 void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...) 176 { 177 va_list args; 178 179 va_start(args, fmt); 180 __ata_ehi_pushv_desc(ehi, fmt, args); 181 va_end(args); 182 } 183 EXPORT_SYMBOL_GPL(__ata_ehi_push_desc); 184 185 /** 186 * ata_ehi_push_desc - push error description with separator 187 * @ehi: target EHI 188 * @fmt: printf format string 189 * 190 * Format string according to @fmt and append it to @ehi->desc. 191 * If @ehi->desc is not empty, ", " is added in-between. 192 * 193 * LOCKING: 194 * spin_lock_irqsave(host lock) 195 */ 196 void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...) 197 { 198 va_list args; 199 200 if (ehi->desc_len) 201 __ata_ehi_push_desc(ehi, ", "); 202 203 va_start(args, fmt); 204 __ata_ehi_pushv_desc(ehi, fmt, args); 205 va_end(args); 206 } 207 EXPORT_SYMBOL_GPL(ata_ehi_push_desc); 208 209 /** 210 * ata_ehi_clear_desc - clean error description 211 * @ehi: target EHI 212 * 213 * Clear @ehi->desc. 214 * 215 * LOCKING: 216 * spin_lock_irqsave(host lock) 217 */ 218 void ata_ehi_clear_desc(struct ata_eh_info *ehi) 219 { 220 ehi->desc[0] = '\0'; 221 ehi->desc_len = 0; 222 } 223 EXPORT_SYMBOL_GPL(ata_ehi_clear_desc); 224 225 /** 226 * ata_port_desc - append port description 227 * @ap: target ATA port 228 * @fmt: printf format string 229 * 230 * Format string according to @fmt and append it to port 231 * description. If port description is not empty, " " is added 232 * in-between. This function is to be used while initializing 233 * ata_host. The description is printed on host registration. 234 * 235 * LOCKING: 236 * None. 237 */ 238 void ata_port_desc(struct ata_port *ap, const char *fmt, ...) 239 { 240 va_list args; 241 242 WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING)); 243 244 if (ap->link.eh_info.desc_len) 245 __ata_ehi_push_desc(&ap->link.eh_info, " "); 246 247 va_start(args, fmt); 248 __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args); 249 va_end(args); 250 } 251 EXPORT_SYMBOL_GPL(ata_port_desc); 252 253 #ifdef CONFIG_PCI 254 /** 255 * ata_port_pbar_desc - append PCI BAR description 256 * @ap: target ATA port 257 * @bar: target PCI BAR 258 * @offset: offset into PCI BAR 259 * @name: name of the area 260 * 261 * If @offset is negative, this function formats a string which 262 * contains the name, address, size and type of the BAR and 263 * appends it to the port description. If @offset is zero or 264 * positive, only name and offsetted address is appended. 265 * 266 * LOCKING: 267 * None. 268 */ 269 void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset, 270 const char *name) 271 { 272 struct pci_dev *pdev = to_pci_dev(ap->host->dev); 273 char *type = ""; 274 unsigned long long start, len; 275 276 if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) 277 type = "m"; 278 else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO) 279 type = "i"; 280 281 start = (unsigned long long)pci_resource_start(pdev, bar); 282 len = (unsigned long long)pci_resource_len(pdev, bar); 283 284 if (offset < 0) 285 ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start); 286 else 287 ata_port_desc(ap, "%s 0x%llx", name, 288 start + (unsigned long long)offset); 289 } 290 EXPORT_SYMBOL_GPL(ata_port_pbar_desc); 291 #endif /* CONFIG_PCI */ 292 293 static int ata_lookup_timeout_table(u8 cmd) 294 { 295 int i; 296 297 for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) { 298 const u8 *cur; 299 300 for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++) 301 if (*cur == cmd) 302 return i; 303 } 304 305 return -1; 306 } 307 308 /** 309 * ata_internal_cmd_timeout - determine timeout for an internal command 310 * @dev: target device 311 * @cmd: internal command to be issued 312 * 313 * Determine timeout for internal command @cmd for @dev. 314 * 315 * LOCKING: 316 * EH context. 317 * 318 * RETURNS: 319 * Determined timeout. 320 */ 321 unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd) 322 { 323 struct ata_eh_context *ehc = &dev->link->eh_context; 324 int ent = ata_lookup_timeout_table(cmd); 325 int idx; 326 327 if (ent < 0) 328 return ATA_EH_CMD_DFL_TIMEOUT; 329 330 idx = ehc->cmd_timeout_idx[dev->devno][ent]; 331 return ata_eh_cmd_timeout_table[ent].timeouts[idx]; 332 } 333 334 /** 335 * ata_internal_cmd_timed_out - notification for internal command timeout 336 * @dev: target device 337 * @cmd: internal command which timed out 338 * 339 * Notify EH that internal command @cmd for @dev timed out. This 340 * function should be called only for commands whose timeouts are 341 * determined using ata_internal_cmd_timeout(). 342 * 343 * LOCKING: 344 * EH context. 345 */ 346 void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd) 347 { 348 struct ata_eh_context *ehc = &dev->link->eh_context; 349 int ent = ata_lookup_timeout_table(cmd); 350 int idx; 351 352 if (ent < 0) 353 return; 354 355 idx = ehc->cmd_timeout_idx[dev->devno][ent]; 356 if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX) 357 ehc->cmd_timeout_idx[dev->devno][ent]++; 358 } 359 360 static void ata_ering_record(struct ata_ering *ering, unsigned int eflags, 361 unsigned int err_mask) 362 { 363 struct ata_ering_entry *ent; 364 365 WARN_ON(!err_mask); 366 367 ering->cursor++; 368 ering->cursor %= ATA_ERING_SIZE; 369 370 ent = &ering->ring[ering->cursor]; 371 ent->eflags = eflags; 372 ent->err_mask = err_mask; 373 ent->timestamp = get_jiffies_64(); 374 } 375 376 static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering) 377 { 378 struct ata_ering_entry *ent = &ering->ring[ering->cursor]; 379 380 if (ent->err_mask) 381 return ent; 382 return NULL; 383 } 384 385 int ata_ering_map(struct ata_ering *ering, 386 int (*map_fn)(struct ata_ering_entry *, void *), 387 void *arg) 388 { 389 int idx, rc = 0; 390 struct ata_ering_entry *ent; 391 392 idx = ering->cursor; 393 do { 394 ent = &ering->ring[idx]; 395 if (!ent->err_mask) 396 break; 397 rc = map_fn(ent, arg); 398 if (rc) 399 break; 400 idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE; 401 } while (idx != ering->cursor); 402 403 return rc; 404 } 405 406 static int ata_ering_clear_cb(struct ata_ering_entry *ent, void *void_arg) 407 { 408 ent->eflags |= ATA_EFLAG_OLD_ER; 409 return 0; 410 } 411 412 static void ata_ering_clear(struct ata_ering *ering) 413 { 414 ata_ering_map(ering, ata_ering_clear_cb, NULL); 415 } 416 417 static unsigned int ata_eh_dev_action(struct ata_device *dev) 418 { 419 struct ata_eh_context *ehc = &dev->link->eh_context; 420 421 return ehc->i.action | ehc->i.dev_action[dev->devno]; 422 } 423 424 static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev, 425 struct ata_eh_info *ehi, unsigned int action) 426 { 427 struct ata_device *tdev; 428 429 if (!dev) { 430 ehi->action &= ~action; 431 ata_for_each_dev(tdev, link, ALL) 432 ehi->dev_action[tdev->devno] &= ~action; 433 } else { 434 /* doesn't make sense for port-wide EH actions */ 435 WARN_ON(!(action & ATA_EH_PERDEV_MASK)); 436 437 /* break ehi->action into ehi->dev_action */ 438 if (ehi->action & action) { 439 ata_for_each_dev(tdev, link, ALL) 440 ehi->dev_action[tdev->devno] |= 441 ehi->action & action; 442 ehi->action &= ~action; 443 } 444 445 /* turn off the specified per-dev action */ 446 ehi->dev_action[dev->devno] &= ~action; 447 } 448 } 449 450 /** 451 * ata_eh_acquire - acquire EH ownership 452 * @ap: ATA port to acquire EH ownership for 453 * 454 * Acquire EH ownership for @ap. This is the basic exclusion 455 * mechanism for ports sharing a host. Only one port hanging off 456 * the same host can claim the ownership of EH. 457 * 458 * LOCKING: 459 * EH context. 460 */ 461 void ata_eh_acquire(struct ata_port *ap) 462 { 463 mutex_lock(&ap->host->eh_mutex); 464 WARN_ON_ONCE(ap->host->eh_owner); 465 ap->host->eh_owner = current; 466 } 467 468 /** 469 * ata_eh_release - release EH ownership 470 * @ap: ATA port to release EH ownership for 471 * 472 * Release EH ownership for @ap if the caller. The caller must 473 * have acquired EH ownership using ata_eh_acquire() previously. 474 * 475 * LOCKING: 476 * EH context. 477 */ 478 void ata_eh_release(struct ata_port *ap) 479 { 480 WARN_ON_ONCE(ap->host->eh_owner != current); 481 ap->host->eh_owner = NULL; 482 mutex_unlock(&ap->host->eh_mutex); 483 } 484 485 static void ata_eh_unload(struct ata_port *ap) 486 { 487 struct ata_link *link; 488 struct ata_device *dev; 489 unsigned long flags; 490 491 /* Restore SControl IPM and SPD for the next driver and 492 * disable attached devices. 493 */ 494 ata_for_each_link(link, ap, PMP_FIRST) { 495 sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0); 496 ata_for_each_dev(dev, link, ALL) 497 ata_dev_disable(dev); 498 } 499 500 /* freeze and set UNLOADED */ 501 spin_lock_irqsave(ap->lock, flags); 502 503 ata_port_freeze(ap); /* won't be thawed */ 504 ap->pflags &= ~ATA_PFLAG_EH_PENDING; /* clear pending from freeze */ 505 ap->pflags |= ATA_PFLAG_UNLOADED; 506 507 spin_unlock_irqrestore(ap->lock, flags); 508 } 509 510 /** 511 * ata_scsi_error - SCSI layer error handler callback 512 * @host: SCSI host on which error occurred 513 * 514 * Handles SCSI-layer-thrown error events. 515 * 516 * LOCKING: 517 * Inherited from SCSI layer (none, can sleep) 518 * 519 * RETURNS: 520 * Zero. 521 */ 522 void ata_scsi_error(struct Scsi_Host *host) 523 { 524 struct ata_port *ap = ata_shost_to_port(host); 525 unsigned long flags; 526 LIST_HEAD(eh_work_q); 527 528 DPRINTK("ENTER\n"); 529 530 spin_lock_irqsave(host->host_lock, flags); 531 list_splice_init(&host->eh_cmd_q, &eh_work_q); 532 spin_unlock_irqrestore(host->host_lock, flags); 533 534 ata_scsi_cmd_error_handler(host, ap, &eh_work_q); 535 536 /* If we timed raced normal completion and there is nothing to 537 recover nr_timedout == 0 why exactly are we doing error recovery ? */ 538 ata_scsi_port_error_handler(host, ap); 539 540 /* finish or retry handled scmd's and clean up */ 541 WARN_ON(!list_empty(&eh_work_q)); 542 543 DPRINTK("EXIT\n"); 544 } 545 546 /** 547 * ata_scsi_cmd_error_handler - error callback for a list of commands 548 * @host: scsi host containing the port 549 * @ap: ATA port within the host 550 * @eh_work_q: list of commands to process 551 * 552 * process the given list of commands and return those finished to the 553 * ap->eh_done_q. This function is the first part of the libata error 554 * handler which processes a given list of failed commands. 555 */ 556 void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap, 557 struct list_head *eh_work_q) 558 { 559 int i; 560 unsigned long flags; 561 562 /* make sure sff pio task is not running */ 563 ata_sff_flush_pio_task(ap); 564 565 /* synchronize with host lock and sort out timeouts */ 566 567 /* For new EH, all qcs are finished in one of three ways - 568 * normal completion, error completion, and SCSI timeout. 569 * Both completions can race against SCSI timeout. When normal 570 * completion wins, the qc never reaches EH. When error 571 * completion wins, the qc has ATA_QCFLAG_FAILED set. 572 * 573 * When SCSI timeout wins, things are a bit more complex. 574 * Normal or error completion can occur after the timeout but 575 * before this point. In such cases, both types of 576 * completions are honored. A scmd is determined to have 577 * timed out iff its associated qc is active and not failed. 578 */ 579 spin_lock_irqsave(ap->lock, flags); 580 if (ap->ops->error_handler) { 581 struct scsi_cmnd *scmd, *tmp; 582 int nr_timedout = 0; 583 584 /* This must occur under the ap->lock as we don't want 585 a polled recovery to race the real interrupt handler 586 587 The lost_interrupt handler checks for any completed but 588 non-notified command and completes much like an IRQ handler. 589 590 We then fall into the error recovery code which will treat 591 this as if normal completion won the race */ 592 593 if (ap->ops->lost_interrupt) 594 ap->ops->lost_interrupt(ap); 595 596 list_for_each_entry_safe(scmd, tmp, eh_work_q, eh_entry) { 597 struct ata_queued_cmd *qc; 598 599 ata_qc_for_each_raw(ap, qc, i) { 600 if (qc->flags & ATA_QCFLAG_ACTIVE && 601 qc->scsicmd == scmd) 602 break; 603 } 604 605 if (i < ATA_MAX_QUEUE) { 606 /* the scmd has an associated qc */ 607 if (!(qc->flags & ATA_QCFLAG_FAILED)) { 608 /* which hasn't failed yet, timeout */ 609 qc->err_mask |= AC_ERR_TIMEOUT; 610 qc->flags |= ATA_QCFLAG_FAILED; 611 nr_timedout++; 612 } 613 } else { 614 /* Normal completion occurred after 615 * SCSI timeout but before this point. 616 * Successfully complete it. 617 */ 618 scmd->retries = scmd->allowed; 619 scsi_eh_finish_cmd(scmd, &ap->eh_done_q); 620 } 621 } 622 623 /* If we have timed out qcs. They belong to EH from 624 * this point but the state of the controller is 625 * unknown. Freeze the port to make sure the IRQ 626 * handler doesn't diddle with those qcs. This must 627 * be done atomically w.r.t. setting QCFLAG_FAILED. 628 */ 629 if (nr_timedout) 630 __ata_port_freeze(ap); 631 632 633 /* initialize eh_tries */ 634 ap->eh_tries = ATA_EH_MAX_TRIES; 635 } 636 spin_unlock_irqrestore(ap->lock, flags); 637 638 } 639 EXPORT_SYMBOL(ata_scsi_cmd_error_handler); 640 641 /** 642 * ata_scsi_port_error_handler - recover the port after the commands 643 * @host: SCSI host containing the port 644 * @ap: the ATA port 645 * 646 * Handle the recovery of the port @ap after all the commands 647 * have been recovered. 648 */ 649 void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap) 650 { 651 unsigned long flags; 652 653 /* invoke error handler */ 654 if (ap->ops->error_handler) { 655 struct ata_link *link; 656 657 /* acquire EH ownership */ 658 ata_eh_acquire(ap); 659 repeat: 660 /* kill fast drain timer */ 661 del_timer_sync(&ap->fastdrain_timer); 662 663 /* process port resume request */ 664 ata_eh_handle_port_resume(ap); 665 666 /* fetch & clear EH info */ 667 spin_lock_irqsave(ap->lock, flags); 668 669 ata_for_each_link(link, ap, HOST_FIRST) { 670 struct ata_eh_context *ehc = &link->eh_context; 671 struct ata_device *dev; 672 673 memset(&link->eh_context, 0, sizeof(link->eh_context)); 674 link->eh_context.i = link->eh_info; 675 memset(&link->eh_info, 0, sizeof(link->eh_info)); 676 677 ata_for_each_dev(dev, link, ENABLED) { 678 int devno = dev->devno; 679 680 ehc->saved_xfer_mode[devno] = dev->xfer_mode; 681 if (ata_ncq_enabled(dev)) 682 ehc->saved_ncq_enabled |= 1 << devno; 683 } 684 } 685 686 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS; 687 ap->pflags &= ~ATA_PFLAG_EH_PENDING; 688 ap->excl_link = NULL; /* don't maintain exclusion over EH */ 689 690 spin_unlock_irqrestore(ap->lock, flags); 691 692 /* invoke EH, skip if unloading or suspended */ 693 if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED))) 694 ap->ops->error_handler(ap); 695 else { 696 /* if unloading, commence suicide */ 697 if ((ap->pflags & ATA_PFLAG_UNLOADING) && 698 !(ap->pflags & ATA_PFLAG_UNLOADED)) 699 ata_eh_unload(ap); 700 ata_eh_finish(ap); 701 } 702 703 /* process port suspend request */ 704 ata_eh_handle_port_suspend(ap); 705 706 /* Exception might have happened after ->error_handler 707 * recovered the port but before this point. Repeat 708 * EH in such case. 709 */ 710 spin_lock_irqsave(ap->lock, flags); 711 712 if (ap->pflags & ATA_PFLAG_EH_PENDING) { 713 if (--ap->eh_tries) { 714 spin_unlock_irqrestore(ap->lock, flags); 715 goto repeat; 716 } 717 ata_port_err(ap, 718 "EH pending after %d tries, giving up\n", 719 ATA_EH_MAX_TRIES); 720 ap->pflags &= ~ATA_PFLAG_EH_PENDING; 721 } 722 723 /* this run is complete, make sure EH info is clear */ 724 ata_for_each_link(link, ap, HOST_FIRST) 725 memset(&link->eh_info, 0, sizeof(link->eh_info)); 726 727 /* end eh (clear host_eh_scheduled) while holding 728 * ap->lock such that if exception occurs after this 729 * point but before EH completion, SCSI midlayer will 730 * re-initiate EH. 731 */ 732 ap->ops->end_eh(ap); 733 734 spin_unlock_irqrestore(ap->lock, flags); 735 ata_eh_release(ap); 736 } else { 737 WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL); 738 ap->ops->eng_timeout(ap); 739 } 740 741 scsi_eh_flush_done_q(&ap->eh_done_q); 742 743 /* clean up */ 744 spin_lock_irqsave(ap->lock, flags); 745 746 if (ap->pflags & ATA_PFLAG_LOADING) 747 ap->pflags &= ~ATA_PFLAG_LOADING; 748 else if ((ap->pflags & ATA_PFLAG_SCSI_HOTPLUG) && 749 !(ap->flags & ATA_FLAG_SAS_HOST)) 750 schedule_delayed_work(&ap->hotplug_task, 0); 751 752 if (ap->pflags & ATA_PFLAG_RECOVERED) 753 ata_port_info(ap, "EH complete\n"); 754 755 ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED); 756 757 /* tell wait_eh that we're done */ 758 ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS; 759 wake_up_all(&ap->eh_wait_q); 760 761 spin_unlock_irqrestore(ap->lock, flags); 762 } 763 EXPORT_SYMBOL_GPL(ata_scsi_port_error_handler); 764 765 /** 766 * ata_port_wait_eh - Wait for the currently pending EH to complete 767 * @ap: Port to wait EH for 768 * 769 * Wait until the currently pending EH is complete. 770 * 771 * LOCKING: 772 * Kernel thread context (may sleep). 773 */ 774 void ata_port_wait_eh(struct ata_port *ap) 775 { 776 unsigned long flags; 777 DEFINE_WAIT(wait); 778 779 retry: 780 spin_lock_irqsave(ap->lock, flags); 781 782 while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) { 783 prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE); 784 spin_unlock_irqrestore(ap->lock, flags); 785 schedule(); 786 spin_lock_irqsave(ap->lock, flags); 787 } 788 finish_wait(&ap->eh_wait_q, &wait); 789 790 spin_unlock_irqrestore(ap->lock, flags); 791 792 /* make sure SCSI EH is complete */ 793 if (scsi_host_in_recovery(ap->scsi_host)) { 794 ata_msleep(ap, 10); 795 goto retry; 796 } 797 } 798 EXPORT_SYMBOL_GPL(ata_port_wait_eh); 799 800 static int ata_eh_nr_in_flight(struct ata_port *ap) 801 { 802 struct ata_queued_cmd *qc; 803 unsigned int tag; 804 int nr = 0; 805 806 /* count only non-internal commands */ 807 ata_qc_for_each(ap, qc, tag) { 808 if (qc) 809 nr++; 810 } 811 812 return nr; 813 } 814 815 void ata_eh_fastdrain_timerfn(struct timer_list *t) 816 { 817 struct ata_port *ap = from_timer(ap, t, fastdrain_timer); 818 unsigned long flags; 819 int cnt; 820 821 spin_lock_irqsave(ap->lock, flags); 822 823 cnt = ata_eh_nr_in_flight(ap); 824 825 /* are we done? */ 826 if (!cnt) 827 goto out_unlock; 828 829 if (cnt == ap->fastdrain_cnt) { 830 struct ata_queued_cmd *qc; 831 unsigned int tag; 832 833 /* No progress during the last interval, tag all 834 * in-flight qcs as timed out and freeze the port. 835 */ 836 ata_qc_for_each(ap, qc, tag) { 837 if (qc) 838 qc->err_mask |= AC_ERR_TIMEOUT; 839 } 840 841 ata_port_freeze(ap); 842 } else { 843 /* some qcs have finished, give it another chance */ 844 ap->fastdrain_cnt = cnt; 845 ap->fastdrain_timer.expires = 846 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL); 847 add_timer(&ap->fastdrain_timer); 848 } 849 850 out_unlock: 851 spin_unlock_irqrestore(ap->lock, flags); 852 } 853 854 /** 855 * ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain 856 * @ap: target ATA port 857 * @fastdrain: activate fast drain 858 * 859 * Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain 860 * is non-zero and EH wasn't pending before. Fast drain ensures 861 * that EH kicks in in timely manner. 862 * 863 * LOCKING: 864 * spin_lock_irqsave(host lock) 865 */ 866 static void ata_eh_set_pending(struct ata_port *ap, int fastdrain) 867 { 868 int cnt; 869 870 /* already scheduled? */ 871 if (ap->pflags & ATA_PFLAG_EH_PENDING) 872 return; 873 874 ap->pflags |= ATA_PFLAG_EH_PENDING; 875 876 if (!fastdrain) 877 return; 878 879 /* do we have in-flight qcs? */ 880 cnt = ata_eh_nr_in_flight(ap); 881 if (!cnt) 882 return; 883 884 /* activate fast drain */ 885 ap->fastdrain_cnt = cnt; 886 ap->fastdrain_timer.expires = 887 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL); 888 add_timer(&ap->fastdrain_timer); 889 } 890 891 /** 892 * ata_qc_schedule_eh - schedule qc for error handling 893 * @qc: command to schedule error handling for 894 * 895 * Schedule error handling for @qc. EH will kick in as soon as 896 * other commands are drained. 897 * 898 * LOCKING: 899 * spin_lock_irqsave(host lock) 900 */ 901 void ata_qc_schedule_eh(struct ata_queued_cmd *qc) 902 { 903 struct ata_port *ap = qc->ap; 904 905 WARN_ON(!ap->ops->error_handler); 906 907 qc->flags |= ATA_QCFLAG_FAILED; 908 ata_eh_set_pending(ap, 1); 909 910 /* The following will fail if timeout has already expired. 911 * ata_scsi_error() takes care of such scmds on EH entry. 912 * Note that ATA_QCFLAG_FAILED is unconditionally set after 913 * this function completes. 914 */ 915 blk_abort_request(qc->scsicmd->request); 916 } 917 918 /** 919 * ata_std_sched_eh - non-libsas ata_ports issue eh with this common routine 920 * @ap: ATA port to schedule EH for 921 * 922 * LOCKING: inherited from ata_port_schedule_eh 923 * spin_lock_irqsave(host lock) 924 */ 925 void ata_std_sched_eh(struct ata_port *ap) 926 { 927 WARN_ON(!ap->ops->error_handler); 928 929 if (ap->pflags & ATA_PFLAG_INITIALIZING) 930 return; 931 932 ata_eh_set_pending(ap, 1); 933 scsi_schedule_eh(ap->scsi_host); 934 935 DPRINTK("port EH scheduled\n"); 936 } 937 EXPORT_SYMBOL_GPL(ata_std_sched_eh); 938 939 /** 940 * ata_std_end_eh - non-libsas ata_ports complete eh with this common routine 941 * @ap: ATA port to end EH for 942 * 943 * In the libata object model there is a 1:1 mapping of ata_port to 944 * shost, so host fields can be directly manipulated under ap->lock, in 945 * the libsas case we need to hold a lock at the ha->level to coordinate 946 * these events. 947 * 948 * LOCKING: 949 * spin_lock_irqsave(host lock) 950 */ 951 void ata_std_end_eh(struct ata_port *ap) 952 { 953 struct Scsi_Host *host = ap->scsi_host; 954 955 host->host_eh_scheduled = 0; 956 } 957 EXPORT_SYMBOL(ata_std_end_eh); 958 959 960 /** 961 * ata_port_schedule_eh - schedule error handling without a qc 962 * @ap: ATA port to schedule EH for 963 * 964 * Schedule error handling for @ap. EH will kick in as soon as 965 * all commands are drained. 966 * 967 * LOCKING: 968 * spin_lock_irqsave(host lock) 969 */ 970 void ata_port_schedule_eh(struct ata_port *ap) 971 { 972 /* see: ata_std_sched_eh, unless you know better */ 973 ap->ops->sched_eh(ap); 974 } 975 EXPORT_SYMBOL_GPL(ata_port_schedule_eh); 976 977 static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link) 978 { 979 struct ata_queued_cmd *qc; 980 int tag, nr_aborted = 0; 981 982 WARN_ON(!ap->ops->error_handler); 983 984 /* we're gonna abort all commands, no need for fast drain */ 985 ata_eh_set_pending(ap, 0); 986 987 /* include internal tag in iteration */ 988 ata_qc_for_each_with_internal(ap, qc, tag) { 989 if (qc && (!link || qc->dev->link == link)) { 990 qc->flags |= ATA_QCFLAG_FAILED; 991 ata_qc_complete(qc); 992 nr_aborted++; 993 } 994 } 995 996 if (!nr_aborted) 997 ata_port_schedule_eh(ap); 998 999 return nr_aborted; 1000 } 1001 1002 /** 1003 * ata_link_abort - abort all qc's on the link 1004 * @link: ATA link to abort qc's for 1005 * 1006 * Abort all active qc's active on @link and schedule EH. 1007 * 1008 * LOCKING: 1009 * spin_lock_irqsave(host lock) 1010 * 1011 * RETURNS: 1012 * Number of aborted qc's. 1013 */ 1014 int ata_link_abort(struct ata_link *link) 1015 { 1016 return ata_do_link_abort(link->ap, link); 1017 } 1018 EXPORT_SYMBOL_GPL(ata_link_abort); 1019 1020 /** 1021 * ata_port_abort - abort all qc's on the port 1022 * @ap: ATA port to abort qc's for 1023 * 1024 * Abort all active qc's of @ap and schedule EH. 1025 * 1026 * LOCKING: 1027 * spin_lock_irqsave(host_set lock) 1028 * 1029 * RETURNS: 1030 * Number of aborted qc's. 1031 */ 1032 int ata_port_abort(struct ata_port *ap) 1033 { 1034 return ata_do_link_abort(ap, NULL); 1035 } 1036 EXPORT_SYMBOL_GPL(ata_port_abort); 1037 1038 /** 1039 * __ata_port_freeze - freeze port 1040 * @ap: ATA port to freeze 1041 * 1042 * This function is called when HSM violation or some other 1043 * condition disrupts normal operation of the port. Frozen port 1044 * is not allowed to perform any operation until the port is 1045 * thawed, which usually follows a successful reset. 1046 * 1047 * ap->ops->freeze() callback can be used for freezing the port 1048 * hardware-wise (e.g. mask interrupt and stop DMA engine). If a 1049 * port cannot be frozen hardware-wise, the interrupt handler 1050 * must ack and clear interrupts unconditionally while the port 1051 * is frozen. 1052 * 1053 * LOCKING: 1054 * spin_lock_irqsave(host lock) 1055 */ 1056 static void __ata_port_freeze(struct ata_port *ap) 1057 { 1058 WARN_ON(!ap->ops->error_handler); 1059 1060 if (ap->ops->freeze) 1061 ap->ops->freeze(ap); 1062 1063 ap->pflags |= ATA_PFLAG_FROZEN; 1064 1065 DPRINTK("ata%u port frozen\n", ap->print_id); 1066 } 1067 1068 /** 1069 * ata_port_freeze - abort & freeze port 1070 * @ap: ATA port to freeze 1071 * 1072 * Abort and freeze @ap. The freeze operation must be called 1073 * first, because some hardware requires special operations 1074 * before the taskfile registers are accessible. 1075 * 1076 * LOCKING: 1077 * spin_lock_irqsave(host lock) 1078 * 1079 * RETURNS: 1080 * Number of aborted commands. 1081 */ 1082 int ata_port_freeze(struct ata_port *ap) 1083 { 1084 int nr_aborted; 1085 1086 WARN_ON(!ap->ops->error_handler); 1087 1088 __ata_port_freeze(ap); 1089 nr_aborted = ata_port_abort(ap); 1090 1091 return nr_aborted; 1092 } 1093 EXPORT_SYMBOL_GPL(ata_port_freeze); 1094 1095 /** 1096 * ata_eh_freeze_port - EH helper to freeze port 1097 * @ap: ATA port to freeze 1098 * 1099 * Freeze @ap. 1100 * 1101 * LOCKING: 1102 * None. 1103 */ 1104 void ata_eh_freeze_port(struct ata_port *ap) 1105 { 1106 unsigned long flags; 1107 1108 if (!ap->ops->error_handler) 1109 return; 1110 1111 spin_lock_irqsave(ap->lock, flags); 1112 __ata_port_freeze(ap); 1113 spin_unlock_irqrestore(ap->lock, flags); 1114 } 1115 EXPORT_SYMBOL_GPL(ata_eh_freeze_port); 1116 1117 /** 1118 * ata_port_thaw_port - EH helper to thaw port 1119 * @ap: ATA port to thaw 1120 * 1121 * Thaw frozen port @ap. 1122 * 1123 * LOCKING: 1124 * None. 1125 */ 1126 void ata_eh_thaw_port(struct ata_port *ap) 1127 { 1128 unsigned long flags; 1129 1130 if (!ap->ops->error_handler) 1131 return; 1132 1133 spin_lock_irqsave(ap->lock, flags); 1134 1135 ap->pflags &= ~ATA_PFLAG_FROZEN; 1136 1137 if (ap->ops->thaw) 1138 ap->ops->thaw(ap); 1139 1140 spin_unlock_irqrestore(ap->lock, flags); 1141 1142 DPRINTK("ata%u port thawed\n", ap->print_id); 1143 } 1144 1145 static void ata_eh_scsidone(struct scsi_cmnd *scmd) 1146 { 1147 /* nada */ 1148 } 1149 1150 static void __ata_eh_qc_complete(struct ata_queued_cmd *qc) 1151 { 1152 struct ata_port *ap = qc->ap; 1153 struct scsi_cmnd *scmd = qc->scsicmd; 1154 unsigned long flags; 1155 1156 spin_lock_irqsave(ap->lock, flags); 1157 qc->scsidone = ata_eh_scsidone; 1158 __ata_qc_complete(qc); 1159 WARN_ON(ata_tag_valid(qc->tag)); 1160 spin_unlock_irqrestore(ap->lock, flags); 1161 1162 scsi_eh_finish_cmd(scmd, &ap->eh_done_q); 1163 } 1164 1165 /** 1166 * ata_eh_qc_complete - Complete an active ATA command from EH 1167 * @qc: Command to complete 1168 * 1169 * Indicate to the mid and upper layers that an ATA command has 1170 * completed. To be used from EH. 1171 */ 1172 void ata_eh_qc_complete(struct ata_queued_cmd *qc) 1173 { 1174 struct scsi_cmnd *scmd = qc->scsicmd; 1175 scmd->retries = scmd->allowed; 1176 __ata_eh_qc_complete(qc); 1177 } 1178 1179 /** 1180 * ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH 1181 * @qc: Command to retry 1182 * 1183 * Indicate to the mid and upper layers that an ATA command 1184 * should be retried. To be used from EH. 1185 * 1186 * SCSI midlayer limits the number of retries to scmd->allowed. 1187 * scmd->allowed is incremented for commands which get retried 1188 * due to unrelated failures (qc->err_mask is zero). 1189 */ 1190 void ata_eh_qc_retry(struct ata_queued_cmd *qc) 1191 { 1192 struct scsi_cmnd *scmd = qc->scsicmd; 1193 if (!qc->err_mask) 1194 scmd->allowed++; 1195 __ata_eh_qc_complete(qc); 1196 } 1197 1198 /** 1199 * ata_dev_disable - disable ATA device 1200 * @dev: ATA device to disable 1201 * 1202 * Disable @dev. 1203 * 1204 * Locking: 1205 * EH context. 1206 */ 1207 void ata_dev_disable(struct ata_device *dev) 1208 { 1209 if (!ata_dev_enabled(dev)) 1210 return; 1211 1212 if (ata_msg_drv(dev->link->ap)) 1213 ata_dev_warn(dev, "disabled\n"); 1214 ata_acpi_on_disable(dev); 1215 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET); 1216 dev->class++; 1217 1218 /* From now till the next successful probe, ering is used to 1219 * track probe failures. Clear accumulated device error info. 1220 */ 1221 ata_ering_clear(&dev->ering); 1222 } 1223 EXPORT_SYMBOL_GPL(ata_dev_disable); 1224 1225 /** 1226 * ata_eh_detach_dev - detach ATA device 1227 * @dev: ATA device to detach 1228 * 1229 * Detach @dev. 1230 * 1231 * LOCKING: 1232 * None. 1233 */ 1234 void ata_eh_detach_dev(struct ata_device *dev) 1235 { 1236 struct ata_link *link = dev->link; 1237 struct ata_port *ap = link->ap; 1238 struct ata_eh_context *ehc = &link->eh_context; 1239 unsigned long flags; 1240 1241 ata_dev_disable(dev); 1242 1243 spin_lock_irqsave(ap->lock, flags); 1244 1245 dev->flags &= ~ATA_DFLAG_DETACH; 1246 1247 if (ata_scsi_offline_dev(dev)) { 1248 dev->flags |= ATA_DFLAG_DETACHED; 1249 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG; 1250 } 1251 1252 /* clear per-dev EH info */ 1253 ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK); 1254 ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK); 1255 ehc->saved_xfer_mode[dev->devno] = 0; 1256 ehc->saved_ncq_enabled &= ~(1 << dev->devno); 1257 1258 spin_unlock_irqrestore(ap->lock, flags); 1259 } 1260 1261 /** 1262 * ata_eh_about_to_do - about to perform eh_action 1263 * @link: target ATA link 1264 * @dev: target ATA dev for per-dev action (can be NULL) 1265 * @action: action about to be performed 1266 * 1267 * Called just before performing EH actions to clear related bits 1268 * in @link->eh_info such that eh actions are not unnecessarily 1269 * repeated. 1270 * 1271 * LOCKING: 1272 * None. 1273 */ 1274 void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev, 1275 unsigned int action) 1276 { 1277 struct ata_port *ap = link->ap; 1278 struct ata_eh_info *ehi = &link->eh_info; 1279 struct ata_eh_context *ehc = &link->eh_context; 1280 unsigned long flags; 1281 1282 spin_lock_irqsave(ap->lock, flags); 1283 1284 ata_eh_clear_action(link, dev, ehi, action); 1285 1286 /* About to take EH action, set RECOVERED. Ignore actions on 1287 * slave links as master will do them again. 1288 */ 1289 if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link) 1290 ap->pflags |= ATA_PFLAG_RECOVERED; 1291 1292 spin_unlock_irqrestore(ap->lock, flags); 1293 } 1294 1295 /** 1296 * ata_eh_done - EH action complete 1297 * @link: ATA link for which EH actions are complete 1298 * @dev: target ATA dev for per-dev action (can be NULL) 1299 * @action: action just completed 1300 * 1301 * Called right after performing EH actions to clear related bits 1302 * in @link->eh_context. 1303 * 1304 * LOCKING: 1305 * None. 1306 */ 1307 void ata_eh_done(struct ata_link *link, struct ata_device *dev, 1308 unsigned int action) 1309 { 1310 struct ata_eh_context *ehc = &link->eh_context; 1311 1312 ata_eh_clear_action(link, dev, &ehc->i, action); 1313 } 1314 1315 /** 1316 * ata_err_string - convert err_mask to descriptive string 1317 * @err_mask: error mask to convert to string 1318 * 1319 * Convert @err_mask to descriptive string. Errors are 1320 * prioritized according to severity and only the most severe 1321 * error is reported. 1322 * 1323 * LOCKING: 1324 * None. 1325 * 1326 * RETURNS: 1327 * Descriptive string for @err_mask 1328 */ 1329 static const char *ata_err_string(unsigned int err_mask) 1330 { 1331 if (err_mask & AC_ERR_HOST_BUS) 1332 return "host bus error"; 1333 if (err_mask & AC_ERR_ATA_BUS) 1334 return "ATA bus error"; 1335 if (err_mask & AC_ERR_TIMEOUT) 1336 return "timeout"; 1337 if (err_mask & AC_ERR_HSM) 1338 return "HSM violation"; 1339 if (err_mask & AC_ERR_SYSTEM) 1340 return "internal error"; 1341 if (err_mask & AC_ERR_MEDIA) 1342 return "media error"; 1343 if (err_mask & AC_ERR_INVALID) 1344 return "invalid argument"; 1345 if (err_mask & AC_ERR_DEV) 1346 return "device error"; 1347 if (err_mask & AC_ERR_NCQ) 1348 return "NCQ error"; 1349 if (err_mask & AC_ERR_NODEV_HINT) 1350 return "Polling detection error"; 1351 return "unknown error"; 1352 } 1353 1354 /** 1355 * atapi_eh_tur - perform ATAPI TEST_UNIT_READY 1356 * @dev: target ATAPI device 1357 * @r_sense_key: out parameter for sense_key 1358 * 1359 * Perform ATAPI TEST_UNIT_READY. 1360 * 1361 * LOCKING: 1362 * EH context (may sleep). 1363 * 1364 * RETURNS: 1365 * 0 on success, AC_ERR_* mask on failure. 1366 */ 1367 unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key) 1368 { 1369 u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 }; 1370 struct ata_taskfile tf; 1371 unsigned int err_mask; 1372 1373 ata_tf_init(dev, &tf); 1374 1375 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 1376 tf.command = ATA_CMD_PACKET; 1377 tf.protocol = ATAPI_PROT_NODATA; 1378 1379 err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0); 1380 if (err_mask == AC_ERR_DEV) 1381 *r_sense_key = tf.feature >> 4; 1382 return err_mask; 1383 } 1384 1385 /** 1386 * ata_eh_request_sense - perform REQUEST_SENSE_DATA_EXT 1387 * @qc: qc to perform REQUEST_SENSE_SENSE_DATA_EXT to 1388 * @cmd: scsi command for which the sense code should be set 1389 * 1390 * Perform REQUEST_SENSE_DATA_EXT after the device reported CHECK 1391 * SENSE. This function is an EH helper. 1392 * 1393 * LOCKING: 1394 * Kernel thread context (may sleep). 1395 */ 1396 static void ata_eh_request_sense(struct ata_queued_cmd *qc, 1397 struct scsi_cmnd *cmd) 1398 { 1399 struct ata_device *dev = qc->dev; 1400 struct ata_taskfile tf; 1401 unsigned int err_mask; 1402 1403 if (qc->ap->pflags & ATA_PFLAG_FROZEN) { 1404 ata_dev_warn(dev, "sense data available but port frozen\n"); 1405 return; 1406 } 1407 1408 if (!cmd || qc->flags & ATA_QCFLAG_SENSE_VALID) 1409 return; 1410 1411 if (!ata_id_sense_reporting_enabled(dev->id)) { 1412 ata_dev_warn(qc->dev, "sense data reporting disabled\n"); 1413 return; 1414 } 1415 1416 DPRINTK("ATA request sense\n"); 1417 1418 ata_tf_init(dev, &tf); 1419 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 1420 tf.flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48; 1421 tf.command = ATA_CMD_REQ_SENSE_DATA; 1422 tf.protocol = ATA_PROT_NODATA; 1423 1424 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 1425 /* Ignore err_mask; ATA_ERR might be set */ 1426 if (tf.command & ATA_SENSE) { 1427 ata_scsi_set_sense(dev, cmd, tf.lbah, tf.lbam, tf.lbal); 1428 qc->flags |= ATA_QCFLAG_SENSE_VALID; 1429 } else { 1430 ata_dev_warn(dev, "request sense failed stat %02x emask %x\n", 1431 tf.command, err_mask); 1432 } 1433 } 1434 1435 /** 1436 * atapi_eh_request_sense - perform ATAPI REQUEST_SENSE 1437 * @dev: device to perform REQUEST_SENSE to 1438 * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long) 1439 * @dfl_sense_key: default sense key to use 1440 * 1441 * Perform ATAPI REQUEST_SENSE after the device reported CHECK 1442 * SENSE. This function is EH helper. 1443 * 1444 * LOCKING: 1445 * Kernel thread context (may sleep). 1446 * 1447 * RETURNS: 1448 * 0 on success, AC_ERR_* mask on failure 1449 */ 1450 unsigned int atapi_eh_request_sense(struct ata_device *dev, 1451 u8 *sense_buf, u8 dfl_sense_key) 1452 { 1453 u8 cdb[ATAPI_CDB_LEN] = 1454 { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 }; 1455 struct ata_port *ap = dev->link->ap; 1456 struct ata_taskfile tf; 1457 1458 DPRINTK("ATAPI request sense\n"); 1459 1460 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE); 1461 1462 /* initialize sense_buf with the error register, 1463 * for the case where they are -not- overwritten 1464 */ 1465 sense_buf[0] = 0x70; 1466 sense_buf[2] = dfl_sense_key; 1467 1468 /* some devices time out if garbage left in tf */ 1469 ata_tf_init(dev, &tf); 1470 1471 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 1472 tf.command = ATA_CMD_PACKET; 1473 1474 /* is it pointless to prefer PIO for "safety reasons"? */ 1475 if (ap->flags & ATA_FLAG_PIO_DMA) { 1476 tf.protocol = ATAPI_PROT_DMA; 1477 tf.feature |= ATAPI_PKT_DMA; 1478 } else { 1479 tf.protocol = ATAPI_PROT_PIO; 1480 tf.lbam = SCSI_SENSE_BUFFERSIZE; 1481 tf.lbah = 0; 1482 } 1483 1484 return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE, 1485 sense_buf, SCSI_SENSE_BUFFERSIZE, 0); 1486 } 1487 1488 /** 1489 * ata_eh_analyze_serror - analyze SError for a failed port 1490 * @link: ATA link to analyze SError for 1491 * 1492 * Analyze SError if available and further determine cause of 1493 * failure. 1494 * 1495 * LOCKING: 1496 * None. 1497 */ 1498 static void ata_eh_analyze_serror(struct ata_link *link) 1499 { 1500 struct ata_eh_context *ehc = &link->eh_context; 1501 u32 serror = ehc->i.serror; 1502 unsigned int err_mask = 0, action = 0; 1503 u32 hotplug_mask; 1504 1505 if (serror & (SERR_PERSISTENT | SERR_DATA)) { 1506 err_mask |= AC_ERR_ATA_BUS; 1507 action |= ATA_EH_RESET; 1508 } 1509 if (serror & SERR_PROTOCOL) { 1510 err_mask |= AC_ERR_HSM; 1511 action |= ATA_EH_RESET; 1512 } 1513 if (serror & SERR_INTERNAL) { 1514 err_mask |= AC_ERR_SYSTEM; 1515 action |= ATA_EH_RESET; 1516 } 1517 1518 /* Determine whether a hotplug event has occurred. Both 1519 * SError.N/X are considered hotplug events for enabled or 1520 * host links. For disabled PMP links, only N bit is 1521 * considered as X bit is left at 1 for link plugging. 1522 */ 1523 if (link->lpm_policy > ATA_LPM_MAX_POWER) 1524 hotplug_mask = 0; /* hotplug doesn't work w/ LPM */ 1525 else if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link)) 1526 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG; 1527 else 1528 hotplug_mask = SERR_PHYRDY_CHG; 1529 1530 if (serror & hotplug_mask) 1531 ata_ehi_hotplugged(&ehc->i); 1532 1533 ehc->i.err_mask |= err_mask; 1534 ehc->i.action |= action; 1535 } 1536 1537 /** 1538 * ata_eh_analyze_tf - analyze taskfile of a failed qc 1539 * @qc: qc to analyze 1540 * @tf: Taskfile registers to analyze 1541 * 1542 * Analyze taskfile of @qc and further determine cause of 1543 * failure. This function also requests ATAPI sense data if 1544 * available. 1545 * 1546 * LOCKING: 1547 * Kernel thread context (may sleep). 1548 * 1549 * RETURNS: 1550 * Determined recovery action 1551 */ 1552 static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc, 1553 const struct ata_taskfile *tf) 1554 { 1555 unsigned int tmp, action = 0; 1556 u8 stat = tf->command, err = tf->feature; 1557 1558 if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) { 1559 qc->err_mask |= AC_ERR_HSM; 1560 return ATA_EH_RESET; 1561 } 1562 1563 if (stat & (ATA_ERR | ATA_DF)) { 1564 qc->err_mask |= AC_ERR_DEV; 1565 /* 1566 * Sense data reporting does not work if the 1567 * device fault bit is set. 1568 */ 1569 if (stat & ATA_DF) 1570 stat &= ~ATA_SENSE; 1571 } else { 1572 return 0; 1573 } 1574 1575 switch (qc->dev->class) { 1576 case ATA_DEV_ZAC: 1577 if (stat & ATA_SENSE) 1578 ata_eh_request_sense(qc, qc->scsicmd); 1579 fallthrough; 1580 case ATA_DEV_ATA: 1581 if (err & ATA_ICRC) 1582 qc->err_mask |= AC_ERR_ATA_BUS; 1583 if (err & (ATA_UNC | ATA_AMNF)) 1584 qc->err_mask |= AC_ERR_MEDIA; 1585 if (err & ATA_IDNF) 1586 qc->err_mask |= AC_ERR_INVALID; 1587 break; 1588 1589 case ATA_DEV_ATAPI: 1590 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) { 1591 tmp = atapi_eh_request_sense(qc->dev, 1592 qc->scsicmd->sense_buffer, 1593 qc->result_tf.feature >> 4); 1594 if (!tmp) 1595 qc->flags |= ATA_QCFLAG_SENSE_VALID; 1596 else 1597 qc->err_mask |= tmp; 1598 } 1599 } 1600 1601 if (qc->flags & ATA_QCFLAG_SENSE_VALID) { 1602 int ret = scsi_check_sense(qc->scsicmd); 1603 /* 1604 * SUCCESS here means that the sense code could be 1605 * evaluated and should be passed to the upper layers 1606 * for correct evaluation. 1607 * FAILED means the sense code could not be interpreted 1608 * and the device would need to be reset. 1609 * NEEDS_RETRY and ADD_TO_MLQUEUE means that the 1610 * command would need to be retried. 1611 */ 1612 if (ret == NEEDS_RETRY || ret == ADD_TO_MLQUEUE) { 1613 qc->flags |= ATA_QCFLAG_RETRY; 1614 qc->err_mask |= AC_ERR_OTHER; 1615 } else if (ret != SUCCESS) { 1616 qc->err_mask |= AC_ERR_HSM; 1617 } 1618 } 1619 if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS)) 1620 action |= ATA_EH_RESET; 1621 1622 return action; 1623 } 1624 1625 static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask, 1626 int *xfer_ok) 1627 { 1628 int base = 0; 1629 1630 if (!(eflags & ATA_EFLAG_DUBIOUS_XFER)) 1631 *xfer_ok = 1; 1632 1633 if (!*xfer_ok) 1634 base = ATA_ECAT_DUBIOUS_NONE; 1635 1636 if (err_mask & AC_ERR_ATA_BUS) 1637 return base + ATA_ECAT_ATA_BUS; 1638 1639 if (err_mask & AC_ERR_TIMEOUT) 1640 return base + ATA_ECAT_TOUT_HSM; 1641 1642 if (eflags & ATA_EFLAG_IS_IO) { 1643 if (err_mask & AC_ERR_HSM) 1644 return base + ATA_ECAT_TOUT_HSM; 1645 if ((err_mask & 1646 (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV) 1647 return base + ATA_ECAT_UNK_DEV; 1648 } 1649 1650 return 0; 1651 } 1652 1653 struct speed_down_verdict_arg { 1654 u64 since; 1655 int xfer_ok; 1656 int nr_errors[ATA_ECAT_NR]; 1657 }; 1658 1659 static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg) 1660 { 1661 struct speed_down_verdict_arg *arg = void_arg; 1662 int cat; 1663 1664 if ((ent->eflags & ATA_EFLAG_OLD_ER) || (ent->timestamp < arg->since)) 1665 return -1; 1666 1667 cat = ata_eh_categorize_error(ent->eflags, ent->err_mask, 1668 &arg->xfer_ok); 1669 arg->nr_errors[cat]++; 1670 1671 return 0; 1672 } 1673 1674 /** 1675 * ata_eh_speed_down_verdict - Determine speed down verdict 1676 * @dev: Device of interest 1677 * 1678 * This function examines error ring of @dev and determines 1679 * whether NCQ needs to be turned off, transfer speed should be 1680 * stepped down, or falling back to PIO is necessary. 1681 * 1682 * ECAT_ATA_BUS : ATA_BUS error for any command 1683 * 1684 * ECAT_TOUT_HSM : TIMEOUT for any command or HSM violation for 1685 * IO commands 1686 * 1687 * ECAT_UNK_DEV : Unknown DEV error for IO commands 1688 * 1689 * ECAT_DUBIOUS_* : Identical to above three but occurred while 1690 * data transfer hasn't been verified. 1691 * 1692 * Verdicts are 1693 * 1694 * NCQ_OFF : Turn off NCQ. 1695 * 1696 * SPEED_DOWN : Speed down transfer speed but don't fall back 1697 * to PIO. 1698 * 1699 * FALLBACK_TO_PIO : Fall back to PIO. 1700 * 1701 * Even if multiple verdicts are returned, only one action is 1702 * taken per error. An action triggered by non-DUBIOUS errors 1703 * clears ering, while one triggered by DUBIOUS_* errors doesn't. 1704 * This is to expedite speed down decisions right after device is 1705 * initially configured. 1706 * 1707 * The following are speed down rules. #1 and #2 deal with 1708 * DUBIOUS errors. 1709 * 1710 * 1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors 1711 * occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO. 1712 * 1713 * 2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors 1714 * occurred during last 5 mins, NCQ_OFF. 1715 * 1716 * 3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors 1717 * occurred during last 5 mins, FALLBACK_TO_PIO 1718 * 1719 * 4. If more than 3 TOUT_HSM or UNK_DEV errors occurred 1720 * during last 10 mins, NCQ_OFF. 1721 * 1722 * 5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6 1723 * UNK_DEV errors occurred during last 10 mins, SPEED_DOWN. 1724 * 1725 * LOCKING: 1726 * Inherited from caller. 1727 * 1728 * RETURNS: 1729 * OR of ATA_EH_SPDN_* flags. 1730 */ 1731 static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev) 1732 { 1733 const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ; 1734 u64 j64 = get_jiffies_64(); 1735 struct speed_down_verdict_arg arg; 1736 unsigned int verdict = 0; 1737 1738 /* scan past 5 mins of error history */ 1739 memset(&arg, 0, sizeof(arg)); 1740 arg.since = j64 - min(j64, j5mins); 1741 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg); 1742 1743 if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] + 1744 arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1) 1745 verdict |= ATA_EH_SPDN_SPEED_DOWN | 1746 ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS; 1747 1748 if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] + 1749 arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1) 1750 verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS; 1751 1752 if (arg.nr_errors[ATA_ECAT_ATA_BUS] + 1753 arg.nr_errors[ATA_ECAT_TOUT_HSM] + 1754 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6) 1755 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO; 1756 1757 /* scan past 10 mins of error history */ 1758 memset(&arg, 0, sizeof(arg)); 1759 arg.since = j64 - min(j64, j10mins); 1760 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg); 1761 1762 if (arg.nr_errors[ATA_ECAT_TOUT_HSM] + 1763 arg.nr_errors[ATA_ECAT_UNK_DEV] > 3) 1764 verdict |= ATA_EH_SPDN_NCQ_OFF; 1765 1766 if (arg.nr_errors[ATA_ECAT_ATA_BUS] + 1767 arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 || 1768 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6) 1769 verdict |= ATA_EH_SPDN_SPEED_DOWN; 1770 1771 return verdict; 1772 } 1773 1774 /** 1775 * ata_eh_speed_down - record error and speed down if necessary 1776 * @dev: Failed device 1777 * @eflags: mask of ATA_EFLAG_* flags 1778 * @err_mask: err_mask of the error 1779 * 1780 * Record error and examine error history to determine whether 1781 * adjusting transmission speed is necessary. It also sets 1782 * transmission limits appropriately if such adjustment is 1783 * necessary. 1784 * 1785 * LOCKING: 1786 * Kernel thread context (may sleep). 1787 * 1788 * RETURNS: 1789 * Determined recovery action. 1790 */ 1791 static unsigned int ata_eh_speed_down(struct ata_device *dev, 1792 unsigned int eflags, unsigned int err_mask) 1793 { 1794 struct ata_link *link = ata_dev_phys_link(dev); 1795 int xfer_ok = 0; 1796 unsigned int verdict; 1797 unsigned int action = 0; 1798 1799 /* don't bother if Cat-0 error */ 1800 if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0) 1801 return 0; 1802 1803 /* record error and determine whether speed down is necessary */ 1804 ata_ering_record(&dev->ering, eflags, err_mask); 1805 verdict = ata_eh_speed_down_verdict(dev); 1806 1807 /* turn off NCQ? */ 1808 if ((verdict & ATA_EH_SPDN_NCQ_OFF) && 1809 (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ | 1810 ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) { 1811 dev->flags |= ATA_DFLAG_NCQ_OFF; 1812 ata_dev_warn(dev, "NCQ disabled due to excessive errors\n"); 1813 goto done; 1814 } 1815 1816 /* speed down? */ 1817 if (verdict & ATA_EH_SPDN_SPEED_DOWN) { 1818 /* speed down SATA link speed if possible */ 1819 if (sata_down_spd_limit(link, 0) == 0) { 1820 action |= ATA_EH_RESET; 1821 goto done; 1822 } 1823 1824 /* lower transfer mode */ 1825 if (dev->spdn_cnt < 2) { 1826 static const int dma_dnxfer_sel[] = 1827 { ATA_DNXFER_DMA, ATA_DNXFER_40C }; 1828 static const int pio_dnxfer_sel[] = 1829 { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 }; 1830 int sel; 1831 1832 if (dev->xfer_shift != ATA_SHIFT_PIO) 1833 sel = dma_dnxfer_sel[dev->spdn_cnt]; 1834 else 1835 sel = pio_dnxfer_sel[dev->spdn_cnt]; 1836 1837 dev->spdn_cnt++; 1838 1839 if (ata_down_xfermask_limit(dev, sel) == 0) { 1840 action |= ATA_EH_RESET; 1841 goto done; 1842 } 1843 } 1844 } 1845 1846 /* Fall back to PIO? Slowing down to PIO is meaningless for 1847 * SATA ATA devices. Consider it only for PATA and SATAPI. 1848 */ 1849 if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) && 1850 (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) && 1851 (dev->xfer_shift != ATA_SHIFT_PIO)) { 1852 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) { 1853 dev->spdn_cnt = 0; 1854 action |= ATA_EH_RESET; 1855 goto done; 1856 } 1857 } 1858 1859 return 0; 1860 done: 1861 /* device has been slowed down, blow error history */ 1862 if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS)) 1863 ata_ering_clear(&dev->ering); 1864 return action; 1865 } 1866 1867 /** 1868 * ata_eh_worth_retry - analyze error and decide whether to retry 1869 * @qc: qc to possibly retry 1870 * 1871 * Look at the cause of the error and decide if a retry 1872 * might be useful or not. We don't want to retry media errors 1873 * because the drive itself has probably already taken 10-30 seconds 1874 * doing its own internal retries before reporting the failure. 1875 */ 1876 static inline int ata_eh_worth_retry(struct ata_queued_cmd *qc) 1877 { 1878 if (qc->err_mask & AC_ERR_MEDIA) 1879 return 0; /* don't retry media errors */ 1880 if (qc->flags & ATA_QCFLAG_IO) 1881 return 1; /* otherwise retry anything from fs stack */ 1882 if (qc->err_mask & AC_ERR_INVALID) 1883 return 0; /* don't retry these */ 1884 return qc->err_mask != AC_ERR_DEV; /* retry if not dev error */ 1885 } 1886 1887 /** 1888 * ata_eh_quiet - check if we need to be quiet about a command error 1889 * @qc: qc to check 1890 * 1891 * Look at the qc flags anbd its scsi command request flags to determine 1892 * if we need to be quiet about the command failure. 1893 */ 1894 static inline bool ata_eh_quiet(struct ata_queued_cmd *qc) 1895 { 1896 if (qc->scsicmd && 1897 qc->scsicmd->request->rq_flags & RQF_QUIET) 1898 qc->flags |= ATA_QCFLAG_QUIET; 1899 return qc->flags & ATA_QCFLAG_QUIET; 1900 } 1901 1902 /** 1903 * ata_eh_link_autopsy - analyze error and determine recovery action 1904 * @link: host link to perform autopsy on 1905 * 1906 * Analyze why @link failed and determine which recovery actions 1907 * are needed. This function also sets more detailed AC_ERR_* 1908 * values and fills sense data for ATAPI CHECK SENSE. 1909 * 1910 * LOCKING: 1911 * Kernel thread context (may sleep). 1912 */ 1913 static void ata_eh_link_autopsy(struct ata_link *link) 1914 { 1915 struct ata_port *ap = link->ap; 1916 struct ata_eh_context *ehc = &link->eh_context; 1917 struct ata_queued_cmd *qc; 1918 struct ata_device *dev; 1919 unsigned int all_err_mask = 0, eflags = 0; 1920 int tag, nr_failed = 0, nr_quiet = 0; 1921 u32 serror; 1922 int rc; 1923 1924 DPRINTK("ENTER\n"); 1925 1926 if (ehc->i.flags & ATA_EHI_NO_AUTOPSY) 1927 return; 1928 1929 /* obtain and analyze SError */ 1930 rc = sata_scr_read(link, SCR_ERROR, &serror); 1931 if (rc == 0) { 1932 ehc->i.serror |= serror; 1933 ata_eh_analyze_serror(link); 1934 } else if (rc != -EOPNOTSUPP) { 1935 /* SError read failed, force reset and probing */ 1936 ehc->i.probe_mask |= ATA_ALL_DEVICES; 1937 ehc->i.action |= ATA_EH_RESET; 1938 ehc->i.err_mask |= AC_ERR_OTHER; 1939 } 1940 1941 /* analyze NCQ failure */ 1942 ata_eh_analyze_ncq_error(link); 1943 1944 /* any real error trumps AC_ERR_OTHER */ 1945 if (ehc->i.err_mask & ~AC_ERR_OTHER) 1946 ehc->i.err_mask &= ~AC_ERR_OTHER; 1947 1948 all_err_mask |= ehc->i.err_mask; 1949 1950 ata_qc_for_each_raw(ap, qc, tag) { 1951 if (!(qc->flags & ATA_QCFLAG_FAILED) || 1952 ata_dev_phys_link(qc->dev) != link) 1953 continue; 1954 1955 /* inherit upper level err_mask */ 1956 qc->err_mask |= ehc->i.err_mask; 1957 1958 /* analyze TF */ 1959 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf); 1960 1961 /* DEV errors are probably spurious in case of ATA_BUS error */ 1962 if (qc->err_mask & AC_ERR_ATA_BUS) 1963 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA | 1964 AC_ERR_INVALID); 1965 1966 /* any real error trumps unknown error */ 1967 if (qc->err_mask & ~AC_ERR_OTHER) 1968 qc->err_mask &= ~AC_ERR_OTHER; 1969 1970 /* 1971 * SENSE_VALID trumps dev/unknown error and revalidation. Upper 1972 * layers will determine whether the command is worth retrying 1973 * based on the sense data and device class/type. Otherwise, 1974 * determine directly if the command is worth retrying using its 1975 * error mask and flags. 1976 */ 1977 if (qc->flags & ATA_QCFLAG_SENSE_VALID) 1978 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER); 1979 else if (ata_eh_worth_retry(qc)) 1980 qc->flags |= ATA_QCFLAG_RETRY; 1981 1982 /* accumulate error info */ 1983 ehc->i.dev = qc->dev; 1984 all_err_mask |= qc->err_mask; 1985 if (qc->flags & ATA_QCFLAG_IO) 1986 eflags |= ATA_EFLAG_IS_IO; 1987 trace_ata_eh_link_autopsy_qc(qc); 1988 1989 /* Count quiet errors */ 1990 if (ata_eh_quiet(qc)) 1991 nr_quiet++; 1992 nr_failed++; 1993 } 1994 1995 /* If all failed commands requested silence, then be quiet */ 1996 if (nr_quiet == nr_failed) 1997 ehc->i.flags |= ATA_EHI_QUIET; 1998 1999 /* enforce default EH actions */ 2000 if (ap->pflags & ATA_PFLAG_FROZEN || 2001 all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT)) 2002 ehc->i.action |= ATA_EH_RESET; 2003 else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) || 2004 (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV))) 2005 ehc->i.action |= ATA_EH_REVALIDATE; 2006 2007 /* If we have offending qcs and the associated failed device, 2008 * perform per-dev EH action only on the offending device. 2009 */ 2010 if (ehc->i.dev) { 2011 ehc->i.dev_action[ehc->i.dev->devno] |= 2012 ehc->i.action & ATA_EH_PERDEV_MASK; 2013 ehc->i.action &= ~ATA_EH_PERDEV_MASK; 2014 } 2015 2016 /* propagate timeout to host link */ 2017 if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link)) 2018 ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT; 2019 2020 /* record error and consider speeding down */ 2021 dev = ehc->i.dev; 2022 if (!dev && ((ata_link_max_devices(link) == 1 && 2023 ata_dev_enabled(link->device)))) 2024 dev = link->device; 2025 2026 if (dev) { 2027 if (dev->flags & ATA_DFLAG_DUBIOUS_XFER) 2028 eflags |= ATA_EFLAG_DUBIOUS_XFER; 2029 ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask); 2030 trace_ata_eh_link_autopsy(dev, ehc->i.action, all_err_mask); 2031 } 2032 DPRINTK("EXIT\n"); 2033 } 2034 2035 /** 2036 * ata_eh_autopsy - analyze error and determine recovery action 2037 * @ap: host port to perform autopsy on 2038 * 2039 * Analyze all links of @ap and determine why they failed and 2040 * which recovery actions are needed. 2041 * 2042 * LOCKING: 2043 * Kernel thread context (may sleep). 2044 */ 2045 void ata_eh_autopsy(struct ata_port *ap) 2046 { 2047 struct ata_link *link; 2048 2049 ata_for_each_link(link, ap, EDGE) 2050 ata_eh_link_autopsy(link); 2051 2052 /* Handle the frigging slave link. Autopsy is done similarly 2053 * but actions and flags are transferred over to the master 2054 * link and handled from there. 2055 */ 2056 if (ap->slave_link) { 2057 struct ata_eh_context *mehc = &ap->link.eh_context; 2058 struct ata_eh_context *sehc = &ap->slave_link->eh_context; 2059 2060 /* transfer control flags from master to slave */ 2061 sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK; 2062 2063 /* perform autopsy on the slave link */ 2064 ata_eh_link_autopsy(ap->slave_link); 2065 2066 /* transfer actions from slave to master and clear slave */ 2067 ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS); 2068 mehc->i.action |= sehc->i.action; 2069 mehc->i.dev_action[1] |= sehc->i.dev_action[1]; 2070 mehc->i.flags |= sehc->i.flags; 2071 ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS); 2072 } 2073 2074 /* Autopsy of fanout ports can affect host link autopsy. 2075 * Perform host link autopsy last. 2076 */ 2077 if (sata_pmp_attached(ap)) 2078 ata_eh_link_autopsy(&ap->link); 2079 } 2080 2081 /** 2082 * ata_get_cmd_descript - get description for ATA command 2083 * @command: ATA command code to get description for 2084 * 2085 * Return a textual description of the given command, or NULL if the 2086 * command is not known. 2087 * 2088 * LOCKING: 2089 * None 2090 */ 2091 const char *ata_get_cmd_descript(u8 command) 2092 { 2093 #ifdef CONFIG_ATA_VERBOSE_ERROR 2094 static const struct 2095 { 2096 u8 command; 2097 const char *text; 2098 } cmd_descr[] = { 2099 { ATA_CMD_DEV_RESET, "DEVICE RESET" }, 2100 { ATA_CMD_CHK_POWER, "CHECK POWER MODE" }, 2101 { ATA_CMD_STANDBY, "STANDBY" }, 2102 { ATA_CMD_IDLE, "IDLE" }, 2103 { ATA_CMD_EDD, "EXECUTE DEVICE DIAGNOSTIC" }, 2104 { ATA_CMD_DOWNLOAD_MICRO, "DOWNLOAD MICROCODE" }, 2105 { ATA_CMD_DOWNLOAD_MICRO_DMA, "DOWNLOAD MICROCODE DMA" }, 2106 { ATA_CMD_NOP, "NOP" }, 2107 { ATA_CMD_FLUSH, "FLUSH CACHE" }, 2108 { ATA_CMD_FLUSH_EXT, "FLUSH CACHE EXT" }, 2109 { ATA_CMD_ID_ATA, "IDENTIFY DEVICE" }, 2110 { ATA_CMD_ID_ATAPI, "IDENTIFY PACKET DEVICE" }, 2111 { ATA_CMD_SERVICE, "SERVICE" }, 2112 { ATA_CMD_READ, "READ DMA" }, 2113 { ATA_CMD_READ_EXT, "READ DMA EXT" }, 2114 { ATA_CMD_READ_QUEUED, "READ DMA QUEUED" }, 2115 { ATA_CMD_READ_STREAM_EXT, "READ STREAM EXT" }, 2116 { ATA_CMD_READ_STREAM_DMA_EXT, "READ STREAM DMA EXT" }, 2117 { ATA_CMD_WRITE, "WRITE DMA" }, 2118 { ATA_CMD_WRITE_EXT, "WRITE DMA EXT" }, 2119 { ATA_CMD_WRITE_QUEUED, "WRITE DMA QUEUED EXT" }, 2120 { ATA_CMD_WRITE_STREAM_EXT, "WRITE STREAM EXT" }, 2121 { ATA_CMD_WRITE_STREAM_DMA_EXT, "WRITE STREAM DMA EXT" }, 2122 { ATA_CMD_WRITE_FUA_EXT, "WRITE DMA FUA EXT" }, 2123 { ATA_CMD_WRITE_QUEUED_FUA_EXT, "WRITE DMA QUEUED FUA EXT" }, 2124 { ATA_CMD_FPDMA_READ, "READ FPDMA QUEUED" }, 2125 { ATA_CMD_FPDMA_WRITE, "WRITE FPDMA QUEUED" }, 2126 { ATA_CMD_FPDMA_SEND, "SEND FPDMA QUEUED" }, 2127 { ATA_CMD_FPDMA_RECV, "RECEIVE FPDMA QUEUED" }, 2128 { ATA_CMD_PIO_READ, "READ SECTOR(S)" }, 2129 { ATA_CMD_PIO_READ_EXT, "READ SECTOR(S) EXT" }, 2130 { ATA_CMD_PIO_WRITE, "WRITE SECTOR(S)" }, 2131 { ATA_CMD_PIO_WRITE_EXT, "WRITE SECTOR(S) EXT" }, 2132 { ATA_CMD_READ_MULTI, "READ MULTIPLE" }, 2133 { ATA_CMD_READ_MULTI_EXT, "READ MULTIPLE EXT" }, 2134 { ATA_CMD_WRITE_MULTI, "WRITE MULTIPLE" }, 2135 { ATA_CMD_WRITE_MULTI_EXT, "WRITE MULTIPLE EXT" }, 2136 { ATA_CMD_WRITE_MULTI_FUA_EXT, "WRITE MULTIPLE FUA EXT" }, 2137 { ATA_CMD_SET_FEATURES, "SET FEATURES" }, 2138 { ATA_CMD_SET_MULTI, "SET MULTIPLE MODE" }, 2139 { ATA_CMD_VERIFY, "READ VERIFY SECTOR(S)" }, 2140 { ATA_CMD_VERIFY_EXT, "READ VERIFY SECTOR(S) EXT" }, 2141 { ATA_CMD_WRITE_UNCORR_EXT, "WRITE UNCORRECTABLE EXT" }, 2142 { ATA_CMD_STANDBYNOW1, "STANDBY IMMEDIATE" }, 2143 { ATA_CMD_IDLEIMMEDIATE, "IDLE IMMEDIATE" }, 2144 { ATA_CMD_SLEEP, "SLEEP" }, 2145 { ATA_CMD_INIT_DEV_PARAMS, "INITIALIZE DEVICE PARAMETERS" }, 2146 { ATA_CMD_READ_NATIVE_MAX, "READ NATIVE MAX ADDRESS" }, 2147 { ATA_CMD_READ_NATIVE_MAX_EXT, "READ NATIVE MAX ADDRESS EXT" }, 2148 { ATA_CMD_SET_MAX, "SET MAX ADDRESS" }, 2149 { ATA_CMD_SET_MAX_EXT, "SET MAX ADDRESS EXT" }, 2150 { ATA_CMD_READ_LOG_EXT, "READ LOG EXT" }, 2151 { ATA_CMD_WRITE_LOG_EXT, "WRITE LOG EXT" }, 2152 { ATA_CMD_READ_LOG_DMA_EXT, "READ LOG DMA EXT" }, 2153 { ATA_CMD_WRITE_LOG_DMA_EXT, "WRITE LOG DMA EXT" }, 2154 { ATA_CMD_TRUSTED_NONDATA, "TRUSTED NON-DATA" }, 2155 { ATA_CMD_TRUSTED_RCV, "TRUSTED RECEIVE" }, 2156 { ATA_CMD_TRUSTED_RCV_DMA, "TRUSTED RECEIVE DMA" }, 2157 { ATA_CMD_TRUSTED_SND, "TRUSTED SEND" }, 2158 { ATA_CMD_TRUSTED_SND_DMA, "TRUSTED SEND DMA" }, 2159 { ATA_CMD_PMP_READ, "READ BUFFER" }, 2160 { ATA_CMD_PMP_READ_DMA, "READ BUFFER DMA" }, 2161 { ATA_CMD_PMP_WRITE, "WRITE BUFFER" }, 2162 { ATA_CMD_PMP_WRITE_DMA, "WRITE BUFFER DMA" }, 2163 { ATA_CMD_CONF_OVERLAY, "DEVICE CONFIGURATION OVERLAY" }, 2164 { ATA_CMD_SEC_SET_PASS, "SECURITY SET PASSWORD" }, 2165 { ATA_CMD_SEC_UNLOCK, "SECURITY UNLOCK" }, 2166 { ATA_CMD_SEC_ERASE_PREP, "SECURITY ERASE PREPARE" }, 2167 { ATA_CMD_SEC_ERASE_UNIT, "SECURITY ERASE UNIT" }, 2168 { ATA_CMD_SEC_FREEZE_LOCK, "SECURITY FREEZE LOCK" }, 2169 { ATA_CMD_SEC_DISABLE_PASS, "SECURITY DISABLE PASSWORD" }, 2170 { ATA_CMD_CONFIG_STREAM, "CONFIGURE STREAM" }, 2171 { ATA_CMD_SMART, "SMART" }, 2172 { ATA_CMD_MEDIA_LOCK, "DOOR LOCK" }, 2173 { ATA_CMD_MEDIA_UNLOCK, "DOOR UNLOCK" }, 2174 { ATA_CMD_DSM, "DATA SET MANAGEMENT" }, 2175 { ATA_CMD_CHK_MED_CRD_TYP, "CHECK MEDIA CARD TYPE" }, 2176 { ATA_CMD_CFA_REQ_EXT_ERR, "CFA REQUEST EXTENDED ERROR" }, 2177 { ATA_CMD_CFA_WRITE_NE, "CFA WRITE SECTORS WITHOUT ERASE" }, 2178 { ATA_CMD_CFA_TRANS_SECT, "CFA TRANSLATE SECTOR" }, 2179 { ATA_CMD_CFA_ERASE, "CFA ERASE SECTORS" }, 2180 { ATA_CMD_CFA_WRITE_MULT_NE, "CFA WRITE MULTIPLE WITHOUT ERASE" }, 2181 { ATA_CMD_REQ_SENSE_DATA, "REQUEST SENSE DATA EXT" }, 2182 { ATA_CMD_SANITIZE_DEVICE, "SANITIZE DEVICE" }, 2183 { ATA_CMD_ZAC_MGMT_IN, "ZAC MANAGEMENT IN" }, 2184 { ATA_CMD_ZAC_MGMT_OUT, "ZAC MANAGEMENT OUT" }, 2185 { ATA_CMD_READ_LONG, "READ LONG (with retries)" }, 2186 { ATA_CMD_READ_LONG_ONCE, "READ LONG (without retries)" }, 2187 { ATA_CMD_WRITE_LONG, "WRITE LONG (with retries)" }, 2188 { ATA_CMD_WRITE_LONG_ONCE, "WRITE LONG (without retries)" }, 2189 { ATA_CMD_RESTORE, "RECALIBRATE" }, 2190 { 0, NULL } /* terminate list */ 2191 }; 2192 2193 unsigned int i; 2194 for (i = 0; cmd_descr[i].text; i++) 2195 if (cmd_descr[i].command == command) 2196 return cmd_descr[i].text; 2197 #endif 2198 2199 return NULL; 2200 } 2201 EXPORT_SYMBOL_GPL(ata_get_cmd_descript); 2202 2203 /** 2204 * ata_eh_link_report - report error handling to user 2205 * @link: ATA link EH is going on 2206 * 2207 * Report EH to user. 2208 * 2209 * LOCKING: 2210 * None. 2211 */ 2212 static void ata_eh_link_report(struct ata_link *link) 2213 { 2214 struct ata_port *ap = link->ap; 2215 struct ata_eh_context *ehc = &link->eh_context; 2216 struct ata_queued_cmd *qc; 2217 const char *frozen, *desc; 2218 char tries_buf[6] = ""; 2219 int tag, nr_failed = 0; 2220 2221 if (ehc->i.flags & ATA_EHI_QUIET) 2222 return; 2223 2224 desc = NULL; 2225 if (ehc->i.desc[0] != '\0') 2226 desc = ehc->i.desc; 2227 2228 ata_qc_for_each_raw(ap, qc, tag) { 2229 if (!(qc->flags & ATA_QCFLAG_FAILED) || 2230 ata_dev_phys_link(qc->dev) != link || 2231 ((qc->flags & ATA_QCFLAG_QUIET) && 2232 qc->err_mask == AC_ERR_DEV)) 2233 continue; 2234 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask) 2235 continue; 2236 2237 nr_failed++; 2238 } 2239 2240 if (!nr_failed && !ehc->i.err_mask) 2241 return; 2242 2243 frozen = ""; 2244 if (ap->pflags & ATA_PFLAG_FROZEN) 2245 frozen = " frozen"; 2246 2247 if (ap->eh_tries < ATA_EH_MAX_TRIES) 2248 snprintf(tries_buf, sizeof(tries_buf), " t%d", 2249 ap->eh_tries); 2250 2251 if (ehc->i.dev) { 2252 ata_dev_err(ehc->i.dev, "exception Emask 0x%x " 2253 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n", 2254 ehc->i.err_mask, link->sactive, ehc->i.serror, 2255 ehc->i.action, frozen, tries_buf); 2256 if (desc) 2257 ata_dev_err(ehc->i.dev, "%s\n", desc); 2258 } else { 2259 ata_link_err(link, "exception Emask 0x%x " 2260 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n", 2261 ehc->i.err_mask, link->sactive, ehc->i.serror, 2262 ehc->i.action, frozen, tries_buf); 2263 if (desc) 2264 ata_link_err(link, "%s\n", desc); 2265 } 2266 2267 #ifdef CONFIG_ATA_VERBOSE_ERROR 2268 if (ehc->i.serror) 2269 ata_link_err(link, 2270 "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n", 2271 ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "", 2272 ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "", 2273 ehc->i.serror & SERR_DATA ? "UnrecovData " : "", 2274 ehc->i.serror & SERR_PERSISTENT ? "Persist " : "", 2275 ehc->i.serror & SERR_PROTOCOL ? "Proto " : "", 2276 ehc->i.serror & SERR_INTERNAL ? "HostInt " : "", 2277 ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "", 2278 ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "", 2279 ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "", 2280 ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "", 2281 ehc->i.serror & SERR_DISPARITY ? "Dispar " : "", 2282 ehc->i.serror & SERR_CRC ? "BadCRC " : "", 2283 ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "", 2284 ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "", 2285 ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "", 2286 ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "", 2287 ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : ""); 2288 #endif 2289 2290 ata_qc_for_each_raw(ap, qc, tag) { 2291 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf; 2292 char data_buf[20] = ""; 2293 char cdb_buf[70] = ""; 2294 2295 if (!(qc->flags & ATA_QCFLAG_FAILED) || 2296 ata_dev_phys_link(qc->dev) != link || !qc->err_mask) 2297 continue; 2298 2299 if (qc->dma_dir != DMA_NONE) { 2300 static const char *dma_str[] = { 2301 [DMA_BIDIRECTIONAL] = "bidi", 2302 [DMA_TO_DEVICE] = "out", 2303 [DMA_FROM_DEVICE] = "in", 2304 }; 2305 const char *prot_str = NULL; 2306 2307 switch (qc->tf.protocol) { 2308 case ATA_PROT_UNKNOWN: 2309 prot_str = "unknown"; 2310 break; 2311 case ATA_PROT_NODATA: 2312 prot_str = "nodata"; 2313 break; 2314 case ATA_PROT_PIO: 2315 prot_str = "pio"; 2316 break; 2317 case ATA_PROT_DMA: 2318 prot_str = "dma"; 2319 break; 2320 case ATA_PROT_NCQ: 2321 prot_str = "ncq dma"; 2322 break; 2323 case ATA_PROT_NCQ_NODATA: 2324 prot_str = "ncq nodata"; 2325 break; 2326 case ATAPI_PROT_NODATA: 2327 prot_str = "nodata"; 2328 break; 2329 case ATAPI_PROT_PIO: 2330 prot_str = "pio"; 2331 break; 2332 case ATAPI_PROT_DMA: 2333 prot_str = "dma"; 2334 break; 2335 } 2336 snprintf(data_buf, sizeof(data_buf), " %s %u %s", 2337 prot_str, qc->nbytes, dma_str[qc->dma_dir]); 2338 } 2339 2340 if (ata_is_atapi(qc->tf.protocol)) { 2341 const u8 *cdb = qc->cdb; 2342 size_t cdb_len = qc->dev->cdb_len; 2343 2344 if (qc->scsicmd) { 2345 cdb = qc->scsicmd->cmnd; 2346 cdb_len = qc->scsicmd->cmd_len; 2347 } 2348 __scsi_format_command(cdb_buf, sizeof(cdb_buf), 2349 cdb, cdb_len); 2350 } else { 2351 const char *descr = ata_get_cmd_descript(cmd->command); 2352 if (descr) 2353 ata_dev_err(qc->dev, "failed command: %s\n", 2354 descr); 2355 } 2356 2357 ata_dev_err(qc->dev, 2358 "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x " 2359 "tag %d%s\n %s" 2360 "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x " 2361 "Emask 0x%x (%s)%s\n", 2362 cmd->command, cmd->feature, cmd->nsect, 2363 cmd->lbal, cmd->lbam, cmd->lbah, 2364 cmd->hob_feature, cmd->hob_nsect, 2365 cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah, 2366 cmd->device, qc->tag, data_buf, cdb_buf, 2367 res->command, res->feature, res->nsect, 2368 res->lbal, res->lbam, res->lbah, 2369 res->hob_feature, res->hob_nsect, 2370 res->hob_lbal, res->hob_lbam, res->hob_lbah, 2371 res->device, qc->err_mask, ata_err_string(qc->err_mask), 2372 qc->err_mask & AC_ERR_NCQ ? " <F>" : ""); 2373 2374 #ifdef CONFIG_ATA_VERBOSE_ERROR 2375 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ | 2376 ATA_SENSE | ATA_ERR)) { 2377 if (res->command & ATA_BUSY) 2378 ata_dev_err(qc->dev, "status: { Busy }\n"); 2379 else 2380 ata_dev_err(qc->dev, "status: { %s%s%s%s%s}\n", 2381 res->command & ATA_DRDY ? "DRDY " : "", 2382 res->command & ATA_DF ? "DF " : "", 2383 res->command & ATA_DRQ ? "DRQ " : "", 2384 res->command & ATA_SENSE ? "SENSE " : "", 2385 res->command & ATA_ERR ? "ERR " : ""); 2386 } 2387 2388 if (cmd->command != ATA_CMD_PACKET && 2389 (res->feature & (ATA_ICRC | ATA_UNC | ATA_AMNF | 2390 ATA_IDNF | ATA_ABORTED))) 2391 ata_dev_err(qc->dev, "error: { %s%s%s%s%s}\n", 2392 res->feature & ATA_ICRC ? "ICRC " : "", 2393 res->feature & ATA_UNC ? "UNC " : "", 2394 res->feature & ATA_AMNF ? "AMNF " : "", 2395 res->feature & ATA_IDNF ? "IDNF " : "", 2396 res->feature & ATA_ABORTED ? "ABRT " : ""); 2397 #endif 2398 } 2399 } 2400 2401 /** 2402 * ata_eh_report - report error handling to user 2403 * @ap: ATA port to report EH about 2404 * 2405 * Report EH to user. 2406 * 2407 * LOCKING: 2408 * None. 2409 */ 2410 void ata_eh_report(struct ata_port *ap) 2411 { 2412 struct ata_link *link; 2413 2414 ata_for_each_link(link, ap, HOST_FIRST) 2415 ata_eh_link_report(link); 2416 } 2417 2418 static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset, 2419 unsigned int *classes, unsigned long deadline, 2420 bool clear_classes) 2421 { 2422 struct ata_device *dev; 2423 2424 if (clear_classes) 2425 ata_for_each_dev(dev, link, ALL) 2426 classes[dev->devno] = ATA_DEV_UNKNOWN; 2427 2428 return reset(link, classes, deadline); 2429 } 2430 2431 static int ata_eh_followup_srst_needed(struct ata_link *link, int rc) 2432 { 2433 if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link)) 2434 return 0; 2435 if (rc == -EAGAIN) 2436 return 1; 2437 if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) 2438 return 1; 2439 return 0; 2440 } 2441 2442 int ata_eh_reset(struct ata_link *link, int classify, 2443 ata_prereset_fn_t prereset, ata_reset_fn_t softreset, 2444 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset) 2445 { 2446 struct ata_port *ap = link->ap; 2447 struct ata_link *slave = ap->slave_link; 2448 struct ata_eh_context *ehc = &link->eh_context; 2449 struct ata_eh_context *sehc = slave ? &slave->eh_context : NULL; 2450 unsigned int *classes = ehc->classes; 2451 unsigned int lflags = link->flags; 2452 int verbose = !(ehc->i.flags & ATA_EHI_QUIET); 2453 int max_tries = 0, try = 0; 2454 struct ata_link *failed_link; 2455 struct ata_device *dev; 2456 unsigned long deadline, now; 2457 ata_reset_fn_t reset; 2458 unsigned long flags; 2459 u32 sstatus; 2460 int nr_unknown, rc; 2461 2462 /* 2463 * Prepare to reset 2464 */ 2465 while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX) 2466 max_tries++; 2467 if (link->flags & ATA_LFLAG_RST_ONCE) 2468 max_tries = 1; 2469 if (link->flags & ATA_LFLAG_NO_HRST) 2470 hardreset = NULL; 2471 if (link->flags & ATA_LFLAG_NO_SRST) 2472 softreset = NULL; 2473 2474 /* make sure each reset attempt is at least COOL_DOWN apart */ 2475 if (ehc->i.flags & ATA_EHI_DID_RESET) { 2476 now = jiffies; 2477 WARN_ON(time_after(ehc->last_reset, now)); 2478 deadline = ata_deadline(ehc->last_reset, 2479 ATA_EH_RESET_COOL_DOWN); 2480 if (time_before(now, deadline)) 2481 schedule_timeout_uninterruptible(deadline - now); 2482 } 2483 2484 spin_lock_irqsave(ap->lock, flags); 2485 ap->pflags |= ATA_PFLAG_RESETTING; 2486 spin_unlock_irqrestore(ap->lock, flags); 2487 2488 ata_eh_about_to_do(link, NULL, ATA_EH_RESET); 2489 2490 ata_for_each_dev(dev, link, ALL) { 2491 /* If we issue an SRST then an ATA drive (not ATAPI) 2492 * may change configuration and be in PIO0 timing. If 2493 * we do a hard reset (or are coming from power on) 2494 * this is true for ATA or ATAPI. Until we've set a 2495 * suitable controller mode we should not touch the 2496 * bus as we may be talking too fast. 2497 */ 2498 dev->pio_mode = XFER_PIO_0; 2499 dev->dma_mode = 0xff; 2500 2501 /* If the controller has a pio mode setup function 2502 * then use it to set the chipset to rights. Don't 2503 * touch the DMA setup as that will be dealt with when 2504 * configuring devices. 2505 */ 2506 if (ap->ops->set_piomode) 2507 ap->ops->set_piomode(ap, dev); 2508 } 2509 2510 /* prefer hardreset */ 2511 reset = NULL; 2512 ehc->i.action &= ~ATA_EH_RESET; 2513 if (hardreset) { 2514 reset = hardreset; 2515 ehc->i.action |= ATA_EH_HARDRESET; 2516 } else if (softreset) { 2517 reset = softreset; 2518 ehc->i.action |= ATA_EH_SOFTRESET; 2519 } 2520 2521 if (prereset) { 2522 unsigned long deadline = ata_deadline(jiffies, 2523 ATA_EH_PRERESET_TIMEOUT); 2524 2525 if (slave) { 2526 sehc->i.action &= ~ATA_EH_RESET; 2527 sehc->i.action |= ehc->i.action; 2528 } 2529 2530 rc = prereset(link, deadline); 2531 2532 /* If present, do prereset on slave link too. Reset 2533 * is skipped iff both master and slave links report 2534 * -ENOENT or clear ATA_EH_RESET. 2535 */ 2536 if (slave && (rc == 0 || rc == -ENOENT)) { 2537 int tmp; 2538 2539 tmp = prereset(slave, deadline); 2540 if (tmp != -ENOENT) 2541 rc = tmp; 2542 2543 ehc->i.action |= sehc->i.action; 2544 } 2545 2546 if (rc) { 2547 if (rc == -ENOENT) { 2548 ata_link_dbg(link, "port disabled--ignoring\n"); 2549 ehc->i.action &= ~ATA_EH_RESET; 2550 2551 ata_for_each_dev(dev, link, ALL) 2552 classes[dev->devno] = ATA_DEV_NONE; 2553 2554 rc = 0; 2555 } else 2556 ata_link_err(link, 2557 "prereset failed (errno=%d)\n", 2558 rc); 2559 goto out; 2560 } 2561 2562 /* prereset() might have cleared ATA_EH_RESET. If so, 2563 * bang classes, thaw and return. 2564 */ 2565 if (reset && !(ehc->i.action & ATA_EH_RESET)) { 2566 ata_for_each_dev(dev, link, ALL) 2567 classes[dev->devno] = ATA_DEV_NONE; 2568 if ((ap->pflags & ATA_PFLAG_FROZEN) && 2569 ata_is_host_link(link)) 2570 ata_eh_thaw_port(ap); 2571 rc = 0; 2572 goto out; 2573 } 2574 } 2575 2576 retry: 2577 /* 2578 * Perform reset 2579 */ 2580 if (ata_is_host_link(link)) 2581 ata_eh_freeze_port(ap); 2582 2583 deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]); 2584 2585 if (reset) { 2586 if (verbose) 2587 ata_link_info(link, "%s resetting link\n", 2588 reset == softreset ? "soft" : "hard"); 2589 2590 /* mark that this EH session started with reset */ 2591 ehc->last_reset = jiffies; 2592 if (reset == hardreset) 2593 ehc->i.flags |= ATA_EHI_DID_HARDRESET; 2594 else 2595 ehc->i.flags |= ATA_EHI_DID_SOFTRESET; 2596 2597 rc = ata_do_reset(link, reset, classes, deadline, true); 2598 if (rc && rc != -EAGAIN) { 2599 failed_link = link; 2600 goto fail; 2601 } 2602 2603 /* hardreset slave link if existent */ 2604 if (slave && reset == hardreset) { 2605 int tmp; 2606 2607 if (verbose) 2608 ata_link_info(slave, "hard resetting link\n"); 2609 2610 ata_eh_about_to_do(slave, NULL, ATA_EH_RESET); 2611 tmp = ata_do_reset(slave, reset, classes, deadline, 2612 false); 2613 switch (tmp) { 2614 case -EAGAIN: 2615 rc = -EAGAIN; 2616 case 0: 2617 break; 2618 default: 2619 failed_link = slave; 2620 rc = tmp; 2621 goto fail; 2622 } 2623 } 2624 2625 /* perform follow-up SRST if necessary */ 2626 if (reset == hardreset && 2627 ata_eh_followup_srst_needed(link, rc)) { 2628 reset = softreset; 2629 2630 if (!reset) { 2631 ata_link_err(link, 2632 "follow-up softreset required but no softreset available\n"); 2633 failed_link = link; 2634 rc = -EINVAL; 2635 goto fail; 2636 } 2637 2638 ata_eh_about_to_do(link, NULL, ATA_EH_RESET); 2639 rc = ata_do_reset(link, reset, classes, deadline, true); 2640 if (rc) { 2641 failed_link = link; 2642 goto fail; 2643 } 2644 } 2645 } else { 2646 if (verbose) 2647 ata_link_info(link, 2648 "no reset method available, skipping reset\n"); 2649 if (!(lflags & ATA_LFLAG_ASSUME_CLASS)) 2650 lflags |= ATA_LFLAG_ASSUME_ATA; 2651 } 2652 2653 /* 2654 * Post-reset processing 2655 */ 2656 ata_for_each_dev(dev, link, ALL) { 2657 /* After the reset, the device state is PIO 0 and the 2658 * controller state is undefined. Reset also wakes up 2659 * drives from sleeping mode. 2660 */ 2661 dev->pio_mode = XFER_PIO_0; 2662 dev->flags &= ~ATA_DFLAG_SLEEPING; 2663 2664 if (ata_phys_link_offline(ata_dev_phys_link(dev))) 2665 continue; 2666 2667 /* apply class override */ 2668 if (lflags & ATA_LFLAG_ASSUME_ATA) 2669 classes[dev->devno] = ATA_DEV_ATA; 2670 else if (lflags & ATA_LFLAG_ASSUME_SEMB) 2671 classes[dev->devno] = ATA_DEV_SEMB_UNSUP; 2672 } 2673 2674 /* record current link speed */ 2675 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0) 2676 link->sata_spd = (sstatus >> 4) & 0xf; 2677 if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0) 2678 slave->sata_spd = (sstatus >> 4) & 0xf; 2679 2680 /* thaw the port */ 2681 if (ata_is_host_link(link)) 2682 ata_eh_thaw_port(ap); 2683 2684 /* postreset() should clear hardware SError. Although SError 2685 * is cleared during link resume, clearing SError here is 2686 * necessary as some PHYs raise hotplug events after SRST. 2687 * This introduces race condition where hotplug occurs between 2688 * reset and here. This race is mediated by cross checking 2689 * link onlineness and classification result later. 2690 */ 2691 if (postreset) { 2692 postreset(link, classes); 2693 if (slave) 2694 postreset(slave, classes); 2695 } 2696 2697 /* 2698 * Some controllers can't be frozen very well and may set spurious 2699 * error conditions during reset. Clear accumulated error 2700 * information and re-thaw the port if frozen. As reset is the 2701 * final recovery action and we cross check link onlineness against 2702 * device classification later, no hotplug event is lost by this. 2703 */ 2704 spin_lock_irqsave(link->ap->lock, flags); 2705 memset(&link->eh_info, 0, sizeof(link->eh_info)); 2706 if (slave) 2707 memset(&slave->eh_info, 0, sizeof(link->eh_info)); 2708 ap->pflags &= ~ATA_PFLAG_EH_PENDING; 2709 spin_unlock_irqrestore(link->ap->lock, flags); 2710 2711 if (ap->pflags & ATA_PFLAG_FROZEN) 2712 ata_eh_thaw_port(ap); 2713 2714 /* 2715 * Make sure onlineness and classification result correspond. 2716 * Hotplug could have happened during reset and some 2717 * controllers fail to wait while a drive is spinning up after 2718 * being hotplugged causing misdetection. By cross checking 2719 * link on/offlineness and classification result, those 2720 * conditions can be reliably detected and retried. 2721 */ 2722 nr_unknown = 0; 2723 ata_for_each_dev(dev, link, ALL) { 2724 if (ata_phys_link_online(ata_dev_phys_link(dev))) { 2725 if (classes[dev->devno] == ATA_DEV_UNKNOWN) { 2726 ata_dev_dbg(dev, "link online but device misclassified\n"); 2727 classes[dev->devno] = ATA_DEV_NONE; 2728 nr_unknown++; 2729 } 2730 } else if (ata_phys_link_offline(ata_dev_phys_link(dev))) { 2731 if (ata_class_enabled(classes[dev->devno])) 2732 ata_dev_dbg(dev, 2733 "link offline, clearing class %d to NONE\n", 2734 classes[dev->devno]); 2735 classes[dev->devno] = ATA_DEV_NONE; 2736 } else if (classes[dev->devno] == ATA_DEV_UNKNOWN) { 2737 ata_dev_dbg(dev, 2738 "link status unknown, clearing UNKNOWN to NONE\n"); 2739 classes[dev->devno] = ATA_DEV_NONE; 2740 } 2741 } 2742 2743 if (classify && nr_unknown) { 2744 if (try < max_tries) { 2745 ata_link_warn(link, 2746 "link online but %d devices misclassified, retrying\n", 2747 nr_unknown); 2748 failed_link = link; 2749 rc = -EAGAIN; 2750 goto fail; 2751 } 2752 ata_link_warn(link, 2753 "link online but %d devices misclassified, " 2754 "device detection might fail\n", nr_unknown); 2755 } 2756 2757 /* reset successful, schedule revalidation */ 2758 ata_eh_done(link, NULL, ATA_EH_RESET); 2759 if (slave) 2760 ata_eh_done(slave, NULL, ATA_EH_RESET); 2761 ehc->last_reset = jiffies; /* update to completion time */ 2762 ehc->i.action |= ATA_EH_REVALIDATE; 2763 link->lpm_policy = ATA_LPM_UNKNOWN; /* reset LPM state */ 2764 2765 rc = 0; 2766 out: 2767 /* clear hotplug flag */ 2768 ehc->i.flags &= ~ATA_EHI_HOTPLUGGED; 2769 if (slave) 2770 sehc->i.flags &= ~ATA_EHI_HOTPLUGGED; 2771 2772 spin_lock_irqsave(ap->lock, flags); 2773 ap->pflags &= ~ATA_PFLAG_RESETTING; 2774 spin_unlock_irqrestore(ap->lock, flags); 2775 2776 return rc; 2777 2778 fail: 2779 /* if SCR isn't accessible on a fan-out port, PMP needs to be reset */ 2780 if (!ata_is_host_link(link) && 2781 sata_scr_read(link, SCR_STATUS, &sstatus)) 2782 rc = -ERESTART; 2783 2784 if (try >= max_tries) { 2785 /* 2786 * Thaw host port even if reset failed, so that the port 2787 * can be retried on the next phy event. This risks 2788 * repeated EH runs but seems to be a better tradeoff than 2789 * shutting down a port after a botched hotplug attempt. 2790 */ 2791 if (ata_is_host_link(link)) 2792 ata_eh_thaw_port(ap); 2793 goto out; 2794 } 2795 2796 now = jiffies; 2797 if (time_before(now, deadline)) { 2798 unsigned long delta = deadline - now; 2799 2800 ata_link_warn(failed_link, 2801 "reset failed (errno=%d), retrying in %u secs\n", 2802 rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000)); 2803 2804 ata_eh_release(ap); 2805 while (delta) 2806 delta = schedule_timeout_uninterruptible(delta); 2807 ata_eh_acquire(ap); 2808 } 2809 2810 /* 2811 * While disks spinup behind PMP, some controllers fail sending SRST. 2812 * They need to be reset - as well as the PMP - before retrying. 2813 */ 2814 if (rc == -ERESTART) { 2815 if (ata_is_host_link(link)) 2816 ata_eh_thaw_port(ap); 2817 goto out; 2818 } 2819 2820 if (try == max_tries - 1) { 2821 sata_down_spd_limit(link, 0); 2822 if (slave) 2823 sata_down_spd_limit(slave, 0); 2824 } else if (rc == -EPIPE) 2825 sata_down_spd_limit(failed_link, 0); 2826 2827 if (hardreset) 2828 reset = hardreset; 2829 goto retry; 2830 } 2831 2832 static inline void ata_eh_pull_park_action(struct ata_port *ap) 2833 { 2834 struct ata_link *link; 2835 struct ata_device *dev; 2836 unsigned long flags; 2837 2838 /* 2839 * This function can be thought of as an extended version of 2840 * ata_eh_about_to_do() specially crafted to accommodate the 2841 * requirements of ATA_EH_PARK handling. Since the EH thread 2842 * does not leave the do {} while () loop in ata_eh_recover as 2843 * long as the timeout for a park request to *one* device on 2844 * the port has not expired, and since we still want to pick 2845 * up park requests to other devices on the same port or 2846 * timeout updates for the same device, we have to pull 2847 * ATA_EH_PARK actions from eh_info into eh_context.i 2848 * ourselves at the beginning of each pass over the loop. 2849 * 2850 * Additionally, all write accesses to &ap->park_req_pending 2851 * through reinit_completion() (see below) or complete_all() 2852 * (see ata_scsi_park_store()) are protected by the host lock. 2853 * As a result we have that park_req_pending.done is zero on 2854 * exit from this function, i.e. when ATA_EH_PARK actions for 2855 * *all* devices on port ap have been pulled into the 2856 * respective eh_context structs. If, and only if, 2857 * park_req_pending.done is non-zero by the time we reach 2858 * wait_for_completion_timeout(), another ATA_EH_PARK action 2859 * has been scheduled for at least one of the devices on port 2860 * ap and we have to cycle over the do {} while () loop in 2861 * ata_eh_recover() again. 2862 */ 2863 2864 spin_lock_irqsave(ap->lock, flags); 2865 reinit_completion(&ap->park_req_pending); 2866 ata_for_each_link(link, ap, EDGE) { 2867 ata_for_each_dev(dev, link, ALL) { 2868 struct ata_eh_info *ehi = &link->eh_info; 2869 2870 link->eh_context.i.dev_action[dev->devno] |= 2871 ehi->dev_action[dev->devno] & ATA_EH_PARK; 2872 ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK); 2873 } 2874 } 2875 spin_unlock_irqrestore(ap->lock, flags); 2876 } 2877 2878 static void ata_eh_park_issue_cmd(struct ata_device *dev, int park) 2879 { 2880 struct ata_eh_context *ehc = &dev->link->eh_context; 2881 struct ata_taskfile tf; 2882 unsigned int err_mask; 2883 2884 ata_tf_init(dev, &tf); 2885 if (park) { 2886 ehc->unloaded_mask |= 1 << dev->devno; 2887 tf.command = ATA_CMD_IDLEIMMEDIATE; 2888 tf.feature = 0x44; 2889 tf.lbal = 0x4c; 2890 tf.lbam = 0x4e; 2891 tf.lbah = 0x55; 2892 } else { 2893 ehc->unloaded_mask &= ~(1 << dev->devno); 2894 tf.command = ATA_CMD_CHK_POWER; 2895 } 2896 2897 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 2898 tf.protocol = ATA_PROT_NODATA; 2899 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 2900 if (park && (err_mask || tf.lbal != 0xc4)) { 2901 ata_dev_err(dev, "head unload failed!\n"); 2902 ehc->unloaded_mask &= ~(1 << dev->devno); 2903 } 2904 } 2905 2906 static int ata_eh_revalidate_and_attach(struct ata_link *link, 2907 struct ata_device **r_failed_dev) 2908 { 2909 struct ata_port *ap = link->ap; 2910 struct ata_eh_context *ehc = &link->eh_context; 2911 struct ata_device *dev; 2912 unsigned int new_mask = 0; 2913 unsigned long flags; 2914 int rc = 0; 2915 2916 DPRINTK("ENTER\n"); 2917 2918 /* For PATA drive side cable detection to work, IDENTIFY must 2919 * be done backwards such that PDIAG- is released by the slave 2920 * device before the master device is identified. 2921 */ 2922 ata_for_each_dev(dev, link, ALL_REVERSE) { 2923 unsigned int action = ata_eh_dev_action(dev); 2924 unsigned int readid_flags = 0; 2925 2926 if (ehc->i.flags & ATA_EHI_DID_RESET) 2927 readid_flags |= ATA_READID_POSTRESET; 2928 2929 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) { 2930 WARN_ON(dev->class == ATA_DEV_PMP); 2931 2932 if (ata_phys_link_offline(ata_dev_phys_link(dev))) { 2933 rc = -EIO; 2934 goto err; 2935 } 2936 2937 ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE); 2938 rc = ata_dev_revalidate(dev, ehc->classes[dev->devno], 2939 readid_flags); 2940 if (rc) 2941 goto err; 2942 2943 ata_eh_done(link, dev, ATA_EH_REVALIDATE); 2944 2945 /* Configuration may have changed, reconfigure 2946 * transfer mode. 2947 */ 2948 ehc->i.flags |= ATA_EHI_SETMODE; 2949 2950 /* schedule the scsi_rescan_device() here */ 2951 schedule_work(&(ap->scsi_rescan_task)); 2952 } else if (dev->class == ATA_DEV_UNKNOWN && 2953 ehc->tries[dev->devno] && 2954 ata_class_enabled(ehc->classes[dev->devno])) { 2955 /* Temporarily set dev->class, it will be 2956 * permanently set once all configurations are 2957 * complete. This is necessary because new 2958 * device configuration is done in two 2959 * separate loops. 2960 */ 2961 dev->class = ehc->classes[dev->devno]; 2962 2963 if (dev->class == ATA_DEV_PMP) 2964 rc = sata_pmp_attach(dev); 2965 else 2966 rc = ata_dev_read_id(dev, &dev->class, 2967 readid_flags, dev->id); 2968 2969 /* read_id might have changed class, store and reset */ 2970 ehc->classes[dev->devno] = dev->class; 2971 dev->class = ATA_DEV_UNKNOWN; 2972 2973 switch (rc) { 2974 case 0: 2975 /* clear error info accumulated during probe */ 2976 ata_ering_clear(&dev->ering); 2977 new_mask |= 1 << dev->devno; 2978 break; 2979 case -ENOENT: 2980 /* IDENTIFY was issued to non-existent 2981 * device. No need to reset. Just 2982 * thaw and ignore the device. 2983 */ 2984 ata_eh_thaw_port(ap); 2985 break; 2986 default: 2987 goto err; 2988 } 2989 } 2990 } 2991 2992 /* PDIAG- should have been released, ask cable type if post-reset */ 2993 if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) { 2994 if (ap->ops->cable_detect) 2995 ap->cbl = ap->ops->cable_detect(ap); 2996 ata_force_cbl(ap); 2997 } 2998 2999 /* Configure new devices forward such that user doesn't see 3000 * device detection messages backwards. 3001 */ 3002 ata_for_each_dev(dev, link, ALL) { 3003 if (!(new_mask & (1 << dev->devno))) 3004 continue; 3005 3006 dev->class = ehc->classes[dev->devno]; 3007 3008 if (dev->class == ATA_DEV_PMP) 3009 continue; 3010 3011 ehc->i.flags |= ATA_EHI_PRINTINFO; 3012 rc = ata_dev_configure(dev); 3013 ehc->i.flags &= ~ATA_EHI_PRINTINFO; 3014 if (rc) { 3015 dev->class = ATA_DEV_UNKNOWN; 3016 goto err; 3017 } 3018 3019 spin_lock_irqsave(ap->lock, flags); 3020 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG; 3021 spin_unlock_irqrestore(ap->lock, flags); 3022 3023 /* new device discovered, configure xfermode */ 3024 ehc->i.flags |= ATA_EHI_SETMODE; 3025 } 3026 3027 return 0; 3028 3029 err: 3030 *r_failed_dev = dev; 3031 DPRINTK("EXIT rc=%d\n", rc); 3032 return rc; 3033 } 3034 3035 /** 3036 * ata_set_mode - Program timings and issue SET FEATURES - XFER 3037 * @link: link on which timings will be programmed 3038 * @r_failed_dev: out parameter for failed device 3039 * 3040 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If 3041 * ata_set_mode() fails, pointer to the failing device is 3042 * returned in @r_failed_dev. 3043 * 3044 * LOCKING: 3045 * PCI/etc. bus probe sem. 3046 * 3047 * RETURNS: 3048 * 0 on success, negative errno otherwise 3049 */ 3050 int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 3051 { 3052 struct ata_port *ap = link->ap; 3053 struct ata_device *dev; 3054 int rc; 3055 3056 /* if data transfer is verified, clear DUBIOUS_XFER on ering top */ 3057 ata_for_each_dev(dev, link, ENABLED) { 3058 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) { 3059 struct ata_ering_entry *ent; 3060 3061 ent = ata_ering_top(&dev->ering); 3062 if (ent) 3063 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER; 3064 } 3065 } 3066 3067 /* has private set_mode? */ 3068 if (ap->ops->set_mode) 3069 rc = ap->ops->set_mode(link, r_failed_dev); 3070 else 3071 rc = ata_do_set_mode(link, r_failed_dev); 3072 3073 /* if transfer mode has changed, set DUBIOUS_XFER on device */ 3074 ata_for_each_dev(dev, link, ENABLED) { 3075 struct ata_eh_context *ehc = &link->eh_context; 3076 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno]; 3077 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno)); 3078 3079 if (dev->xfer_mode != saved_xfer_mode || 3080 ata_ncq_enabled(dev) != saved_ncq) 3081 dev->flags |= ATA_DFLAG_DUBIOUS_XFER; 3082 } 3083 3084 return rc; 3085 } 3086 3087 /** 3088 * atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset 3089 * @dev: ATAPI device to clear UA for 3090 * 3091 * Resets and other operations can make an ATAPI device raise 3092 * UNIT ATTENTION which causes the next operation to fail. This 3093 * function clears UA. 3094 * 3095 * LOCKING: 3096 * EH context (may sleep). 3097 * 3098 * RETURNS: 3099 * 0 on success, -errno on failure. 3100 */ 3101 static int atapi_eh_clear_ua(struct ata_device *dev) 3102 { 3103 int i; 3104 3105 for (i = 0; i < ATA_EH_UA_TRIES; i++) { 3106 u8 *sense_buffer = dev->link->ap->sector_buf; 3107 u8 sense_key = 0; 3108 unsigned int err_mask; 3109 3110 err_mask = atapi_eh_tur(dev, &sense_key); 3111 if (err_mask != 0 && err_mask != AC_ERR_DEV) { 3112 ata_dev_warn(dev, 3113 "TEST_UNIT_READY failed (err_mask=0x%x)\n", 3114 err_mask); 3115 return -EIO; 3116 } 3117 3118 if (!err_mask || sense_key != UNIT_ATTENTION) 3119 return 0; 3120 3121 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key); 3122 if (err_mask) { 3123 ata_dev_warn(dev, "failed to clear " 3124 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask); 3125 return -EIO; 3126 } 3127 } 3128 3129 ata_dev_warn(dev, "UNIT ATTENTION persists after %d tries\n", 3130 ATA_EH_UA_TRIES); 3131 3132 return 0; 3133 } 3134 3135 /** 3136 * ata_eh_maybe_retry_flush - Retry FLUSH if necessary 3137 * @dev: ATA device which may need FLUSH retry 3138 * 3139 * If @dev failed FLUSH, it needs to be reported upper layer 3140 * immediately as it means that @dev failed to remap and already 3141 * lost at least a sector and further FLUSH retrials won't make 3142 * any difference to the lost sector. However, if FLUSH failed 3143 * for other reasons, for example transmission error, FLUSH needs 3144 * to be retried. 3145 * 3146 * This function determines whether FLUSH failure retry is 3147 * necessary and performs it if so. 3148 * 3149 * RETURNS: 3150 * 0 if EH can continue, -errno if EH needs to be repeated. 3151 */ 3152 static int ata_eh_maybe_retry_flush(struct ata_device *dev) 3153 { 3154 struct ata_link *link = dev->link; 3155 struct ata_port *ap = link->ap; 3156 struct ata_queued_cmd *qc; 3157 struct ata_taskfile tf; 3158 unsigned int err_mask; 3159 int rc = 0; 3160 3161 /* did flush fail for this device? */ 3162 if (!ata_tag_valid(link->active_tag)) 3163 return 0; 3164 3165 qc = __ata_qc_from_tag(ap, link->active_tag); 3166 if (qc->dev != dev || (qc->tf.command != ATA_CMD_FLUSH_EXT && 3167 qc->tf.command != ATA_CMD_FLUSH)) 3168 return 0; 3169 3170 /* if the device failed it, it should be reported to upper layers */ 3171 if (qc->err_mask & AC_ERR_DEV) 3172 return 0; 3173 3174 /* flush failed for some other reason, give it another shot */ 3175 ata_tf_init(dev, &tf); 3176 3177 tf.command = qc->tf.command; 3178 tf.flags |= ATA_TFLAG_DEVICE; 3179 tf.protocol = ATA_PROT_NODATA; 3180 3181 ata_dev_warn(dev, "retrying FLUSH 0x%x Emask 0x%x\n", 3182 tf.command, qc->err_mask); 3183 3184 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 3185 if (!err_mask) { 3186 /* 3187 * FLUSH is complete but there's no way to 3188 * successfully complete a failed command from EH. 3189 * Making sure retry is allowed at least once and 3190 * retrying it should do the trick - whatever was in 3191 * the cache is already on the platter and this won't 3192 * cause infinite loop. 3193 */ 3194 qc->scsicmd->allowed = max(qc->scsicmd->allowed, 1); 3195 } else { 3196 ata_dev_warn(dev, "FLUSH failed Emask 0x%x\n", 3197 err_mask); 3198 rc = -EIO; 3199 3200 /* if device failed it, report it to upper layers */ 3201 if (err_mask & AC_ERR_DEV) { 3202 qc->err_mask |= AC_ERR_DEV; 3203 qc->result_tf = tf; 3204 if (!(ap->pflags & ATA_PFLAG_FROZEN)) 3205 rc = 0; 3206 } 3207 } 3208 return rc; 3209 } 3210 3211 /** 3212 * ata_eh_set_lpm - configure SATA interface power management 3213 * @link: link to configure power management 3214 * @policy: the link power management policy 3215 * @r_failed_dev: out parameter for failed device 3216 * 3217 * Enable SATA Interface power management. This will enable 3218 * Device Interface Power Management (DIPM) for min_power and 3219 * medium_power_with_dipm policies, and then call driver specific 3220 * callbacks for enabling Host Initiated Power management. 3221 * 3222 * LOCKING: 3223 * EH context. 3224 * 3225 * RETURNS: 3226 * 0 on success, -errno on failure. 3227 */ 3228 static int ata_eh_set_lpm(struct ata_link *link, enum ata_lpm_policy policy, 3229 struct ata_device **r_failed_dev) 3230 { 3231 struct ata_port *ap = ata_is_host_link(link) ? link->ap : NULL; 3232 struct ata_eh_context *ehc = &link->eh_context; 3233 struct ata_device *dev, *link_dev = NULL, *lpm_dev = NULL; 3234 enum ata_lpm_policy old_policy = link->lpm_policy; 3235 bool no_dipm = link->ap->flags & ATA_FLAG_NO_DIPM; 3236 unsigned int hints = ATA_LPM_EMPTY | ATA_LPM_HIPM; 3237 unsigned int err_mask; 3238 int rc; 3239 3240 /* if the link or host doesn't do LPM, noop */ 3241 if (!IS_ENABLED(CONFIG_SATA_HOST) || 3242 (link->flags & ATA_LFLAG_NO_LPM) || (ap && !ap->ops->set_lpm)) 3243 return 0; 3244 3245 /* 3246 * DIPM is enabled only for MIN_POWER as some devices 3247 * misbehave when the host NACKs transition to SLUMBER. Order 3248 * device and link configurations such that the host always 3249 * allows DIPM requests. 3250 */ 3251 ata_for_each_dev(dev, link, ENABLED) { 3252 bool hipm = ata_id_has_hipm(dev->id); 3253 bool dipm = ata_id_has_dipm(dev->id) && !no_dipm; 3254 3255 /* find the first enabled and LPM enabled devices */ 3256 if (!link_dev) 3257 link_dev = dev; 3258 3259 if (!lpm_dev && (hipm || dipm)) 3260 lpm_dev = dev; 3261 3262 hints &= ~ATA_LPM_EMPTY; 3263 if (!hipm) 3264 hints &= ~ATA_LPM_HIPM; 3265 3266 /* disable DIPM before changing link config */ 3267 if (policy < ATA_LPM_MED_POWER_WITH_DIPM && dipm) { 3268 err_mask = ata_dev_set_feature(dev, 3269 SETFEATURES_SATA_DISABLE, SATA_DIPM); 3270 if (err_mask && err_mask != AC_ERR_DEV) { 3271 ata_dev_warn(dev, 3272 "failed to disable DIPM, Emask 0x%x\n", 3273 err_mask); 3274 rc = -EIO; 3275 goto fail; 3276 } 3277 } 3278 } 3279 3280 if (ap) { 3281 rc = ap->ops->set_lpm(link, policy, hints); 3282 if (!rc && ap->slave_link) 3283 rc = ap->ops->set_lpm(ap->slave_link, policy, hints); 3284 } else 3285 rc = sata_pmp_set_lpm(link, policy, hints); 3286 3287 /* 3288 * Attribute link config failure to the first (LPM) enabled 3289 * device on the link. 3290 */ 3291 if (rc) { 3292 if (rc == -EOPNOTSUPP) { 3293 link->flags |= ATA_LFLAG_NO_LPM; 3294 return 0; 3295 } 3296 dev = lpm_dev ? lpm_dev : link_dev; 3297 goto fail; 3298 } 3299 3300 /* 3301 * Low level driver acked the transition. Issue DIPM command 3302 * with the new policy set. 3303 */ 3304 link->lpm_policy = policy; 3305 if (ap && ap->slave_link) 3306 ap->slave_link->lpm_policy = policy; 3307 3308 /* host config updated, enable DIPM if transitioning to MIN_POWER */ 3309 ata_for_each_dev(dev, link, ENABLED) { 3310 if (policy >= ATA_LPM_MED_POWER_WITH_DIPM && !no_dipm && 3311 ata_id_has_dipm(dev->id)) { 3312 err_mask = ata_dev_set_feature(dev, 3313 SETFEATURES_SATA_ENABLE, SATA_DIPM); 3314 if (err_mask && err_mask != AC_ERR_DEV) { 3315 ata_dev_warn(dev, 3316 "failed to enable DIPM, Emask 0x%x\n", 3317 err_mask); 3318 rc = -EIO; 3319 goto fail; 3320 } 3321 } 3322 } 3323 3324 link->last_lpm_change = jiffies; 3325 link->flags |= ATA_LFLAG_CHANGED; 3326 3327 return 0; 3328 3329 fail: 3330 /* restore the old policy */ 3331 link->lpm_policy = old_policy; 3332 if (ap && ap->slave_link) 3333 ap->slave_link->lpm_policy = old_policy; 3334 3335 /* if no device or only one more chance is left, disable LPM */ 3336 if (!dev || ehc->tries[dev->devno] <= 2) { 3337 ata_link_warn(link, "disabling LPM on the link\n"); 3338 link->flags |= ATA_LFLAG_NO_LPM; 3339 } 3340 if (r_failed_dev) 3341 *r_failed_dev = dev; 3342 return rc; 3343 } 3344 3345 int ata_link_nr_enabled(struct ata_link *link) 3346 { 3347 struct ata_device *dev; 3348 int cnt = 0; 3349 3350 ata_for_each_dev(dev, link, ENABLED) 3351 cnt++; 3352 return cnt; 3353 } 3354 3355 static int ata_link_nr_vacant(struct ata_link *link) 3356 { 3357 struct ata_device *dev; 3358 int cnt = 0; 3359 3360 ata_for_each_dev(dev, link, ALL) 3361 if (dev->class == ATA_DEV_UNKNOWN) 3362 cnt++; 3363 return cnt; 3364 } 3365 3366 static int ata_eh_skip_recovery(struct ata_link *link) 3367 { 3368 struct ata_port *ap = link->ap; 3369 struct ata_eh_context *ehc = &link->eh_context; 3370 struct ata_device *dev; 3371 3372 /* skip disabled links */ 3373 if (link->flags & ATA_LFLAG_DISABLED) 3374 return 1; 3375 3376 /* skip if explicitly requested */ 3377 if (ehc->i.flags & ATA_EHI_NO_RECOVERY) 3378 return 1; 3379 3380 /* thaw frozen port and recover failed devices */ 3381 if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link)) 3382 return 0; 3383 3384 /* reset at least once if reset is requested */ 3385 if ((ehc->i.action & ATA_EH_RESET) && 3386 !(ehc->i.flags & ATA_EHI_DID_RESET)) 3387 return 0; 3388 3389 /* skip if class codes for all vacant slots are ATA_DEV_NONE */ 3390 ata_for_each_dev(dev, link, ALL) { 3391 if (dev->class == ATA_DEV_UNKNOWN && 3392 ehc->classes[dev->devno] != ATA_DEV_NONE) 3393 return 0; 3394 } 3395 3396 return 1; 3397 } 3398 3399 static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg) 3400 { 3401 u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL); 3402 u64 now = get_jiffies_64(); 3403 int *trials = void_arg; 3404 3405 if ((ent->eflags & ATA_EFLAG_OLD_ER) || 3406 (ent->timestamp < now - min(now, interval))) 3407 return -1; 3408 3409 (*trials)++; 3410 return 0; 3411 } 3412 3413 static int ata_eh_schedule_probe(struct ata_device *dev) 3414 { 3415 struct ata_eh_context *ehc = &dev->link->eh_context; 3416 struct ata_link *link = ata_dev_phys_link(dev); 3417 int trials = 0; 3418 3419 if (!(ehc->i.probe_mask & (1 << dev->devno)) || 3420 (ehc->did_probe_mask & (1 << dev->devno))) 3421 return 0; 3422 3423 ata_eh_detach_dev(dev); 3424 ata_dev_init(dev); 3425 ehc->did_probe_mask |= (1 << dev->devno); 3426 ehc->i.action |= ATA_EH_RESET; 3427 ehc->saved_xfer_mode[dev->devno] = 0; 3428 ehc->saved_ncq_enabled &= ~(1 << dev->devno); 3429 3430 /* the link maybe in a deep sleep, wake it up */ 3431 if (link->lpm_policy > ATA_LPM_MAX_POWER) { 3432 if (ata_is_host_link(link)) 3433 link->ap->ops->set_lpm(link, ATA_LPM_MAX_POWER, 3434 ATA_LPM_EMPTY); 3435 else 3436 sata_pmp_set_lpm(link, ATA_LPM_MAX_POWER, 3437 ATA_LPM_EMPTY); 3438 } 3439 3440 /* Record and count probe trials on the ering. The specific 3441 * error mask used is irrelevant. Because a successful device 3442 * detection clears the ering, this count accumulates only if 3443 * there are consecutive failed probes. 3444 * 3445 * If the count is equal to or higher than ATA_EH_PROBE_TRIALS 3446 * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is 3447 * forced to 1.5Gbps. 3448 * 3449 * This is to work around cases where failed link speed 3450 * negotiation results in device misdetection leading to 3451 * infinite DEVXCHG or PHRDY CHG events. 3452 */ 3453 ata_ering_record(&dev->ering, 0, AC_ERR_OTHER); 3454 ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials); 3455 3456 if (trials > ATA_EH_PROBE_TRIALS) 3457 sata_down_spd_limit(link, 1); 3458 3459 return 1; 3460 } 3461 3462 static int ata_eh_handle_dev_fail(struct ata_device *dev, int err) 3463 { 3464 struct ata_eh_context *ehc = &dev->link->eh_context; 3465 3466 /* -EAGAIN from EH routine indicates retry without prejudice. 3467 * The requester is responsible for ensuring forward progress. 3468 */ 3469 if (err != -EAGAIN) 3470 ehc->tries[dev->devno]--; 3471 3472 switch (err) { 3473 case -ENODEV: 3474 /* device missing or wrong IDENTIFY data, schedule probing */ 3475 ehc->i.probe_mask |= (1 << dev->devno); 3476 fallthrough; 3477 case -EINVAL: 3478 /* give it just one more chance */ 3479 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1); 3480 fallthrough; 3481 case -EIO: 3482 if (ehc->tries[dev->devno] == 1) { 3483 /* This is the last chance, better to slow 3484 * down than lose it. 3485 */ 3486 sata_down_spd_limit(ata_dev_phys_link(dev), 0); 3487 if (dev->pio_mode > XFER_PIO_0) 3488 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO); 3489 } 3490 } 3491 3492 if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) { 3493 /* disable device if it has used up all its chances */ 3494 ata_dev_disable(dev); 3495 3496 /* detach if offline */ 3497 if (ata_phys_link_offline(ata_dev_phys_link(dev))) 3498 ata_eh_detach_dev(dev); 3499 3500 /* schedule probe if necessary */ 3501 if (ata_eh_schedule_probe(dev)) { 3502 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES; 3503 memset(ehc->cmd_timeout_idx[dev->devno], 0, 3504 sizeof(ehc->cmd_timeout_idx[dev->devno])); 3505 } 3506 3507 return 1; 3508 } else { 3509 ehc->i.action |= ATA_EH_RESET; 3510 return 0; 3511 } 3512 } 3513 3514 /** 3515 * ata_eh_recover - recover host port after error 3516 * @ap: host port to recover 3517 * @prereset: prereset method (can be NULL) 3518 * @softreset: softreset method (can be NULL) 3519 * @hardreset: hardreset method (can be NULL) 3520 * @postreset: postreset method (can be NULL) 3521 * @r_failed_link: out parameter for failed link 3522 * 3523 * This is the alpha and omega, eum and yang, heart and soul of 3524 * libata exception handling. On entry, actions required to 3525 * recover each link and hotplug requests are recorded in the 3526 * link's eh_context. This function executes all the operations 3527 * with appropriate retrials and fallbacks to resurrect failed 3528 * devices, detach goners and greet newcomers. 3529 * 3530 * LOCKING: 3531 * Kernel thread context (may sleep). 3532 * 3533 * RETURNS: 3534 * 0 on success, -errno on failure. 3535 */ 3536 int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset, 3537 ata_reset_fn_t softreset, ata_reset_fn_t hardreset, 3538 ata_postreset_fn_t postreset, 3539 struct ata_link **r_failed_link) 3540 { 3541 struct ata_link *link; 3542 struct ata_device *dev; 3543 int rc, nr_fails; 3544 unsigned long flags, deadline; 3545 3546 DPRINTK("ENTER\n"); 3547 3548 /* prep for recovery */ 3549 ata_for_each_link(link, ap, EDGE) { 3550 struct ata_eh_context *ehc = &link->eh_context; 3551 3552 /* re-enable link? */ 3553 if (ehc->i.action & ATA_EH_ENABLE_LINK) { 3554 ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK); 3555 spin_lock_irqsave(ap->lock, flags); 3556 link->flags &= ~ATA_LFLAG_DISABLED; 3557 spin_unlock_irqrestore(ap->lock, flags); 3558 ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK); 3559 } 3560 3561 ata_for_each_dev(dev, link, ALL) { 3562 if (link->flags & ATA_LFLAG_NO_RETRY) 3563 ehc->tries[dev->devno] = 1; 3564 else 3565 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES; 3566 3567 /* collect port action mask recorded in dev actions */ 3568 ehc->i.action |= ehc->i.dev_action[dev->devno] & 3569 ~ATA_EH_PERDEV_MASK; 3570 ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK; 3571 3572 /* process hotplug request */ 3573 if (dev->flags & ATA_DFLAG_DETACH) 3574 ata_eh_detach_dev(dev); 3575 3576 /* schedule probe if necessary */ 3577 if (!ata_dev_enabled(dev)) 3578 ata_eh_schedule_probe(dev); 3579 } 3580 } 3581 3582 retry: 3583 rc = 0; 3584 3585 /* if UNLOADING, finish immediately */ 3586 if (ap->pflags & ATA_PFLAG_UNLOADING) 3587 goto out; 3588 3589 /* prep for EH */ 3590 ata_for_each_link(link, ap, EDGE) { 3591 struct ata_eh_context *ehc = &link->eh_context; 3592 3593 /* skip EH if possible. */ 3594 if (ata_eh_skip_recovery(link)) 3595 ehc->i.action = 0; 3596 3597 ata_for_each_dev(dev, link, ALL) 3598 ehc->classes[dev->devno] = ATA_DEV_UNKNOWN; 3599 } 3600 3601 /* reset */ 3602 ata_for_each_link(link, ap, EDGE) { 3603 struct ata_eh_context *ehc = &link->eh_context; 3604 3605 if (!(ehc->i.action & ATA_EH_RESET)) 3606 continue; 3607 3608 rc = ata_eh_reset(link, ata_link_nr_vacant(link), 3609 prereset, softreset, hardreset, postreset); 3610 if (rc) { 3611 ata_link_err(link, "reset failed, giving up\n"); 3612 goto out; 3613 } 3614 } 3615 3616 do { 3617 unsigned long now; 3618 3619 /* 3620 * clears ATA_EH_PARK in eh_info and resets 3621 * ap->park_req_pending 3622 */ 3623 ata_eh_pull_park_action(ap); 3624 3625 deadline = jiffies; 3626 ata_for_each_link(link, ap, EDGE) { 3627 ata_for_each_dev(dev, link, ALL) { 3628 struct ata_eh_context *ehc = &link->eh_context; 3629 unsigned long tmp; 3630 3631 if (dev->class != ATA_DEV_ATA && 3632 dev->class != ATA_DEV_ZAC) 3633 continue; 3634 if (!(ehc->i.dev_action[dev->devno] & 3635 ATA_EH_PARK)) 3636 continue; 3637 tmp = dev->unpark_deadline; 3638 if (time_before(deadline, tmp)) 3639 deadline = tmp; 3640 else if (time_before_eq(tmp, jiffies)) 3641 continue; 3642 if (ehc->unloaded_mask & (1 << dev->devno)) 3643 continue; 3644 3645 ata_eh_park_issue_cmd(dev, 1); 3646 } 3647 } 3648 3649 now = jiffies; 3650 if (time_before_eq(deadline, now)) 3651 break; 3652 3653 ata_eh_release(ap); 3654 deadline = wait_for_completion_timeout(&ap->park_req_pending, 3655 deadline - now); 3656 ata_eh_acquire(ap); 3657 } while (deadline); 3658 ata_for_each_link(link, ap, EDGE) { 3659 ata_for_each_dev(dev, link, ALL) { 3660 if (!(link->eh_context.unloaded_mask & 3661 (1 << dev->devno))) 3662 continue; 3663 3664 ata_eh_park_issue_cmd(dev, 0); 3665 ata_eh_done(link, dev, ATA_EH_PARK); 3666 } 3667 } 3668 3669 /* the rest */ 3670 nr_fails = 0; 3671 ata_for_each_link(link, ap, PMP_FIRST) { 3672 struct ata_eh_context *ehc = &link->eh_context; 3673 3674 if (sata_pmp_attached(ap) && ata_is_host_link(link)) 3675 goto config_lpm; 3676 3677 /* revalidate existing devices and attach new ones */ 3678 rc = ata_eh_revalidate_and_attach(link, &dev); 3679 if (rc) 3680 goto rest_fail; 3681 3682 /* if PMP got attached, return, pmp EH will take care of it */ 3683 if (link->device->class == ATA_DEV_PMP) { 3684 ehc->i.action = 0; 3685 return 0; 3686 } 3687 3688 /* configure transfer mode if necessary */ 3689 if (ehc->i.flags & ATA_EHI_SETMODE) { 3690 rc = ata_set_mode(link, &dev); 3691 if (rc) 3692 goto rest_fail; 3693 ehc->i.flags &= ~ATA_EHI_SETMODE; 3694 } 3695 3696 /* If reset has been issued, clear UA to avoid 3697 * disrupting the current users of the device. 3698 */ 3699 if (ehc->i.flags & ATA_EHI_DID_RESET) { 3700 ata_for_each_dev(dev, link, ALL) { 3701 if (dev->class != ATA_DEV_ATAPI) 3702 continue; 3703 rc = atapi_eh_clear_ua(dev); 3704 if (rc) 3705 goto rest_fail; 3706 if (zpodd_dev_enabled(dev)) 3707 zpodd_post_poweron(dev); 3708 } 3709 } 3710 3711 /* retry flush if necessary */ 3712 ata_for_each_dev(dev, link, ALL) { 3713 if (dev->class != ATA_DEV_ATA && 3714 dev->class != ATA_DEV_ZAC) 3715 continue; 3716 rc = ata_eh_maybe_retry_flush(dev); 3717 if (rc) 3718 goto rest_fail; 3719 } 3720 3721 config_lpm: 3722 /* configure link power saving */ 3723 if (link->lpm_policy != ap->target_lpm_policy) { 3724 rc = ata_eh_set_lpm(link, ap->target_lpm_policy, &dev); 3725 if (rc) 3726 goto rest_fail; 3727 } 3728 3729 /* this link is okay now */ 3730 ehc->i.flags = 0; 3731 continue; 3732 3733 rest_fail: 3734 nr_fails++; 3735 if (dev) 3736 ata_eh_handle_dev_fail(dev, rc); 3737 3738 if (ap->pflags & ATA_PFLAG_FROZEN) { 3739 /* PMP reset requires working host port. 3740 * Can't retry if it's frozen. 3741 */ 3742 if (sata_pmp_attached(ap)) 3743 goto out; 3744 break; 3745 } 3746 } 3747 3748 if (nr_fails) 3749 goto retry; 3750 3751 out: 3752 if (rc && r_failed_link) 3753 *r_failed_link = link; 3754 3755 DPRINTK("EXIT, rc=%d\n", rc); 3756 return rc; 3757 } 3758 3759 /** 3760 * ata_eh_finish - finish up EH 3761 * @ap: host port to finish EH for 3762 * 3763 * Recovery is complete. Clean up EH states and retry or finish 3764 * failed qcs. 3765 * 3766 * LOCKING: 3767 * None. 3768 */ 3769 void ata_eh_finish(struct ata_port *ap) 3770 { 3771 struct ata_queued_cmd *qc; 3772 int tag; 3773 3774 /* retry or finish qcs */ 3775 ata_qc_for_each_raw(ap, qc, tag) { 3776 if (!(qc->flags & ATA_QCFLAG_FAILED)) 3777 continue; 3778 3779 if (qc->err_mask) { 3780 /* FIXME: Once EH migration is complete, 3781 * generate sense data in this function, 3782 * considering both err_mask and tf. 3783 */ 3784 if (qc->flags & ATA_QCFLAG_RETRY) 3785 ata_eh_qc_retry(qc); 3786 else 3787 ata_eh_qc_complete(qc); 3788 } else { 3789 if (qc->flags & ATA_QCFLAG_SENSE_VALID) { 3790 ata_eh_qc_complete(qc); 3791 } else { 3792 /* feed zero TF to sense generation */ 3793 memset(&qc->result_tf, 0, sizeof(qc->result_tf)); 3794 ata_eh_qc_retry(qc); 3795 } 3796 } 3797 } 3798 3799 /* make sure nr_active_links is zero after EH */ 3800 WARN_ON(ap->nr_active_links); 3801 ap->nr_active_links = 0; 3802 } 3803 3804 /** 3805 * ata_do_eh - do standard error handling 3806 * @ap: host port to handle error for 3807 * 3808 * @prereset: prereset method (can be NULL) 3809 * @softreset: softreset method (can be NULL) 3810 * @hardreset: hardreset method (can be NULL) 3811 * @postreset: postreset method (can be NULL) 3812 * 3813 * Perform standard error handling sequence. 3814 * 3815 * LOCKING: 3816 * Kernel thread context (may sleep). 3817 */ 3818 void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset, 3819 ata_reset_fn_t softreset, ata_reset_fn_t hardreset, 3820 ata_postreset_fn_t postreset) 3821 { 3822 struct ata_device *dev; 3823 int rc; 3824 3825 ata_eh_autopsy(ap); 3826 ata_eh_report(ap); 3827 3828 rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset, 3829 NULL); 3830 if (rc) { 3831 ata_for_each_dev(dev, &ap->link, ALL) 3832 ata_dev_disable(dev); 3833 } 3834 3835 ata_eh_finish(ap); 3836 } 3837 3838 /** 3839 * ata_std_error_handler - standard error handler 3840 * @ap: host port to handle error for 3841 * 3842 * Standard error handler 3843 * 3844 * LOCKING: 3845 * Kernel thread context (may sleep). 3846 */ 3847 void ata_std_error_handler(struct ata_port *ap) 3848 { 3849 struct ata_port_operations *ops = ap->ops; 3850 ata_reset_fn_t hardreset = ops->hardreset; 3851 3852 /* ignore built-in hardreset if SCR access is not available */ 3853 if (hardreset == sata_std_hardreset && !sata_scr_valid(&ap->link)) 3854 hardreset = NULL; 3855 3856 ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset); 3857 } 3858 EXPORT_SYMBOL_GPL(ata_std_error_handler); 3859 3860 #ifdef CONFIG_PM 3861 /** 3862 * ata_eh_handle_port_suspend - perform port suspend operation 3863 * @ap: port to suspend 3864 * 3865 * Suspend @ap. 3866 * 3867 * LOCKING: 3868 * Kernel thread context (may sleep). 3869 */ 3870 static void ata_eh_handle_port_suspend(struct ata_port *ap) 3871 { 3872 unsigned long flags; 3873 int rc = 0; 3874 struct ata_device *dev; 3875 3876 /* are we suspending? */ 3877 spin_lock_irqsave(ap->lock, flags); 3878 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) || 3879 ap->pm_mesg.event & PM_EVENT_RESUME) { 3880 spin_unlock_irqrestore(ap->lock, flags); 3881 return; 3882 } 3883 spin_unlock_irqrestore(ap->lock, flags); 3884 3885 WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED); 3886 3887 /* 3888 * If we have a ZPODD attached, check its zero 3889 * power ready status before the port is frozen. 3890 * Only needed for runtime suspend. 3891 */ 3892 if (PMSG_IS_AUTO(ap->pm_mesg)) { 3893 ata_for_each_dev(dev, &ap->link, ENABLED) { 3894 if (zpodd_dev_enabled(dev)) 3895 zpodd_on_suspend(dev); 3896 } 3897 } 3898 3899 /* tell ACPI we're suspending */ 3900 rc = ata_acpi_on_suspend(ap); 3901 if (rc) 3902 goto out; 3903 3904 /* suspend */ 3905 ata_eh_freeze_port(ap); 3906 3907 if (ap->ops->port_suspend) 3908 rc = ap->ops->port_suspend(ap, ap->pm_mesg); 3909 3910 ata_acpi_set_state(ap, ap->pm_mesg); 3911 out: 3912 /* update the flags */ 3913 spin_lock_irqsave(ap->lock, flags); 3914 3915 ap->pflags &= ~ATA_PFLAG_PM_PENDING; 3916 if (rc == 0) 3917 ap->pflags |= ATA_PFLAG_SUSPENDED; 3918 else if (ap->pflags & ATA_PFLAG_FROZEN) 3919 ata_port_schedule_eh(ap); 3920 3921 spin_unlock_irqrestore(ap->lock, flags); 3922 3923 return; 3924 } 3925 3926 /** 3927 * ata_eh_handle_port_resume - perform port resume operation 3928 * @ap: port to resume 3929 * 3930 * Resume @ap. 3931 * 3932 * LOCKING: 3933 * Kernel thread context (may sleep). 3934 */ 3935 static void ata_eh_handle_port_resume(struct ata_port *ap) 3936 { 3937 struct ata_link *link; 3938 struct ata_device *dev; 3939 unsigned long flags; 3940 3941 /* are we resuming? */ 3942 spin_lock_irqsave(ap->lock, flags); 3943 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) || 3944 !(ap->pm_mesg.event & PM_EVENT_RESUME)) { 3945 spin_unlock_irqrestore(ap->lock, flags); 3946 return; 3947 } 3948 spin_unlock_irqrestore(ap->lock, flags); 3949 3950 WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED)); 3951 3952 /* 3953 * Error timestamps are in jiffies which doesn't run while 3954 * suspended and PHY events during resume isn't too uncommon. 3955 * When the two are combined, it can lead to unnecessary speed 3956 * downs if the machine is suspended and resumed repeatedly. 3957 * Clear error history. 3958 */ 3959 ata_for_each_link(link, ap, HOST_FIRST) 3960 ata_for_each_dev(dev, link, ALL) 3961 ata_ering_clear(&dev->ering); 3962 3963 ata_acpi_set_state(ap, ap->pm_mesg); 3964 3965 if (ap->ops->port_resume) 3966 ap->ops->port_resume(ap); 3967 3968 /* tell ACPI that we're resuming */ 3969 ata_acpi_on_resume(ap); 3970 3971 /* update the flags */ 3972 spin_lock_irqsave(ap->lock, flags); 3973 ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED); 3974 spin_unlock_irqrestore(ap->lock, flags); 3975 } 3976 #endif /* CONFIG_PM */ 3977