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