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