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 (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 /* 2913 * While disks spinup behind PMP, some controllers fail sending SRST. 2914 * They need to be reset - as well as the PMP - before retrying. 2915 */ 2916 if (rc == -ERESTART) { 2917 if (ata_is_host_link(link)) 2918 ata_eh_thaw_port(ap); 2919 goto out; 2920 } 2921 2922 if (try == max_tries - 1) { 2923 sata_down_spd_limit(link, 0); 2924 if (slave) 2925 sata_down_spd_limit(slave, 0); 2926 } else if (rc == -EPIPE) 2927 sata_down_spd_limit(failed_link, 0); 2928 2929 if (hardreset) 2930 reset = hardreset; 2931 goto retry; 2932 } 2933 2934 static inline void ata_eh_pull_park_action(struct ata_port *ap) 2935 { 2936 struct ata_link *link; 2937 struct ata_device *dev; 2938 unsigned long flags; 2939 2940 /* 2941 * This function can be thought of as an extended version of 2942 * ata_eh_about_to_do() specially crafted to accommodate the 2943 * requirements of ATA_EH_PARK handling. Since the EH thread 2944 * does not leave the do {} while () loop in ata_eh_recover as 2945 * long as the timeout for a park request to *one* device on 2946 * the port has not expired, and since we still want to pick 2947 * up park requests to other devices on the same port or 2948 * timeout updates for the same device, we have to pull 2949 * ATA_EH_PARK actions from eh_info into eh_context.i 2950 * ourselves at the beginning of each pass over the loop. 2951 * 2952 * Additionally, all write accesses to &ap->park_req_pending 2953 * through INIT_COMPLETION() (see below) or complete_all() 2954 * (see ata_scsi_park_store()) are protected by the host lock. 2955 * As a result we have that park_req_pending.done is zero on 2956 * exit from this function, i.e. when ATA_EH_PARK actions for 2957 * *all* devices on port ap have been pulled into the 2958 * respective eh_context structs. If, and only if, 2959 * park_req_pending.done is non-zero by the time we reach 2960 * wait_for_completion_timeout(), another ATA_EH_PARK action 2961 * has been scheduled for at least one of the devices on port 2962 * ap and we have to cycle over the do {} while () loop in 2963 * ata_eh_recover() again. 2964 */ 2965 2966 spin_lock_irqsave(ap->lock, flags); 2967 INIT_COMPLETION(ap->park_req_pending); 2968 ata_for_each_link(link, ap, EDGE) { 2969 ata_for_each_dev(dev, link, ALL) { 2970 struct ata_eh_info *ehi = &link->eh_info; 2971 2972 link->eh_context.i.dev_action[dev->devno] |= 2973 ehi->dev_action[dev->devno] & ATA_EH_PARK; 2974 ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK); 2975 } 2976 } 2977 spin_unlock_irqrestore(ap->lock, flags); 2978 } 2979 2980 static void ata_eh_park_issue_cmd(struct ata_device *dev, int park) 2981 { 2982 struct ata_eh_context *ehc = &dev->link->eh_context; 2983 struct ata_taskfile tf; 2984 unsigned int err_mask; 2985 2986 ata_tf_init(dev, &tf); 2987 if (park) { 2988 ehc->unloaded_mask |= 1 << dev->devno; 2989 tf.command = ATA_CMD_IDLEIMMEDIATE; 2990 tf.feature = 0x44; 2991 tf.lbal = 0x4c; 2992 tf.lbam = 0x4e; 2993 tf.lbah = 0x55; 2994 } else { 2995 ehc->unloaded_mask &= ~(1 << dev->devno); 2996 tf.command = ATA_CMD_CHK_POWER; 2997 } 2998 2999 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 3000 tf.protocol |= ATA_PROT_NODATA; 3001 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 3002 if (park && (err_mask || tf.lbal != 0xc4)) { 3003 ata_dev_err(dev, "head unload failed!\n"); 3004 ehc->unloaded_mask &= ~(1 << dev->devno); 3005 } 3006 } 3007 3008 static int ata_eh_revalidate_and_attach(struct ata_link *link, 3009 struct ata_device **r_failed_dev) 3010 { 3011 struct ata_port *ap = link->ap; 3012 struct ata_eh_context *ehc = &link->eh_context; 3013 struct ata_device *dev; 3014 unsigned int new_mask = 0; 3015 unsigned long flags; 3016 int rc = 0; 3017 3018 DPRINTK("ENTER\n"); 3019 3020 /* For PATA drive side cable detection to work, IDENTIFY must 3021 * be done backwards such that PDIAG- is released by the slave 3022 * device before the master device is identified. 3023 */ 3024 ata_for_each_dev(dev, link, ALL_REVERSE) { 3025 unsigned int action = ata_eh_dev_action(dev); 3026 unsigned int readid_flags = 0; 3027 3028 if (ehc->i.flags & ATA_EHI_DID_RESET) 3029 readid_flags |= ATA_READID_POSTRESET; 3030 3031 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) { 3032 WARN_ON(dev->class == ATA_DEV_PMP); 3033 3034 if (ata_phys_link_offline(ata_dev_phys_link(dev))) { 3035 rc = -EIO; 3036 goto err; 3037 } 3038 3039 ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE); 3040 rc = ata_dev_revalidate(dev, ehc->classes[dev->devno], 3041 readid_flags); 3042 if (rc) 3043 goto err; 3044 3045 ata_eh_done(link, dev, ATA_EH_REVALIDATE); 3046 3047 /* Configuration may have changed, reconfigure 3048 * transfer mode. 3049 */ 3050 ehc->i.flags |= ATA_EHI_SETMODE; 3051 3052 /* schedule the scsi_rescan_device() here */ 3053 schedule_work(&(ap->scsi_rescan_task)); 3054 } else if (dev->class == ATA_DEV_UNKNOWN && 3055 ehc->tries[dev->devno] && 3056 ata_class_enabled(ehc->classes[dev->devno])) { 3057 /* Temporarily set dev->class, it will be 3058 * permanently set once all configurations are 3059 * complete. This is necessary because new 3060 * device configuration is done in two 3061 * separate loops. 3062 */ 3063 dev->class = ehc->classes[dev->devno]; 3064 3065 if (dev->class == ATA_DEV_PMP) 3066 rc = sata_pmp_attach(dev); 3067 else 3068 rc = ata_dev_read_id(dev, &dev->class, 3069 readid_flags, dev->id); 3070 3071 /* read_id might have changed class, store and reset */ 3072 ehc->classes[dev->devno] = dev->class; 3073 dev->class = ATA_DEV_UNKNOWN; 3074 3075 switch (rc) { 3076 case 0: 3077 /* clear error info accumulated during probe */ 3078 ata_ering_clear(&dev->ering); 3079 new_mask |= 1 << dev->devno; 3080 break; 3081 case -ENOENT: 3082 /* IDENTIFY was issued to non-existent 3083 * device. No need to reset. Just 3084 * thaw and ignore the device. 3085 */ 3086 ata_eh_thaw_port(ap); 3087 break; 3088 default: 3089 goto err; 3090 } 3091 } 3092 } 3093 3094 /* PDIAG- should have been released, ask cable type if post-reset */ 3095 if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) { 3096 if (ap->ops->cable_detect) 3097 ap->cbl = ap->ops->cable_detect(ap); 3098 ata_force_cbl(ap); 3099 } 3100 3101 /* Configure new devices forward such that user doesn't see 3102 * device detection messages backwards. 3103 */ 3104 ata_for_each_dev(dev, link, ALL) { 3105 if (!(new_mask & (1 << dev->devno))) 3106 continue; 3107 3108 dev->class = ehc->classes[dev->devno]; 3109 3110 if (dev->class == ATA_DEV_PMP) 3111 continue; 3112 3113 ehc->i.flags |= ATA_EHI_PRINTINFO; 3114 rc = ata_dev_configure(dev); 3115 ehc->i.flags &= ~ATA_EHI_PRINTINFO; 3116 if (rc) { 3117 dev->class = ATA_DEV_UNKNOWN; 3118 goto err; 3119 } 3120 3121 spin_lock_irqsave(ap->lock, flags); 3122 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG; 3123 spin_unlock_irqrestore(ap->lock, flags); 3124 3125 /* new device discovered, configure xfermode */ 3126 ehc->i.flags |= ATA_EHI_SETMODE; 3127 } 3128 3129 return 0; 3130 3131 err: 3132 *r_failed_dev = dev; 3133 DPRINTK("EXIT rc=%d\n", rc); 3134 return rc; 3135 } 3136 3137 /** 3138 * ata_set_mode - Program timings and issue SET FEATURES - XFER 3139 * @link: link on which timings will be programmed 3140 * @r_failed_dev: out parameter for failed device 3141 * 3142 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If 3143 * ata_set_mode() fails, pointer to the failing device is 3144 * returned in @r_failed_dev. 3145 * 3146 * LOCKING: 3147 * PCI/etc. bus probe sem. 3148 * 3149 * RETURNS: 3150 * 0 on success, negative errno otherwise 3151 */ 3152 int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 3153 { 3154 struct ata_port *ap = link->ap; 3155 struct ata_device *dev; 3156 int rc; 3157 3158 /* if data transfer is verified, clear DUBIOUS_XFER on ering top */ 3159 ata_for_each_dev(dev, link, ENABLED) { 3160 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) { 3161 struct ata_ering_entry *ent; 3162 3163 ent = ata_ering_top(&dev->ering); 3164 if (ent) 3165 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER; 3166 } 3167 } 3168 3169 /* has private set_mode? */ 3170 if (ap->ops->set_mode) 3171 rc = ap->ops->set_mode(link, r_failed_dev); 3172 else 3173 rc = ata_do_set_mode(link, r_failed_dev); 3174 3175 /* if transfer mode has changed, set DUBIOUS_XFER on device */ 3176 ata_for_each_dev(dev, link, ENABLED) { 3177 struct ata_eh_context *ehc = &link->eh_context; 3178 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno]; 3179 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno)); 3180 3181 if (dev->xfer_mode != saved_xfer_mode || 3182 ata_ncq_enabled(dev) != saved_ncq) 3183 dev->flags |= ATA_DFLAG_DUBIOUS_XFER; 3184 } 3185 3186 return rc; 3187 } 3188 3189 /** 3190 * atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset 3191 * @dev: ATAPI device to clear UA for 3192 * 3193 * Resets and other operations can make an ATAPI device raise 3194 * UNIT ATTENTION which causes the next operation to fail. This 3195 * function clears UA. 3196 * 3197 * LOCKING: 3198 * EH context (may sleep). 3199 * 3200 * RETURNS: 3201 * 0 on success, -errno on failure. 3202 */ 3203 static int atapi_eh_clear_ua(struct ata_device *dev) 3204 { 3205 int i; 3206 3207 for (i = 0; i < ATA_EH_UA_TRIES; i++) { 3208 u8 *sense_buffer = dev->link->ap->sector_buf; 3209 u8 sense_key = 0; 3210 unsigned int err_mask; 3211 3212 err_mask = atapi_eh_tur(dev, &sense_key); 3213 if (err_mask != 0 && err_mask != AC_ERR_DEV) { 3214 ata_dev_warn(dev, 3215 "TEST_UNIT_READY failed (err_mask=0x%x)\n", 3216 err_mask); 3217 return -EIO; 3218 } 3219 3220 if (!err_mask || sense_key != UNIT_ATTENTION) 3221 return 0; 3222 3223 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key); 3224 if (err_mask) { 3225 ata_dev_warn(dev, "failed to clear " 3226 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask); 3227 return -EIO; 3228 } 3229 } 3230 3231 ata_dev_warn(dev, "UNIT ATTENTION persists after %d tries\n", 3232 ATA_EH_UA_TRIES); 3233 3234 return 0; 3235 } 3236 3237 /** 3238 * ata_eh_maybe_retry_flush - Retry FLUSH if necessary 3239 * @dev: ATA device which may need FLUSH retry 3240 * 3241 * If @dev failed FLUSH, it needs to be reported upper layer 3242 * immediately as it means that @dev failed to remap and already 3243 * lost at least a sector and further FLUSH retrials won't make 3244 * any difference to the lost sector. However, if FLUSH failed 3245 * for other reasons, for example transmission error, FLUSH needs 3246 * to be retried. 3247 * 3248 * This function determines whether FLUSH failure retry is 3249 * necessary and performs it if so. 3250 * 3251 * RETURNS: 3252 * 0 if EH can continue, -errno if EH needs to be repeated. 3253 */ 3254 static int ata_eh_maybe_retry_flush(struct ata_device *dev) 3255 { 3256 struct ata_link *link = dev->link; 3257 struct ata_port *ap = link->ap; 3258 struct ata_queued_cmd *qc; 3259 struct ata_taskfile tf; 3260 unsigned int err_mask; 3261 int rc = 0; 3262 3263 /* did flush fail for this device? */ 3264 if (!ata_tag_valid(link->active_tag)) 3265 return 0; 3266 3267 qc = __ata_qc_from_tag(ap, link->active_tag); 3268 if (qc->dev != dev || (qc->tf.command != ATA_CMD_FLUSH_EXT && 3269 qc->tf.command != ATA_CMD_FLUSH)) 3270 return 0; 3271 3272 /* if the device failed it, it should be reported to upper layers */ 3273 if (qc->err_mask & AC_ERR_DEV) 3274 return 0; 3275 3276 /* flush failed for some other reason, give it another shot */ 3277 ata_tf_init(dev, &tf); 3278 3279 tf.command = qc->tf.command; 3280 tf.flags |= ATA_TFLAG_DEVICE; 3281 tf.protocol = ATA_PROT_NODATA; 3282 3283 ata_dev_warn(dev, "retrying FLUSH 0x%x Emask 0x%x\n", 3284 tf.command, qc->err_mask); 3285 3286 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 3287 if (!err_mask) { 3288 /* 3289 * FLUSH is complete but there's no way to 3290 * successfully complete a failed command from EH. 3291 * Making sure retry is allowed at least once and 3292 * retrying it should do the trick - whatever was in 3293 * the cache is already on the platter and this won't 3294 * cause infinite loop. 3295 */ 3296 qc->scsicmd->allowed = max(qc->scsicmd->allowed, 1); 3297 } else { 3298 ata_dev_warn(dev, "FLUSH failed Emask 0x%x\n", 3299 err_mask); 3300 rc = -EIO; 3301 3302 /* if device failed it, report it to upper layers */ 3303 if (err_mask & AC_ERR_DEV) { 3304 qc->err_mask |= AC_ERR_DEV; 3305 qc->result_tf = tf; 3306 if (!(ap->pflags & ATA_PFLAG_FROZEN)) 3307 rc = 0; 3308 } 3309 } 3310 return rc; 3311 } 3312 3313 /** 3314 * ata_eh_set_lpm - configure SATA interface power management 3315 * @link: link to configure power management 3316 * @policy: the link power management policy 3317 * @r_failed_dev: out parameter for failed device 3318 * 3319 * Enable SATA Interface power management. This will enable 3320 * Device Interface Power Management (DIPM) for min_power 3321 * policy, and then call driver specific callbacks for 3322 * enabling Host Initiated Power management. 3323 * 3324 * LOCKING: 3325 * EH context. 3326 * 3327 * RETURNS: 3328 * 0 on success, -errno on failure. 3329 */ 3330 static int ata_eh_set_lpm(struct ata_link *link, enum ata_lpm_policy policy, 3331 struct ata_device **r_failed_dev) 3332 { 3333 struct ata_port *ap = ata_is_host_link(link) ? link->ap : NULL; 3334 struct ata_eh_context *ehc = &link->eh_context; 3335 struct ata_device *dev, *link_dev = NULL, *lpm_dev = NULL; 3336 enum ata_lpm_policy old_policy = link->lpm_policy; 3337 bool no_dipm = link->ap->flags & ATA_FLAG_NO_DIPM; 3338 unsigned int hints = ATA_LPM_EMPTY | ATA_LPM_HIPM; 3339 unsigned int err_mask; 3340 int rc; 3341 3342 /* if the link or host doesn't do LPM, noop */ 3343 if ((link->flags & ATA_LFLAG_NO_LPM) || (ap && !ap->ops->set_lpm)) 3344 return 0; 3345 3346 /* 3347 * DIPM is enabled only for MIN_POWER as some devices 3348 * misbehave when the host NACKs transition to SLUMBER. Order 3349 * device and link configurations such that the host always 3350 * allows DIPM requests. 3351 */ 3352 ata_for_each_dev(dev, link, ENABLED) { 3353 bool hipm = ata_id_has_hipm(dev->id); 3354 bool dipm = ata_id_has_dipm(dev->id) && !no_dipm; 3355 3356 /* find the first enabled and LPM enabled devices */ 3357 if (!link_dev) 3358 link_dev = dev; 3359 3360 if (!lpm_dev && (hipm || dipm)) 3361 lpm_dev = dev; 3362 3363 hints &= ~ATA_LPM_EMPTY; 3364 if (!hipm) 3365 hints &= ~ATA_LPM_HIPM; 3366 3367 /* disable DIPM before changing link config */ 3368 if (policy != ATA_LPM_MIN_POWER && dipm) { 3369 err_mask = ata_dev_set_feature(dev, 3370 SETFEATURES_SATA_DISABLE, SATA_DIPM); 3371 if (err_mask && err_mask != AC_ERR_DEV) { 3372 ata_dev_warn(dev, 3373 "failed to disable DIPM, Emask 0x%x\n", 3374 err_mask); 3375 rc = -EIO; 3376 goto fail; 3377 } 3378 } 3379 } 3380 3381 if (ap) { 3382 rc = ap->ops->set_lpm(link, policy, hints); 3383 if (!rc && ap->slave_link) 3384 rc = ap->ops->set_lpm(ap->slave_link, policy, hints); 3385 } else 3386 rc = sata_pmp_set_lpm(link, policy, hints); 3387 3388 /* 3389 * Attribute link config failure to the first (LPM) enabled 3390 * device on the link. 3391 */ 3392 if (rc) { 3393 if (rc == -EOPNOTSUPP) { 3394 link->flags |= ATA_LFLAG_NO_LPM; 3395 return 0; 3396 } 3397 dev = lpm_dev ? lpm_dev : link_dev; 3398 goto fail; 3399 } 3400 3401 /* 3402 * Low level driver acked the transition. Issue DIPM command 3403 * with the new policy set. 3404 */ 3405 link->lpm_policy = policy; 3406 if (ap && ap->slave_link) 3407 ap->slave_link->lpm_policy = policy; 3408 3409 /* host config updated, enable DIPM if transitioning to MIN_POWER */ 3410 ata_for_each_dev(dev, link, ENABLED) { 3411 if (policy == ATA_LPM_MIN_POWER && !no_dipm && 3412 ata_id_has_dipm(dev->id)) { 3413 err_mask = ata_dev_set_feature(dev, 3414 SETFEATURES_SATA_ENABLE, SATA_DIPM); 3415 if (err_mask && err_mask != AC_ERR_DEV) { 3416 ata_dev_warn(dev, 3417 "failed to enable DIPM, Emask 0x%x\n", 3418 err_mask); 3419 rc = -EIO; 3420 goto fail; 3421 } 3422 } 3423 } 3424 3425 return 0; 3426 3427 fail: 3428 /* restore the old policy */ 3429 link->lpm_policy = old_policy; 3430 if (ap && ap->slave_link) 3431 ap->slave_link->lpm_policy = old_policy; 3432 3433 /* if no device or only one more chance is left, disable LPM */ 3434 if (!dev || ehc->tries[dev->devno] <= 2) { 3435 ata_link_warn(link, "disabling LPM on the link\n"); 3436 link->flags |= ATA_LFLAG_NO_LPM; 3437 } 3438 if (r_failed_dev) 3439 *r_failed_dev = dev; 3440 return rc; 3441 } 3442 3443 int ata_link_nr_enabled(struct ata_link *link) 3444 { 3445 struct ata_device *dev; 3446 int cnt = 0; 3447 3448 ata_for_each_dev(dev, link, ENABLED) 3449 cnt++; 3450 return cnt; 3451 } 3452 3453 static int ata_link_nr_vacant(struct ata_link *link) 3454 { 3455 struct ata_device *dev; 3456 int cnt = 0; 3457 3458 ata_for_each_dev(dev, link, ALL) 3459 if (dev->class == ATA_DEV_UNKNOWN) 3460 cnt++; 3461 return cnt; 3462 } 3463 3464 static int ata_eh_skip_recovery(struct ata_link *link) 3465 { 3466 struct ata_port *ap = link->ap; 3467 struct ata_eh_context *ehc = &link->eh_context; 3468 struct ata_device *dev; 3469 3470 /* skip disabled links */ 3471 if (link->flags & ATA_LFLAG_DISABLED) 3472 return 1; 3473 3474 /* skip if explicitly requested */ 3475 if (ehc->i.flags & ATA_EHI_NO_RECOVERY) 3476 return 1; 3477 3478 /* thaw frozen port and recover failed devices */ 3479 if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link)) 3480 return 0; 3481 3482 /* reset at least once if reset is requested */ 3483 if ((ehc->i.action & ATA_EH_RESET) && 3484 !(ehc->i.flags & ATA_EHI_DID_RESET)) 3485 return 0; 3486 3487 /* skip if class codes for all vacant slots are ATA_DEV_NONE */ 3488 ata_for_each_dev(dev, link, ALL) { 3489 if (dev->class == ATA_DEV_UNKNOWN && 3490 ehc->classes[dev->devno] != ATA_DEV_NONE) 3491 return 0; 3492 } 3493 3494 return 1; 3495 } 3496 3497 static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg) 3498 { 3499 u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL); 3500 u64 now = get_jiffies_64(); 3501 int *trials = void_arg; 3502 3503 if (ent->timestamp < now - min(now, interval)) 3504 return -1; 3505 3506 (*trials)++; 3507 return 0; 3508 } 3509 3510 static int ata_eh_schedule_probe(struct ata_device *dev) 3511 { 3512 struct ata_eh_context *ehc = &dev->link->eh_context; 3513 struct ata_link *link = ata_dev_phys_link(dev); 3514 int trials = 0; 3515 3516 if (!(ehc->i.probe_mask & (1 << dev->devno)) || 3517 (ehc->did_probe_mask & (1 << dev->devno))) 3518 return 0; 3519 3520 ata_eh_detach_dev(dev); 3521 ata_dev_init(dev); 3522 ehc->did_probe_mask |= (1 << dev->devno); 3523 ehc->i.action |= ATA_EH_RESET; 3524 ehc->saved_xfer_mode[dev->devno] = 0; 3525 ehc->saved_ncq_enabled &= ~(1 << dev->devno); 3526 3527 /* the link maybe in a deep sleep, wake it up */ 3528 if (link->lpm_policy > ATA_LPM_MAX_POWER) { 3529 if (ata_is_host_link(link)) 3530 link->ap->ops->set_lpm(link, ATA_LPM_MAX_POWER, 3531 ATA_LPM_EMPTY); 3532 else 3533 sata_pmp_set_lpm(link, ATA_LPM_MAX_POWER, 3534 ATA_LPM_EMPTY); 3535 } 3536 3537 /* Record and count probe trials on the ering. The specific 3538 * error mask used is irrelevant. Because a successful device 3539 * detection clears the ering, this count accumulates only if 3540 * there are consecutive failed probes. 3541 * 3542 * If the count is equal to or higher than ATA_EH_PROBE_TRIALS 3543 * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is 3544 * forced to 1.5Gbps. 3545 * 3546 * This is to work around cases where failed link speed 3547 * negotiation results in device misdetection leading to 3548 * infinite DEVXCHG or PHRDY CHG events. 3549 */ 3550 ata_ering_record(&dev->ering, 0, AC_ERR_OTHER); 3551 ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials); 3552 3553 if (trials > ATA_EH_PROBE_TRIALS) 3554 sata_down_spd_limit(link, 1); 3555 3556 return 1; 3557 } 3558 3559 static int ata_eh_handle_dev_fail(struct ata_device *dev, int err) 3560 { 3561 struct ata_eh_context *ehc = &dev->link->eh_context; 3562 3563 /* -EAGAIN from EH routine indicates retry without prejudice. 3564 * The requester is responsible for ensuring forward progress. 3565 */ 3566 if (err != -EAGAIN) 3567 ehc->tries[dev->devno]--; 3568 3569 switch (err) { 3570 case -ENODEV: 3571 /* device missing or wrong IDENTIFY data, schedule probing */ 3572 ehc->i.probe_mask |= (1 << dev->devno); 3573 case -EINVAL: 3574 /* give it just one more chance */ 3575 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1); 3576 case -EIO: 3577 if (ehc->tries[dev->devno] == 1) { 3578 /* This is the last chance, better to slow 3579 * down than lose it. 3580 */ 3581 sata_down_spd_limit(ata_dev_phys_link(dev), 0); 3582 if (dev->pio_mode > XFER_PIO_0) 3583 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO); 3584 } 3585 } 3586 3587 if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) { 3588 /* disable device if it has used up all its chances */ 3589 ata_dev_disable(dev); 3590 3591 /* detach if offline */ 3592 if (ata_phys_link_offline(ata_dev_phys_link(dev))) 3593 ata_eh_detach_dev(dev); 3594 3595 /* schedule probe if necessary */ 3596 if (ata_eh_schedule_probe(dev)) { 3597 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES; 3598 memset(ehc->cmd_timeout_idx[dev->devno], 0, 3599 sizeof(ehc->cmd_timeout_idx[dev->devno])); 3600 } 3601 3602 return 1; 3603 } else { 3604 ehc->i.action |= ATA_EH_RESET; 3605 return 0; 3606 } 3607 } 3608 3609 /** 3610 * ata_eh_recover - recover host port after error 3611 * @ap: host port to recover 3612 * @prereset: prereset method (can be NULL) 3613 * @softreset: softreset method (can be NULL) 3614 * @hardreset: hardreset method (can be NULL) 3615 * @postreset: postreset method (can be NULL) 3616 * @r_failed_link: out parameter for failed link 3617 * 3618 * This is the alpha and omega, eum and yang, heart and soul of 3619 * libata exception handling. On entry, actions required to 3620 * recover each link and hotplug requests are recorded in the 3621 * link's eh_context. This function executes all the operations 3622 * with appropriate retrials and fallbacks to resurrect failed 3623 * devices, detach goners and greet newcomers. 3624 * 3625 * LOCKING: 3626 * Kernel thread context (may sleep). 3627 * 3628 * RETURNS: 3629 * 0 on success, -errno on failure. 3630 */ 3631 int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset, 3632 ata_reset_fn_t softreset, ata_reset_fn_t hardreset, 3633 ata_postreset_fn_t postreset, 3634 struct ata_link **r_failed_link) 3635 { 3636 struct ata_link *link; 3637 struct ata_device *dev; 3638 int rc, nr_fails; 3639 unsigned long flags, deadline; 3640 3641 DPRINTK("ENTER\n"); 3642 3643 /* prep for recovery */ 3644 ata_for_each_link(link, ap, EDGE) { 3645 struct ata_eh_context *ehc = &link->eh_context; 3646 3647 /* re-enable link? */ 3648 if (ehc->i.action & ATA_EH_ENABLE_LINK) { 3649 ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK); 3650 spin_lock_irqsave(ap->lock, flags); 3651 link->flags &= ~ATA_LFLAG_DISABLED; 3652 spin_unlock_irqrestore(ap->lock, flags); 3653 ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK); 3654 } 3655 3656 ata_for_each_dev(dev, link, ALL) { 3657 if (link->flags & ATA_LFLAG_NO_RETRY) 3658 ehc->tries[dev->devno] = 1; 3659 else 3660 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES; 3661 3662 /* collect port action mask recorded in dev actions */ 3663 ehc->i.action |= ehc->i.dev_action[dev->devno] & 3664 ~ATA_EH_PERDEV_MASK; 3665 ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK; 3666 3667 /* process hotplug request */ 3668 if (dev->flags & ATA_DFLAG_DETACH) 3669 ata_eh_detach_dev(dev); 3670 3671 /* schedule probe if necessary */ 3672 if (!ata_dev_enabled(dev)) 3673 ata_eh_schedule_probe(dev); 3674 } 3675 } 3676 3677 retry: 3678 rc = 0; 3679 3680 /* if UNLOADING, finish immediately */ 3681 if (ap->pflags & ATA_PFLAG_UNLOADING) 3682 goto out; 3683 3684 /* prep for EH */ 3685 ata_for_each_link(link, ap, EDGE) { 3686 struct ata_eh_context *ehc = &link->eh_context; 3687 3688 /* skip EH if possible. */ 3689 if (ata_eh_skip_recovery(link)) 3690 ehc->i.action = 0; 3691 3692 ata_for_each_dev(dev, link, ALL) 3693 ehc->classes[dev->devno] = ATA_DEV_UNKNOWN; 3694 } 3695 3696 /* reset */ 3697 ata_for_each_link(link, ap, EDGE) { 3698 struct ata_eh_context *ehc = &link->eh_context; 3699 3700 if (!(ehc->i.action & ATA_EH_RESET)) 3701 continue; 3702 3703 rc = ata_eh_reset(link, ata_link_nr_vacant(link), 3704 prereset, softreset, hardreset, postreset); 3705 if (rc) { 3706 ata_link_err(link, "reset failed, giving up\n"); 3707 goto out; 3708 } 3709 } 3710 3711 do { 3712 unsigned long now; 3713 3714 /* 3715 * clears ATA_EH_PARK in eh_info and resets 3716 * ap->park_req_pending 3717 */ 3718 ata_eh_pull_park_action(ap); 3719 3720 deadline = jiffies; 3721 ata_for_each_link(link, ap, EDGE) { 3722 ata_for_each_dev(dev, link, ALL) { 3723 struct ata_eh_context *ehc = &link->eh_context; 3724 unsigned long tmp; 3725 3726 if (dev->class != ATA_DEV_ATA) 3727 continue; 3728 if (!(ehc->i.dev_action[dev->devno] & 3729 ATA_EH_PARK)) 3730 continue; 3731 tmp = dev->unpark_deadline; 3732 if (time_before(deadline, tmp)) 3733 deadline = tmp; 3734 else if (time_before_eq(tmp, jiffies)) 3735 continue; 3736 if (ehc->unloaded_mask & (1 << dev->devno)) 3737 continue; 3738 3739 ata_eh_park_issue_cmd(dev, 1); 3740 } 3741 } 3742 3743 now = jiffies; 3744 if (time_before_eq(deadline, now)) 3745 break; 3746 3747 ata_eh_release(ap); 3748 deadline = wait_for_completion_timeout(&ap->park_req_pending, 3749 deadline - now); 3750 ata_eh_acquire(ap); 3751 } while (deadline); 3752 ata_for_each_link(link, ap, EDGE) { 3753 ata_for_each_dev(dev, link, ALL) { 3754 if (!(link->eh_context.unloaded_mask & 3755 (1 << dev->devno))) 3756 continue; 3757 3758 ata_eh_park_issue_cmd(dev, 0); 3759 ata_eh_done(link, dev, ATA_EH_PARK); 3760 } 3761 } 3762 3763 /* the rest */ 3764 nr_fails = 0; 3765 ata_for_each_link(link, ap, PMP_FIRST) { 3766 struct ata_eh_context *ehc = &link->eh_context; 3767 3768 if (sata_pmp_attached(ap) && ata_is_host_link(link)) 3769 goto config_lpm; 3770 3771 /* revalidate existing devices and attach new ones */ 3772 rc = ata_eh_revalidate_and_attach(link, &dev); 3773 if (rc) 3774 goto rest_fail; 3775 3776 /* if PMP got attached, return, pmp EH will take care of it */ 3777 if (link->device->class == ATA_DEV_PMP) { 3778 ehc->i.action = 0; 3779 return 0; 3780 } 3781 3782 /* configure transfer mode if necessary */ 3783 if (ehc->i.flags & ATA_EHI_SETMODE) { 3784 rc = ata_set_mode(link, &dev); 3785 if (rc) 3786 goto rest_fail; 3787 ehc->i.flags &= ~ATA_EHI_SETMODE; 3788 } 3789 3790 /* If reset has been issued, clear UA to avoid 3791 * disrupting the current users of the device. 3792 */ 3793 if (ehc->i.flags & ATA_EHI_DID_RESET) { 3794 ata_for_each_dev(dev, link, ALL) { 3795 if (dev->class != ATA_DEV_ATAPI) 3796 continue; 3797 rc = atapi_eh_clear_ua(dev); 3798 if (rc) 3799 goto rest_fail; 3800 } 3801 } 3802 3803 /* retry flush if necessary */ 3804 ata_for_each_dev(dev, link, ALL) { 3805 if (dev->class != ATA_DEV_ATA) 3806 continue; 3807 rc = ata_eh_maybe_retry_flush(dev); 3808 if (rc) 3809 goto rest_fail; 3810 } 3811 3812 config_lpm: 3813 /* configure link power saving */ 3814 if (link->lpm_policy != ap->target_lpm_policy) { 3815 rc = ata_eh_set_lpm(link, ap->target_lpm_policy, &dev); 3816 if (rc) 3817 goto rest_fail; 3818 } 3819 3820 /* this link is okay now */ 3821 ehc->i.flags = 0; 3822 continue; 3823 3824 rest_fail: 3825 nr_fails++; 3826 if (dev) 3827 ata_eh_handle_dev_fail(dev, rc); 3828 3829 if (ap->pflags & ATA_PFLAG_FROZEN) { 3830 /* PMP reset requires working host port. 3831 * Can't retry if it's frozen. 3832 */ 3833 if (sata_pmp_attached(ap)) 3834 goto out; 3835 break; 3836 } 3837 } 3838 3839 if (nr_fails) 3840 goto retry; 3841 3842 out: 3843 if (rc && r_failed_link) 3844 *r_failed_link = link; 3845 3846 DPRINTK("EXIT, rc=%d\n", rc); 3847 return rc; 3848 } 3849 3850 /** 3851 * ata_eh_finish - finish up EH 3852 * @ap: host port to finish EH for 3853 * 3854 * Recovery is complete. Clean up EH states and retry or finish 3855 * failed qcs. 3856 * 3857 * LOCKING: 3858 * None. 3859 */ 3860 void ata_eh_finish(struct ata_port *ap) 3861 { 3862 int tag; 3863 3864 /* retry or finish qcs */ 3865 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { 3866 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); 3867 3868 if (!(qc->flags & ATA_QCFLAG_FAILED)) 3869 continue; 3870 3871 if (qc->err_mask) { 3872 /* FIXME: Once EH migration is complete, 3873 * generate sense data in this function, 3874 * considering both err_mask and tf. 3875 */ 3876 if (qc->flags & ATA_QCFLAG_RETRY) 3877 ata_eh_qc_retry(qc); 3878 else 3879 ata_eh_qc_complete(qc); 3880 } else { 3881 if (qc->flags & ATA_QCFLAG_SENSE_VALID) { 3882 ata_eh_qc_complete(qc); 3883 } else { 3884 /* feed zero TF to sense generation */ 3885 memset(&qc->result_tf, 0, sizeof(qc->result_tf)); 3886 ata_eh_qc_retry(qc); 3887 } 3888 } 3889 } 3890 3891 /* make sure nr_active_links is zero after EH */ 3892 WARN_ON(ap->nr_active_links); 3893 ap->nr_active_links = 0; 3894 } 3895 3896 /** 3897 * ata_do_eh - do standard error handling 3898 * @ap: host port to handle error for 3899 * 3900 * @prereset: prereset method (can be NULL) 3901 * @softreset: softreset method (can be NULL) 3902 * @hardreset: hardreset method (can be NULL) 3903 * @postreset: postreset method (can be NULL) 3904 * 3905 * Perform standard error handling sequence. 3906 * 3907 * LOCKING: 3908 * Kernel thread context (may sleep). 3909 */ 3910 void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset, 3911 ata_reset_fn_t softreset, ata_reset_fn_t hardreset, 3912 ata_postreset_fn_t postreset) 3913 { 3914 struct ata_device *dev; 3915 int rc; 3916 3917 ata_eh_autopsy(ap); 3918 ata_eh_report(ap); 3919 3920 rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset, 3921 NULL); 3922 if (rc) { 3923 ata_for_each_dev(dev, &ap->link, ALL) 3924 ata_dev_disable(dev); 3925 } 3926 3927 ata_eh_finish(ap); 3928 } 3929 3930 /** 3931 * ata_std_error_handler - standard error handler 3932 * @ap: host port to handle error for 3933 * 3934 * Standard error handler 3935 * 3936 * LOCKING: 3937 * Kernel thread context (may sleep). 3938 */ 3939 void ata_std_error_handler(struct ata_port *ap) 3940 { 3941 struct ata_port_operations *ops = ap->ops; 3942 ata_reset_fn_t hardreset = ops->hardreset; 3943 3944 /* ignore built-in hardreset if SCR access is not available */ 3945 if (hardreset == sata_std_hardreset && !sata_scr_valid(&ap->link)) 3946 hardreset = NULL; 3947 3948 ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset); 3949 } 3950 3951 #ifdef CONFIG_PM 3952 /** 3953 * ata_eh_handle_port_suspend - perform port suspend operation 3954 * @ap: port to suspend 3955 * 3956 * Suspend @ap. 3957 * 3958 * LOCKING: 3959 * Kernel thread context (may sleep). 3960 */ 3961 static void ata_eh_handle_port_suspend(struct ata_port *ap) 3962 { 3963 unsigned long flags; 3964 int rc = 0; 3965 3966 /* are we suspending? */ 3967 spin_lock_irqsave(ap->lock, flags); 3968 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) || 3969 ap->pm_mesg.event == PM_EVENT_ON) { 3970 spin_unlock_irqrestore(ap->lock, flags); 3971 return; 3972 } 3973 spin_unlock_irqrestore(ap->lock, flags); 3974 3975 WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED); 3976 3977 /* tell ACPI we're suspending */ 3978 rc = ata_acpi_on_suspend(ap); 3979 if (rc) 3980 goto out; 3981 3982 /* suspend */ 3983 ata_eh_freeze_port(ap); 3984 3985 if (ap->ops->port_suspend) 3986 rc = ap->ops->port_suspend(ap, ap->pm_mesg); 3987 3988 ata_acpi_set_state(ap, PMSG_SUSPEND); 3989 out: 3990 /* report result */ 3991 spin_lock_irqsave(ap->lock, flags); 3992 3993 ap->pflags &= ~ATA_PFLAG_PM_PENDING; 3994 if (rc == 0) 3995 ap->pflags |= ATA_PFLAG_SUSPENDED; 3996 else if (ap->pflags & ATA_PFLAG_FROZEN) 3997 ata_port_schedule_eh(ap); 3998 3999 if (ap->pm_result) { 4000 *ap->pm_result = rc; 4001 ap->pm_result = NULL; 4002 } 4003 4004 spin_unlock_irqrestore(ap->lock, flags); 4005 4006 return; 4007 } 4008 4009 /** 4010 * ata_eh_handle_port_resume - perform port resume operation 4011 * @ap: port to resume 4012 * 4013 * Resume @ap. 4014 * 4015 * LOCKING: 4016 * Kernel thread context (may sleep). 4017 */ 4018 static void ata_eh_handle_port_resume(struct ata_port *ap) 4019 { 4020 struct ata_link *link; 4021 struct ata_device *dev; 4022 unsigned long flags; 4023 int rc = 0; 4024 4025 /* are we resuming? */ 4026 spin_lock_irqsave(ap->lock, flags); 4027 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) || 4028 ap->pm_mesg.event != PM_EVENT_ON) { 4029 spin_unlock_irqrestore(ap->lock, flags); 4030 return; 4031 } 4032 spin_unlock_irqrestore(ap->lock, flags); 4033 4034 WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED)); 4035 4036 /* 4037 * Error timestamps are in jiffies which doesn't run while 4038 * suspended and PHY events during resume isn't too uncommon. 4039 * When the two are combined, it can lead to unnecessary speed 4040 * downs if the machine is suspended and resumed repeatedly. 4041 * Clear error history. 4042 */ 4043 ata_for_each_link(link, ap, HOST_FIRST) 4044 ata_for_each_dev(dev, link, ALL) 4045 ata_ering_clear(&dev->ering); 4046 4047 ata_acpi_set_state(ap, PMSG_ON); 4048 4049 if (ap->ops->port_resume) 4050 rc = ap->ops->port_resume(ap); 4051 4052 /* tell ACPI that we're resuming */ 4053 ata_acpi_on_resume(ap); 4054 4055 /* report result */ 4056 spin_lock_irqsave(ap->lock, flags); 4057 ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED); 4058 if (ap->pm_result) { 4059 *ap->pm_result = rc; 4060 ap->pm_result = NULL; 4061 } 4062 spin_unlock_irqrestore(ap->lock, flags); 4063 } 4064 #endif /* CONFIG_PM */ 4065