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