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 if (!ata_dev_enabled(dev)) 607 continue; 608 609 ehc->saved_xfer_mode[devno] = dev->xfer_mode; 610 if (ata_ncq_enabled(dev)) 611 ehc->saved_ncq_enabled |= 1 << devno; 612 } 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 struct ata_eh_context *ehc = &link->eh_context; 1165 unsigned long flags; 1166 1167 ata_dev_disable(dev); 1168 1169 spin_lock_irqsave(ap->lock, flags); 1170 1171 dev->flags &= ~ATA_DFLAG_DETACH; 1172 1173 if (ata_scsi_offline_dev(dev)) { 1174 dev->flags |= ATA_DFLAG_DETACHED; 1175 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG; 1176 } 1177 1178 /* clear per-dev EH info */ 1179 ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK); 1180 ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK); 1181 ehc->saved_xfer_mode[dev->devno] = 0; 1182 ehc->saved_ncq_enabled &= ~(1 << dev->devno); 1183 1184 spin_unlock_irqrestore(ap->lock, flags); 1185 } 1186 1187 /** 1188 * ata_eh_about_to_do - about to perform eh_action 1189 * @link: target ATA link 1190 * @dev: target ATA dev for per-dev action (can be NULL) 1191 * @action: action about to be performed 1192 * 1193 * Called just before performing EH actions to clear related bits 1194 * in @link->eh_info such that eh actions are not unnecessarily 1195 * repeated. 1196 * 1197 * LOCKING: 1198 * None. 1199 */ 1200 void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev, 1201 unsigned int action) 1202 { 1203 struct ata_port *ap = link->ap; 1204 struct ata_eh_info *ehi = &link->eh_info; 1205 struct ata_eh_context *ehc = &link->eh_context; 1206 unsigned long flags; 1207 1208 spin_lock_irqsave(ap->lock, flags); 1209 1210 ata_eh_clear_action(link, dev, ehi, action); 1211 1212 /* About to take EH action, set RECOVERED. Ignore actions on 1213 * slave links as master will do them again. 1214 */ 1215 if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link) 1216 ap->pflags |= ATA_PFLAG_RECOVERED; 1217 1218 spin_unlock_irqrestore(ap->lock, flags); 1219 } 1220 1221 /** 1222 * ata_eh_done - EH action complete 1223 * @ap: target ATA port 1224 * @dev: target ATA dev for per-dev action (can be NULL) 1225 * @action: action just completed 1226 * 1227 * Called right after performing EH actions to clear related bits 1228 * in @link->eh_context. 1229 * 1230 * LOCKING: 1231 * None. 1232 */ 1233 void ata_eh_done(struct ata_link *link, struct ata_device *dev, 1234 unsigned int action) 1235 { 1236 struct ata_eh_context *ehc = &link->eh_context; 1237 1238 ata_eh_clear_action(link, dev, &ehc->i, action); 1239 } 1240 1241 /** 1242 * ata_err_string - convert err_mask to descriptive string 1243 * @err_mask: error mask to convert to string 1244 * 1245 * Convert @err_mask to descriptive string. Errors are 1246 * prioritized according to severity and only the most severe 1247 * error is reported. 1248 * 1249 * LOCKING: 1250 * None. 1251 * 1252 * RETURNS: 1253 * Descriptive string for @err_mask 1254 */ 1255 static const char *ata_err_string(unsigned int err_mask) 1256 { 1257 if (err_mask & AC_ERR_HOST_BUS) 1258 return "host bus error"; 1259 if (err_mask & AC_ERR_ATA_BUS) 1260 return "ATA bus error"; 1261 if (err_mask & AC_ERR_TIMEOUT) 1262 return "timeout"; 1263 if (err_mask & AC_ERR_HSM) 1264 return "HSM violation"; 1265 if (err_mask & AC_ERR_SYSTEM) 1266 return "internal error"; 1267 if (err_mask & AC_ERR_MEDIA) 1268 return "media error"; 1269 if (err_mask & AC_ERR_INVALID) 1270 return "invalid argument"; 1271 if (err_mask & AC_ERR_DEV) 1272 return "device error"; 1273 return "unknown error"; 1274 } 1275 1276 /** 1277 * ata_read_log_page - read a specific log page 1278 * @dev: target device 1279 * @page: page to read 1280 * @buf: buffer to store read page 1281 * @sectors: number of sectors to read 1282 * 1283 * Read log page using READ_LOG_EXT command. 1284 * 1285 * LOCKING: 1286 * Kernel thread context (may sleep). 1287 * 1288 * RETURNS: 1289 * 0 on success, AC_ERR_* mask otherwise. 1290 */ 1291 static unsigned int ata_read_log_page(struct ata_device *dev, 1292 u8 page, void *buf, unsigned int sectors) 1293 { 1294 struct ata_taskfile tf; 1295 unsigned int err_mask; 1296 1297 DPRINTK("read log page - page %d\n", page); 1298 1299 ata_tf_init(dev, &tf); 1300 tf.command = ATA_CMD_READ_LOG_EXT; 1301 tf.lbal = page; 1302 tf.nsect = sectors; 1303 tf.hob_nsect = sectors >> 8; 1304 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE; 1305 tf.protocol = ATA_PROT_PIO; 1306 1307 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE, 1308 buf, sectors * ATA_SECT_SIZE, 0); 1309 1310 DPRINTK("EXIT, err_mask=%x\n", err_mask); 1311 return err_mask; 1312 } 1313 1314 /** 1315 * ata_eh_read_log_10h - Read log page 10h for NCQ error details 1316 * @dev: Device to read log page 10h from 1317 * @tag: Resulting tag of the failed command 1318 * @tf: Resulting taskfile registers of the failed command 1319 * 1320 * Read log page 10h to obtain NCQ error details and clear error 1321 * condition. 1322 * 1323 * LOCKING: 1324 * Kernel thread context (may sleep). 1325 * 1326 * RETURNS: 1327 * 0 on success, -errno otherwise. 1328 */ 1329 static int ata_eh_read_log_10h(struct ata_device *dev, 1330 int *tag, struct ata_taskfile *tf) 1331 { 1332 u8 *buf = dev->link->ap->sector_buf; 1333 unsigned int err_mask; 1334 u8 csum; 1335 int i; 1336 1337 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1); 1338 if (err_mask) 1339 return -EIO; 1340 1341 csum = 0; 1342 for (i = 0; i < ATA_SECT_SIZE; i++) 1343 csum += buf[i]; 1344 if (csum) 1345 ata_dev_printk(dev, KERN_WARNING, 1346 "invalid checksum 0x%x on log page 10h\n", csum); 1347 1348 if (buf[0] & 0x80) 1349 return -ENOENT; 1350 1351 *tag = buf[0] & 0x1f; 1352 1353 tf->command = buf[2]; 1354 tf->feature = buf[3]; 1355 tf->lbal = buf[4]; 1356 tf->lbam = buf[5]; 1357 tf->lbah = buf[6]; 1358 tf->device = buf[7]; 1359 tf->hob_lbal = buf[8]; 1360 tf->hob_lbam = buf[9]; 1361 tf->hob_lbah = buf[10]; 1362 tf->nsect = buf[12]; 1363 tf->hob_nsect = buf[13]; 1364 1365 return 0; 1366 } 1367 1368 /** 1369 * atapi_eh_tur - perform ATAPI TEST_UNIT_READY 1370 * @dev: target ATAPI device 1371 * @r_sense_key: out parameter for sense_key 1372 * 1373 * Perform ATAPI TEST_UNIT_READY. 1374 * 1375 * LOCKING: 1376 * EH context (may sleep). 1377 * 1378 * RETURNS: 1379 * 0 on success, AC_ERR_* mask on failure. 1380 */ 1381 static unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key) 1382 { 1383 u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 }; 1384 struct ata_taskfile tf; 1385 unsigned int err_mask; 1386 1387 ata_tf_init(dev, &tf); 1388 1389 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 1390 tf.command = ATA_CMD_PACKET; 1391 tf.protocol = ATAPI_PROT_NODATA; 1392 1393 err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0); 1394 if (err_mask == AC_ERR_DEV) 1395 *r_sense_key = tf.feature >> 4; 1396 return err_mask; 1397 } 1398 1399 /** 1400 * atapi_eh_request_sense - perform ATAPI REQUEST_SENSE 1401 * @dev: device to perform REQUEST_SENSE to 1402 * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long) 1403 * @dfl_sense_key: default sense key to use 1404 * 1405 * Perform ATAPI REQUEST_SENSE after the device reported CHECK 1406 * SENSE. This function is EH helper. 1407 * 1408 * LOCKING: 1409 * Kernel thread context (may sleep). 1410 * 1411 * RETURNS: 1412 * 0 on success, AC_ERR_* mask on failure 1413 */ 1414 static unsigned int atapi_eh_request_sense(struct ata_device *dev, 1415 u8 *sense_buf, u8 dfl_sense_key) 1416 { 1417 u8 cdb[ATAPI_CDB_LEN] = 1418 { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 }; 1419 struct ata_port *ap = dev->link->ap; 1420 struct ata_taskfile tf; 1421 1422 DPRINTK("ATAPI request sense\n"); 1423 1424 /* FIXME: is this needed? */ 1425 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE); 1426 1427 /* initialize sense_buf with the error register, 1428 * for the case where they are -not- overwritten 1429 */ 1430 sense_buf[0] = 0x70; 1431 sense_buf[2] = dfl_sense_key; 1432 1433 /* some devices time out if garbage left in tf */ 1434 ata_tf_init(dev, &tf); 1435 1436 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; 1437 tf.command = ATA_CMD_PACKET; 1438 1439 /* is it pointless to prefer PIO for "safety reasons"? */ 1440 if (ap->flags & ATA_FLAG_PIO_DMA) { 1441 tf.protocol = ATAPI_PROT_DMA; 1442 tf.feature |= ATAPI_PKT_DMA; 1443 } else { 1444 tf.protocol = ATAPI_PROT_PIO; 1445 tf.lbam = SCSI_SENSE_BUFFERSIZE; 1446 tf.lbah = 0; 1447 } 1448 1449 return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE, 1450 sense_buf, SCSI_SENSE_BUFFERSIZE, 0); 1451 } 1452 1453 /** 1454 * ata_eh_analyze_serror - analyze SError for a failed port 1455 * @link: ATA link to analyze SError for 1456 * 1457 * Analyze SError if available and further determine cause of 1458 * failure. 1459 * 1460 * LOCKING: 1461 * None. 1462 */ 1463 static void ata_eh_analyze_serror(struct ata_link *link) 1464 { 1465 struct ata_eh_context *ehc = &link->eh_context; 1466 u32 serror = ehc->i.serror; 1467 unsigned int err_mask = 0, action = 0; 1468 u32 hotplug_mask; 1469 1470 if (serror & (SERR_PERSISTENT | SERR_DATA)) { 1471 err_mask |= AC_ERR_ATA_BUS; 1472 action |= ATA_EH_RESET; 1473 } 1474 if (serror & SERR_PROTOCOL) { 1475 err_mask |= AC_ERR_HSM; 1476 action |= ATA_EH_RESET; 1477 } 1478 if (serror & SERR_INTERNAL) { 1479 err_mask |= AC_ERR_SYSTEM; 1480 action |= ATA_EH_RESET; 1481 } 1482 1483 /* Determine whether a hotplug event has occurred. Both 1484 * SError.N/X are considered hotplug events for enabled or 1485 * host links. For disabled PMP links, only N bit is 1486 * considered as X bit is left at 1 for link plugging. 1487 */ 1488 hotplug_mask = 0; 1489 1490 if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link)) 1491 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG; 1492 else 1493 hotplug_mask = SERR_PHYRDY_CHG; 1494 1495 if (serror & hotplug_mask) 1496 ata_ehi_hotplugged(&ehc->i); 1497 1498 ehc->i.err_mask |= err_mask; 1499 ehc->i.action |= action; 1500 } 1501 1502 /** 1503 * ata_eh_analyze_ncq_error - analyze NCQ error 1504 * @link: ATA link to analyze NCQ error for 1505 * 1506 * Read log page 10h, determine the offending qc and acquire 1507 * error status TF. For NCQ device errors, all LLDDs have to do 1508 * is setting AC_ERR_DEV in ehi->err_mask. This function takes 1509 * care of the rest. 1510 * 1511 * LOCKING: 1512 * Kernel thread context (may sleep). 1513 */ 1514 void ata_eh_analyze_ncq_error(struct ata_link *link) 1515 { 1516 struct ata_port *ap = link->ap; 1517 struct ata_eh_context *ehc = &link->eh_context; 1518 struct ata_device *dev = link->device; 1519 struct ata_queued_cmd *qc; 1520 struct ata_taskfile tf; 1521 int tag, rc; 1522 1523 /* if frozen, we can't do much */ 1524 if (ap->pflags & ATA_PFLAG_FROZEN) 1525 return; 1526 1527 /* is it NCQ device error? */ 1528 if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV)) 1529 return; 1530 1531 /* has LLDD analyzed already? */ 1532 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { 1533 qc = __ata_qc_from_tag(ap, tag); 1534 1535 if (!(qc->flags & ATA_QCFLAG_FAILED)) 1536 continue; 1537 1538 if (qc->err_mask) 1539 return; 1540 } 1541 1542 /* okay, this error is ours */ 1543 rc = ata_eh_read_log_10h(dev, &tag, &tf); 1544 if (rc) { 1545 ata_link_printk(link, KERN_ERR, "failed to read log page 10h " 1546 "(errno=%d)\n", rc); 1547 return; 1548 } 1549 1550 if (!(link->sactive & (1 << tag))) { 1551 ata_link_printk(link, KERN_ERR, "log page 10h reported " 1552 "inactive tag %d\n", tag); 1553 return; 1554 } 1555 1556 /* we've got the perpetrator, condemn it */ 1557 qc = __ata_qc_from_tag(ap, tag); 1558 memcpy(&qc->result_tf, &tf, sizeof(tf)); 1559 qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48; 1560 qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ; 1561 ehc->i.err_mask &= ~AC_ERR_DEV; 1562 } 1563 1564 /** 1565 * ata_eh_analyze_tf - analyze taskfile of a failed qc 1566 * @qc: qc to analyze 1567 * @tf: Taskfile registers to analyze 1568 * 1569 * Analyze taskfile of @qc and further determine cause of 1570 * failure. This function also requests ATAPI sense data if 1571 * avaliable. 1572 * 1573 * LOCKING: 1574 * Kernel thread context (may sleep). 1575 * 1576 * RETURNS: 1577 * Determined recovery action 1578 */ 1579 static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc, 1580 const struct ata_taskfile *tf) 1581 { 1582 unsigned int tmp, action = 0; 1583 u8 stat = tf->command, err = tf->feature; 1584 1585 if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) { 1586 qc->err_mask |= AC_ERR_HSM; 1587 return ATA_EH_RESET; 1588 } 1589 1590 if (stat & (ATA_ERR | ATA_DF)) 1591 qc->err_mask |= AC_ERR_DEV; 1592 else 1593 return 0; 1594 1595 switch (qc->dev->class) { 1596 case ATA_DEV_ATA: 1597 if (err & ATA_ICRC) 1598 qc->err_mask |= AC_ERR_ATA_BUS; 1599 if (err & ATA_UNC) 1600 qc->err_mask |= AC_ERR_MEDIA; 1601 if (err & ATA_IDNF) 1602 qc->err_mask |= AC_ERR_INVALID; 1603 break; 1604 1605 case ATA_DEV_ATAPI: 1606 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) { 1607 tmp = atapi_eh_request_sense(qc->dev, 1608 qc->scsicmd->sense_buffer, 1609 qc->result_tf.feature >> 4); 1610 if (!tmp) { 1611 /* ATA_QCFLAG_SENSE_VALID is used to 1612 * tell atapi_qc_complete() that sense 1613 * data is already valid. 1614 * 1615 * TODO: interpret sense data and set 1616 * appropriate err_mask. 1617 */ 1618 qc->flags |= ATA_QCFLAG_SENSE_VALID; 1619 } else 1620 qc->err_mask |= tmp; 1621 } 1622 } 1623 1624 if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS)) 1625 action |= ATA_EH_RESET; 1626 1627 return action; 1628 } 1629 1630 static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask, 1631 int *xfer_ok) 1632 { 1633 int base = 0; 1634 1635 if (!(eflags & ATA_EFLAG_DUBIOUS_XFER)) 1636 *xfer_ok = 1; 1637 1638 if (!*xfer_ok) 1639 base = ATA_ECAT_DUBIOUS_NONE; 1640 1641 if (err_mask & AC_ERR_ATA_BUS) 1642 return base + ATA_ECAT_ATA_BUS; 1643 1644 if (err_mask & AC_ERR_TIMEOUT) 1645 return base + ATA_ECAT_TOUT_HSM; 1646 1647 if (eflags & ATA_EFLAG_IS_IO) { 1648 if (err_mask & AC_ERR_HSM) 1649 return base + ATA_ECAT_TOUT_HSM; 1650 if ((err_mask & 1651 (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV) 1652 return base + ATA_ECAT_UNK_DEV; 1653 } 1654 1655 return 0; 1656 } 1657 1658 struct speed_down_verdict_arg { 1659 u64 since; 1660 int xfer_ok; 1661 int nr_errors[ATA_ECAT_NR]; 1662 }; 1663 1664 static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg) 1665 { 1666 struct speed_down_verdict_arg *arg = void_arg; 1667 int cat; 1668 1669 if (ent->timestamp < arg->since) 1670 return -1; 1671 1672 cat = ata_eh_categorize_error(ent->eflags, ent->err_mask, 1673 &arg->xfer_ok); 1674 arg->nr_errors[cat]++; 1675 1676 return 0; 1677 } 1678 1679 /** 1680 * ata_eh_speed_down_verdict - Determine speed down verdict 1681 * @dev: Device of interest 1682 * 1683 * This function examines error ring of @dev and determines 1684 * whether NCQ needs to be turned off, transfer speed should be 1685 * stepped down, or falling back to PIO is necessary. 1686 * 1687 * ECAT_ATA_BUS : ATA_BUS error for any command 1688 * 1689 * ECAT_TOUT_HSM : TIMEOUT for any command or HSM violation for 1690 * IO commands 1691 * 1692 * ECAT_UNK_DEV : Unknown DEV error for IO commands 1693 * 1694 * ECAT_DUBIOUS_* : Identical to above three but occurred while 1695 * data transfer hasn't been verified. 1696 * 1697 * Verdicts are 1698 * 1699 * NCQ_OFF : Turn off NCQ. 1700 * 1701 * SPEED_DOWN : Speed down transfer speed but don't fall back 1702 * to PIO. 1703 * 1704 * FALLBACK_TO_PIO : Fall back to PIO. 1705 * 1706 * Even if multiple verdicts are returned, only one action is 1707 * taken per error. An action triggered by non-DUBIOUS errors 1708 * clears ering, while one triggered by DUBIOUS_* errors doesn't. 1709 * This is to expedite speed down decisions right after device is 1710 * initially configured. 1711 * 1712 * The followings are speed down rules. #1 and #2 deal with 1713 * DUBIOUS errors. 1714 * 1715 * 1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors 1716 * occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO. 1717 * 1718 * 2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors 1719 * occurred during last 5 mins, NCQ_OFF. 1720 * 1721 * 3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors 1722 * ocurred during last 5 mins, FALLBACK_TO_PIO 1723 * 1724 * 4. If more than 3 TOUT_HSM or UNK_DEV errors occurred 1725 * during last 10 mins, NCQ_OFF. 1726 * 1727 * 5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6 1728 * UNK_DEV errors occurred during last 10 mins, SPEED_DOWN. 1729 * 1730 * LOCKING: 1731 * Inherited from caller. 1732 * 1733 * RETURNS: 1734 * OR of ATA_EH_SPDN_* flags. 1735 */ 1736 static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev) 1737 { 1738 const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ; 1739 u64 j64 = get_jiffies_64(); 1740 struct speed_down_verdict_arg arg; 1741 unsigned int verdict = 0; 1742 1743 /* scan past 5 mins of error history */ 1744 memset(&arg, 0, sizeof(arg)); 1745 arg.since = j64 - min(j64, j5mins); 1746 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg); 1747 1748 if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] + 1749 arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1) 1750 verdict |= ATA_EH_SPDN_SPEED_DOWN | 1751 ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS; 1752 1753 if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] + 1754 arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1) 1755 verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS; 1756 1757 if (arg.nr_errors[ATA_ECAT_ATA_BUS] + 1758 arg.nr_errors[ATA_ECAT_TOUT_HSM] + 1759 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6) 1760 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO; 1761 1762 /* scan past 10 mins of error history */ 1763 memset(&arg, 0, sizeof(arg)); 1764 arg.since = j64 - min(j64, j10mins); 1765 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg); 1766 1767 if (arg.nr_errors[ATA_ECAT_TOUT_HSM] + 1768 arg.nr_errors[ATA_ECAT_UNK_DEV] > 3) 1769 verdict |= ATA_EH_SPDN_NCQ_OFF; 1770 1771 if (arg.nr_errors[ATA_ECAT_ATA_BUS] + 1772 arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 || 1773 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6) 1774 verdict |= ATA_EH_SPDN_SPEED_DOWN; 1775 1776 return verdict; 1777 } 1778 1779 /** 1780 * ata_eh_speed_down - record error and speed down if necessary 1781 * @dev: Failed device 1782 * @eflags: mask of ATA_EFLAG_* flags 1783 * @err_mask: err_mask of the error 1784 * 1785 * Record error and examine error history to determine whether 1786 * adjusting transmission speed is necessary. It also sets 1787 * transmission limits appropriately if such adjustment is 1788 * necessary. 1789 * 1790 * LOCKING: 1791 * Kernel thread context (may sleep). 1792 * 1793 * RETURNS: 1794 * Determined recovery action. 1795 */ 1796 static unsigned int ata_eh_speed_down(struct ata_device *dev, 1797 unsigned int eflags, unsigned int err_mask) 1798 { 1799 struct ata_link *link = ata_dev_phys_link(dev); 1800 int xfer_ok = 0; 1801 unsigned int verdict; 1802 unsigned int action = 0; 1803 1804 /* don't bother if Cat-0 error */ 1805 if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0) 1806 return 0; 1807 1808 /* record error and determine whether speed down is necessary */ 1809 ata_ering_record(&dev->ering, eflags, err_mask); 1810 verdict = ata_eh_speed_down_verdict(dev); 1811 1812 /* turn off NCQ? */ 1813 if ((verdict & ATA_EH_SPDN_NCQ_OFF) && 1814 (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ | 1815 ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) { 1816 dev->flags |= ATA_DFLAG_NCQ_OFF; 1817 ata_dev_printk(dev, KERN_WARNING, 1818 "NCQ disabled due to excessive errors\n"); 1819 goto done; 1820 } 1821 1822 /* speed down? */ 1823 if (verdict & ATA_EH_SPDN_SPEED_DOWN) { 1824 /* speed down SATA link speed if possible */ 1825 if (sata_down_spd_limit(link) == 0) { 1826 action |= ATA_EH_RESET; 1827 goto done; 1828 } 1829 1830 /* lower transfer mode */ 1831 if (dev->spdn_cnt < 2) { 1832 static const int dma_dnxfer_sel[] = 1833 { ATA_DNXFER_DMA, ATA_DNXFER_40C }; 1834 static const int pio_dnxfer_sel[] = 1835 { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 }; 1836 int sel; 1837 1838 if (dev->xfer_shift != ATA_SHIFT_PIO) 1839 sel = dma_dnxfer_sel[dev->spdn_cnt]; 1840 else 1841 sel = pio_dnxfer_sel[dev->spdn_cnt]; 1842 1843 dev->spdn_cnt++; 1844 1845 if (ata_down_xfermask_limit(dev, sel) == 0) { 1846 action |= ATA_EH_RESET; 1847 goto done; 1848 } 1849 } 1850 } 1851 1852 /* Fall back to PIO? Slowing down to PIO is meaningless for 1853 * SATA ATA devices. Consider it only for PATA and SATAPI. 1854 */ 1855 if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) && 1856 (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) && 1857 (dev->xfer_shift != ATA_SHIFT_PIO)) { 1858 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) { 1859 dev->spdn_cnt = 0; 1860 action |= ATA_EH_RESET; 1861 goto done; 1862 } 1863 } 1864 1865 return 0; 1866 done: 1867 /* device has been slowed down, blow error history */ 1868 if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS)) 1869 ata_ering_clear(&dev->ering); 1870 return action; 1871 } 1872 1873 /** 1874 * ata_eh_link_autopsy - analyze error and determine recovery action 1875 * @link: host link to perform autopsy on 1876 * 1877 * Analyze why @link failed and determine which recovery actions 1878 * are needed. This function also sets more detailed AC_ERR_* 1879 * values and fills sense data for ATAPI CHECK SENSE. 1880 * 1881 * LOCKING: 1882 * Kernel thread context (may sleep). 1883 */ 1884 static void ata_eh_link_autopsy(struct ata_link *link) 1885 { 1886 struct ata_port *ap = link->ap; 1887 struct ata_eh_context *ehc = &link->eh_context; 1888 struct ata_device *dev; 1889 unsigned int all_err_mask = 0, eflags = 0; 1890 int tag; 1891 u32 serror; 1892 int rc; 1893 1894 DPRINTK("ENTER\n"); 1895 1896 if (ehc->i.flags & ATA_EHI_NO_AUTOPSY) 1897 return; 1898 1899 /* obtain and analyze SError */ 1900 rc = sata_scr_read(link, SCR_ERROR, &serror); 1901 if (rc == 0) { 1902 ehc->i.serror |= serror; 1903 ata_eh_analyze_serror(link); 1904 } else if (rc != -EOPNOTSUPP) { 1905 /* SError read failed, force reset and probing */ 1906 ehc->i.probe_mask |= ATA_ALL_DEVICES; 1907 ehc->i.action |= ATA_EH_RESET; 1908 ehc->i.err_mask |= AC_ERR_OTHER; 1909 } 1910 1911 /* analyze NCQ failure */ 1912 ata_eh_analyze_ncq_error(link); 1913 1914 /* any real error trumps AC_ERR_OTHER */ 1915 if (ehc->i.err_mask & ~AC_ERR_OTHER) 1916 ehc->i.err_mask &= ~AC_ERR_OTHER; 1917 1918 all_err_mask |= ehc->i.err_mask; 1919 1920 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { 1921 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); 1922 1923 if (!(qc->flags & ATA_QCFLAG_FAILED) || 1924 ata_dev_phys_link(qc->dev) != link) 1925 continue; 1926 1927 /* inherit upper level err_mask */ 1928 qc->err_mask |= ehc->i.err_mask; 1929 1930 /* analyze TF */ 1931 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf); 1932 1933 /* DEV errors are probably spurious in case of ATA_BUS error */ 1934 if (qc->err_mask & AC_ERR_ATA_BUS) 1935 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA | 1936 AC_ERR_INVALID); 1937 1938 /* any real error trumps unknown error */ 1939 if (qc->err_mask & ~AC_ERR_OTHER) 1940 qc->err_mask &= ~AC_ERR_OTHER; 1941 1942 /* SENSE_VALID trumps dev/unknown error and revalidation */ 1943 if (qc->flags & ATA_QCFLAG_SENSE_VALID) 1944 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER); 1945 1946 /* determine whether the command is worth retrying */ 1947 if (!(qc->err_mask & AC_ERR_INVALID) && 1948 ((qc->flags & ATA_QCFLAG_IO) || qc->err_mask != AC_ERR_DEV)) 1949 qc->flags |= ATA_QCFLAG_RETRY; 1950 1951 /* accumulate error info */ 1952 ehc->i.dev = qc->dev; 1953 all_err_mask |= qc->err_mask; 1954 if (qc->flags & ATA_QCFLAG_IO) 1955 eflags |= ATA_EFLAG_IS_IO; 1956 } 1957 1958 /* enforce default EH actions */ 1959 if (ap->pflags & ATA_PFLAG_FROZEN || 1960 all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT)) 1961 ehc->i.action |= ATA_EH_RESET; 1962 else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) || 1963 (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV))) 1964 ehc->i.action |= ATA_EH_REVALIDATE; 1965 1966 /* If we have offending qcs and the associated failed device, 1967 * perform per-dev EH action only on the offending device. 1968 */ 1969 if (ehc->i.dev) { 1970 ehc->i.dev_action[ehc->i.dev->devno] |= 1971 ehc->i.action & ATA_EH_PERDEV_MASK; 1972 ehc->i.action &= ~ATA_EH_PERDEV_MASK; 1973 } 1974 1975 /* propagate timeout to host link */ 1976 if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link)) 1977 ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT; 1978 1979 /* record error and consider speeding down */ 1980 dev = ehc->i.dev; 1981 if (!dev && ((ata_link_max_devices(link) == 1 && 1982 ata_dev_enabled(link->device)))) 1983 dev = link->device; 1984 1985 if (dev) { 1986 if (dev->flags & ATA_DFLAG_DUBIOUS_XFER) 1987 eflags |= ATA_EFLAG_DUBIOUS_XFER; 1988 ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask); 1989 } 1990 1991 DPRINTK("EXIT\n"); 1992 } 1993 1994 /** 1995 * ata_eh_autopsy - analyze error and determine recovery action 1996 * @ap: host port to perform autopsy on 1997 * 1998 * Analyze all links of @ap and determine why they failed and 1999 * which recovery actions are needed. 2000 * 2001 * LOCKING: 2002 * Kernel thread context (may sleep). 2003 */ 2004 void ata_eh_autopsy(struct ata_port *ap) 2005 { 2006 struct ata_link *link; 2007 2008 ata_port_for_each_link(link, ap) 2009 ata_eh_link_autopsy(link); 2010 2011 /* Handle the frigging slave link. Autopsy is done similarly 2012 * but actions and flags are transferred over to the master 2013 * link and handled from there. 2014 */ 2015 if (ap->slave_link) { 2016 struct ata_eh_context *mehc = &ap->link.eh_context; 2017 struct ata_eh_context *sehc = &ap->slave_link->eh_context; 2018 2019 /* transfer control flags from master to slave */ 2020 sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK; 2021 2022 /* perform autopsy on the slave link */ 2023 ata_eh_link_autopsy(ap->slave_link); 2024 2025 /* transfer actions from slave to master and clear slave */ 2026 ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS); 2027 mehc->i.action |= sehc->i.action; 2028 mehc->i.dev_action[1] |= sehc->i.dev_action[1]; 2029 mehc->i.flags |= sehc->i.flags; 2030 ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS); 2031 } 2032 2033 /* Autopsy of fanout ports can affect host link autopsy. 2034 * Perform host link autopsy last. 2035 */ 2036 if (sata_pmp_attached(ap)) 2037 ata_eh_link_autopsy(&ap->link); 2038 } 2039 2040 /** 2041 * ata_eh_link_report - report error handling to user 2042 * @link: ATA link EH is going on 2043 * 2044 * Report EH to user. 2045 * 2046 * LOCKING: 2047 * None. 2048 */ 2049 static void ata_eh_link_report(struct ata_link *link) 2050 { 2051 struct ata_port *ap = link->ap; 2052 struct ata_eh_context *ehc = &link->eh_context; 2053 const char *frozen, *desc; 2054 char tries_buf[6]; 2055 int tag, nr_failed = 0; 2056 2057 if (ehc->i.flags & ATA_EHI_QUIET) 2058 return; 2059 2060 desc = NULL; 2061 if (ehc->i.desc[0] != '\0') 2062 desc = ehc->i.desc; 2063 2064 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { 2065 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); 2066 2067 if (!(qc->flags & ATA_QCFLAG_FAILED) || 2068 ata_dev_phys_link(qc->dev) != link || 2069 ((qc->flags & ATA_QCFLAG_QUIET) && 2070 qc->err_mask == AC_ERR_DEV)) 2071 continue; 2072 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask) 2073 continue; 2074 2075 nr_failed++; 2076 } 2077 2078 if (!nr_failed && !ehc->i.err_mask) 2079 return; 2080 2081 frozen = ""; 2082 if (ap->pflags & ATA_PFLAG_FROZEN) 2083 frozen = " frozen"; 2084 2085 memset(tries_buf, 0, sizeof(tries_buf)); 2086 if (ap->eh_tries < ATA_EH_MAX_TRIES) 2087 snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d", 2088 ap->eh_tries); 2089 2090 if (ehc->i.dev) { 2091 ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x " 2092 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n", 2093 ehc->i.err_mask, link->sactive, ehc->i.serror, 2094 ehc->i.action, frozen, tries_buf); 2095 if (desc) 2096 ata_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc); 2097 } else { 2098 ata_link_printk(link, KERN_ERR, "exception Emask 0x%x " 2099 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n", 2100 ehc->i.err_mask, link->sactive, ehc->i.serror, 2101 ehc->i.action, frozen, tries_buf); 2102 if (desc) 2103 ata_link_printk(link, KERN_ERR, "%s\n", desc); 2104 } 2105 2106 if (ehc->i.serror) 2107 ata_link_printk(link, KERN_ERR, 2108 "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n", 2109 ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "", 2110 ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "", 2111 ehc->i.serror & SERR_DATA ? "UnrecovData " : "", 2112 ehc->i.serror & SERR_PERSISTENT ? "Persist " : "", 2113 ehc->i.serror & SERR_PROTOCOL ? "Proto " : "", 2114 ehc->i.serror & SERR_INTERNAL ? "HostInt " : "", 2115 ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "", 2116 ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "", 2117 ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "", 2118 ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "", 2119 ehc->i.serror & SERR_DISPARITY ? "Dispar " : "", 2120 ehc->i.serror & SERR_CRC ? "BadCRC " : "", 2121 ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "", 2122 ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "", 2123 ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "", 2124 ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "", 2125 ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : ""); 2126 2127 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { 2128 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); 2129 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf; 2130 const u8 *cdb = qc->cdb; 2131 char data_buf[20] = ""; 2132 char cdb_buf[70] = ""; 2133 2134 if (!(qc->flags & ATA_QCFLAG_FAILED) || 2135 ata_dev_phys_link(qc->dev) != link || !qc->err_mask) 2136 continue; 2137 2138 if (qc->dma_dir != DMA_NONE) { 2139 static const char *dma_str[] = { 2140 [DMA_BIDIRECTIONAL] = "bidi", 2141 [DMA_TO_DEVICE] = "out", 2142 [DMA_FROM_DEVICE] = "in", 2143 }; 2144 static const char *prot_str[] = { 2145 [ATA_PROT_PIO] = "pio", 2146 [ATA_PROT_DMA] = "dma", 2147 [ATA_PROT_NCQ] = "ncq", 2148 [ATAPI_PROT_PIO] = "pio", 2149 [ATAPI_PROT_DMA] = "dma", 2150 }; 2151 2152 snprintf(data_buf, sizeof(data_buf), " %s %u %s", 2153 prot_str[qc->tf.protocol], qc->nbytes, 2154 dma_str[qc->dma_dir]); 2155 } 2156 2157 if (ata_is_atapi(qc->tf.protocol)) 2158 snprintf(cdb_buf, sizeof(cdb_buf), 2159 "cdb %02x %02x %02x %02x %02x %02x %02x %02x " 2160 "%02x %02x %02x %02x %02x %02x %02x %02x\n ", 2161 cdb[0], cdb[1], cdb[2], cdb[3], 2162 cdb[4], cdb[5], cdb[6], cdb[7], 2163 cdb[8], cdb[9], cdb[10], cdb[11], 2164 cdb[12], cdb[13], cdb[14], cdb[15]); 2165 2166 ata_dev_printk(qc->dev, KERN_ERR, 2167 "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x " 2168 "tag %d%s\n %s" 2169 "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x " 2170 "Emask 0x%x (%s)%s\n", 2171 cmd->command, cmd->feature, cmd->nsect, 2172 cmd->lbal, cmd->lbam, cmd->lbah, 2173 cmd->hob_feature, cmd->hob_nsect, 2174 cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah, 2175 cmd->device, qc->tag, data_buf, cdb_buf, 2176 res->command, res->feature, res->nsect, 2177 res->lbal, res->lbam, res->lbah, 2178 res->hob_feature, res->hob_nsect, 2179 res->hob_lbal, res->hob_lbam, res->hob_lbah, 2180 res->device, qc->err_mask, ata_err_string(qc->err_mask), 2181 qc->err_mask & AC_ERR_NCQ ? " <F>" : ""); 2182 2183 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ | 2184 ATA_ERR)) { 2185 if (res->command & ATA_BUSY) 2186 ata_dev_printk(qc->dev, KERN_ERR, 2187 "status: { Busy }\n"); 2188 else 2189 ata_dev_printk(qc->dev, KERN_ERR, 2190 "status: { %s%s%s%s}\n", 2191 res->command & ATA_DRDY ? "DRDY " : "", 2192 res->command & ATA_DF ? "DF " : "", 2193 res->command & ATA_DRQ ? "DRQ " : "", 2194 res->command & ATA_ERR ? "ERR " : ""); 2195 } 2196 2197 if (cmd->command != ATA_CMD_PACKET && 2198 (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF | 2199 ATA_ABORTED))) 2200 ata_dev_printk(qc->dev, KERN_ERR, 2201 "error: { %s%s%s%s}\n", 2202 res->feature & ATA_ICRC ? "ICRC " : "", 2203 res->feature & ATA_UNC ? "UNC " : "", 2204 res->feature & ATA_IDNF ? "IDNF " : "", 2205 res->feature & ATA_ABORTED ? "ABRT " : ""); 2206 } 2207 } 2208 2209 /** 2210 * ata_eh_report - report error handling to user 2211 * @ap: ATA port to report EH about 2212 * 2213 * Report EH to user. 2214 * 2215 * LOCKING: 2216 * None. 2217 */ 2218 void ata_eh_report(struct ata_port *ap) 2219 { 2220 struct ata_link *link; 2221 2222 __ata_port_for_each_link(link, ap) 2223 ata_eh_link_report(link); 2224 } 2225 2226 static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset, 2227 unsigned int *classes, unsigned long deadline, 2228 bool clear_classes) 2229 { 2230 struct ata_device *dev; 2231 2232 if (clear_classes) 2233 ata_link_for_each_dev(dev, link) 2234 classes[dev->devno] = ATA_DEV_UNKNOWN; 2235 2236 return reset(link, classes, deadline); 2237 } 2238 2239 static int ata_eh_followup_srst_needed(struct ata_link *link, 2240 int rc, const unsigned int *classes) 2241 { 2242 if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link)) 2243 return 0; 2244 if (rc == -EAGAIN) 2245 return 1; 2246 if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) 2247 return 1; 2248 return 0; 2249 } 2250 2251 int ata_eh_reset(struct ata_link *link, int classify, 2252 ata_prereset_fn_t prereset, ata_reset_fn_t softreset, 2253 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset) 2254 { 2255 struct ata_port *ap = link->ap; 2256 struct ata_link *slave = ap->slave_link; 2257 struct ata_eh_context *ehc = &link->eh_context; 2258 struct ata_eh_context *sehc = &slave->eh_context; 2259 unsigned int *classes = ehc->classes; 2260 unsigned int lflags = link->flags; 2261 int verbose = !(ehc->i.flags & ATA_EHI_QUIET); 2262 int max_tries = 0, try = 0; 2263 struct ata_link *failed_link; 2264 struct ata_device *dev; 2265 unsigned long deadline, now; 2266 ata_reset_fn_t reset; 2267 unsigned long flags; 2268 u32 sstatus; 2269 int nr_unknown, rc; 2270 2271 /* 2272 * Prepare to reset 2273 */ 2274 while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX) 2275 max_tries++; 2276 if (link->flags & ATA_LFLAG_NO_HRST) 2277 hardreset = NULL; 2278 if (link->flags & ATA_LFLAG_NO_SRST) 2279 softreset = NULL; 2280 2281 /* make sure each reset attemp is at least COOL_DOWN apart */ 2282 if (ehc->i.flags & ATA_EHI_DID_RESET) { 2283 now = jiffies; 2284 WARN_ON(time_after(ehc->last_reset, now)); 2285 deadline = ata_deadline(ehc->last_reset, 2286 ATA_EH_RESET_COOL_DOWN); 2287 if (time_before(now, deadline)) 2288 schedule_timeout_uninterruptible(deadline - now); 2289 } 2290 2291 spin_lock_irqsave(ap->lock, flags); 2292 ap->pflags |= ATA_PFLAG_RESETTING; 2293 spin_unlock_irqrestore(ap->lock, flags); 2294 2295 ata_eh_about_to_do(link, NULL, ATA_EH_RESET); 2296 2297 ata_link_for_each_dev(dev, link) { 2298 /* If we issue an SRST then an ATA drive (not ATAPI) 2299 * may change configuration and be in PIO0 timing. If 2300 * we do a hard reset (or are coming from power on) 2301 * this is true for ATA or ATAPI. Until we've set a 2302 * suitable controller mode we should not touch the 2303 * bus as we may be talking too fast. 2304 */ 2305 dev->pio_mode = XFER_PIO_0; 2306 2307 /* If the controller has a pio mode setup function 2308 * then use it to set the chipset to rights. Don't 2309 * touch the DMA setup as that will be dealt with when 2310 * configuring devices. 2311 */ 2312 if (ap->ops->set_piomode) 2313 ap->ops->set_piomode(ap, dev); 2314 } 2315 2316 /* prefer hardreset */ 2317 reset = NULL; 2318 ehc->i.action &= ~ATA_EH_RESET; 2319 if (hardreset) { 2320 reset = hardreset; 2321 ehc->i.action |= ATA_EH_HARDRESET; 2322 } else if (softreset) { 2323 reset = softreset; 2324 ehc->i.action |= ATA_EH_SOFTRESET; 2325 } 2326 2327 if (prereset) { 2328 unsigned long deadline = ata_deadline(jiffies, 2329 ATA_EH_PRERESET_TIMEOUT); 2330 2331 if (slave) { 2332 sehc->i.action &= ~ATA_EH_RESET; 2333 sehc->i.action |= ehc->i.action; 2334 } 2335 2336 rc = prereset(link, deadline); 2337 2338 /* If present, do prereset on slave link too. Reset 2339 * is skipped iff both master and slave links report 2340 * -ENOENT or clear ATA_EH_RESET. 2341 */ 2342 if (slave && (rc == 0 || rc == -ENOENT)) { 2343 int tmp; 2344 2345 tmp = prereset(slave, deadline); 2346 if (tmp != -ENOENT) 2347 rc = tmp; 2348 2349 ehc->i.action |= sehc->i.action; 2350 } 2351 2352 if (rc) { 2353 if (rc == -ENOENT) { 2354 ata_link_printk(link, KERN_DEBUG, 2355 "port disabled. ignoring.\n"); 2356 ehc->i.action &= ~ATA_EH_RESET; 2357 2358 ata_link_for_each_dev(dev, link) 2359 classes[dev->devno] = ATA_DEV_NONE; 2360 2361 rc = 0; 2362 } else 2363 ata_link_printk(link, KERN_ERR, 2364 "prereset failed (errno=%d)\n", rc); 2365 goto out; 2366 } 2367 2368 /* prereset() might have cleared ATA_EH_RESET. If so, 2369 * bang classes and return. 2370 */ 2371 if (reset && !(ehc->i.action & ATA_EH_RESET)) { 2372 ata_link_for_each_dev(dev, link) 2373 classes[dev->devno] = ATA_DEV_NONE; 2374 rc = 0; 2375 goto out; 2376 } 2377 } 2378 2379 retry: 2380 /* 2381 * Perform reset 2382 */ 2383 if (ata_is_host_link(link)) 2384 ata_eh_freeze_port(ap); 2385 2386 deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]); 2387 2388 if (reset) { 2389 if (verbose) 2390 ata_link_printk(link, KERN_INFO, "%s resetting link\n", 2391 reset == softreset ? "soft" : "hard"); 2392 2393 /* mark that this EH session started with reset */ 2394 ehc->last_reset = jiffies; 2395 if (reset == hardreset) 2396 ehc->i.flags |= ATA_EHI_DID_HARDRESET; 2397 else 2398 ehc->i.flags |= ATA_EHI_DID_SOFTRESET; 2399 2400 rc = ata_do_reset(link, reset, classes, deadline, true); 2401 if (rc && rc != -EAGAIN) { 2402 failed_link = link; 2403 goto fail; 2404 } 2405 2406 /* hardreset slave link if existent */ 2407 if (slave && reset == hardreset) { 2408 int tmp; 2409 2410 if (verbose) 2411 ata_link_printk(slave, KERN_INFO, 2412 "hard resetting link\n"); 2413 2414 ata_eh_about_to_do(slave, NULL, ATA_EH_RESET); 2415 tmp = ata_do_reset(slave, reset, classes, deadline, 2416 false); 2417 switch (tmp) { 2418 case -EAGAIN: 2419 rc = -EAGAIN; 2420 case 0: 2421 break; 2422 default: 2423 failed_link = slave; 2424 rc = tmp; 2425 goto fail; 2426 } 2427 } 2428 2429 /* perform follow-up SRST if necessary */ 2430 if (reset == hardreset && 2431 ata_eh_followup_srst_needed(link, rc, classes)) { 2432 reset = softreset; 2433 2434 if (!reset) { 2435 ata_link_printk(link, KERN_ERR, 2436 "follow-up softreset required " 2437 "but no softreset avaliable\n"); 2438 failed_link = link; 2439 rc = -EINVAL; 2440 goto fail; 2441 } 2442 2443 ata_eh_about_to_do(link, NULL, ATA_EH_RESET); 2444 rc = ata_do_reset(link, reset, classes, deadline, true); 2445 } 2446 } else { 2447 if (verbose) 2448 ata_link_printk(link, KERN_INFO, "no reset method " 2449 "available, skipping reset\n"); 2450 if (!(lflags & ATA_LFLAG_ASSUME_CLASS)) 2451 lflags |= ATA_LFLAG_ASSUME_ATA; 2452 } 2453 2454 /* 2455 * Post-reset processing 2456 */ 2457 ata_link_for_each_dev(dev, link) { 2458 /* After the reset, the device state is PIO 0 and the 2459 * controller state is undefined. Reset also wakes up 2460 * drives from sleeping mode. 2461 */ 2462 dev->pio_mode = XFER_PIO_0; 2463 dev->flags &= ~ATA_DFLAG_SLEEPING; 2464 2465 if (!ata_phys_link_offline(ata_dev_phys_link(dev))) { 2466 /* apply class override */ 2467 if (lflags & ATA_LFLAG_ASSUME_ATA) 2468 classes[dev->devno] = ATA_DEV_ATA; 2469 else if (lflags & ATA_LFLAG_ASSUME_SEMB) 2470 classes[dev->devno] = ATA_DEV_SEMB_UNSUP; 2471 } else 2472 classes[dev->devno] = ATA_DEV_NONE; 2473 } 2474 2475 /* record current link speed */ 2476 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0) 2477 link->sata_spd = (sstatus >> 4) & 0xf; 2478 if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0) 2479 slave->sata_spd = (sstatus >> 4) & 0xf; 2480 2481 /* thaw the port */ 2482 if (ata_is_host_link(link)) 2483 ata_eh_thaw_port(ap); 2484 2485 /* postreset() should clear hardware SError. Although SError 2486 * is cleared during link resume, clearing SError here is 2487 * necessary as some PHYs raise hotplug events after SRST. 2488 * This introduces race condition where hotplug occurs between 2489 * reset and here. This race is mediated by cross checking 2490 * link onlineness and classification result later. 2491 */ 2492 if (postreset) { 2493 postreset(link, classes); 2494 if (slave) 2495 postreset(slave, classes); 2496 } 2497 2498 /* clear cached SError */ 2499 spin_lock_irqsave(link->ap->lock, flags); 2500 link->eh_info.serror = 0; 2501 if (slave) 2502 slave->eh_info.serror = 0; 2503 spin_unlock_irqrestore(link->ap->lock, flags); 2504 2505 /* Make sure onlineness and classification result correspond. 2506 * Hotplug could have happened during reset and some 2507 * controllers fail to wait while a drive is spinning up after 2508 * being hotplugged causing misdetection. By cross checking 2509 * link onlineness and classification result, those conditions 2510 * can be reliably detected and retried. 2511 */ 2512 nr_unknown = 0; 2513 ata_link_for_each_dev(dev, link) { 2514 /* convert all ATA_DEV_UNKNOWN to ATA_DEV_NONE */ 2515 if (classes[dev->devno] == ATA_DEV_UNKNOWN) { 2516 classes[dev->devno] = ATA_DEV_NONE; 2517 if (ata_phys_link_online(ata_dev_phys_link(dev))) 2518 nr_unknown++; 2519 } 2520 } 2521 2522 if (classify && nr_unknown) { 2523 if (try < max_tries) { 2524 ata_link_printk(link, KERN_WARNING, "link online but " 2525 "device misclassified, retrying\n"); 2526 failed_link = link; 2527 rc = -EAGAIN; 2528 goto fail; 2529 } 2530 ata_link_printk(link, KERN_WARNING, 2531 "link online but device misclassified, " 2532 "device detection might fail\n"); 2533 } 2534 2535 /* reset successful, schedule revalidation */ 2536 ata_eh_done(link, NULL, ATA_EH_RESET); 2537 if (slave) 2538 ata_eh_done(slave, NULL, ATA_EH_RESET); 2539 ehc->last_reset = jiffies; /* update to completion time */ 2540 ehc->i.action |= ATA_EH_REVALIDATE; 2541 2542 rc = 0; 2543 out: 2544 /* clear hotplug flag */ 2545 ehc->i.flags &= ~ATA_EHI_HOTPLUGGED; 2546 if (slave) 2547 sehc->i.flags &= ~ATA_EHI_HOTPLUGGED; 2548 2549 spin_lock_irqsave(ap->lock, flags); 2550 ap->pflags &= ~ATA_PFLAG_RESETTING; 2551 spin_unlock_irqrestore(ap->lock, flags); 2552 2553 return rc; 2554 2555 fail: 2556 /* if SCR isn't accessible on a fan-out port, PMP needs to be reset */ 2557 if (!ata_is_host_link(link) && 2558 sata_scr_read(link, SCR_STATUS, &sstatus)) 2559 rc = -ERESTART; 2560 2561 if (rc == -ERESTART || try >= max_tries) 2562 goto out; 2563 2564 now = jiffies; 2565 if (time_before(now, deadline)) { 2566 unsigned long delta = deadline - now; 2567 2568 ata_link_printk(failed_link, KERN_WARNING, 2569 "reset failed (errno=%d), retrying in %u secs\n", 2570 rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000)); 2571 2572 while (delta) 2573 delta = schedule_timeout_uninterruptible(delta); 2574 } 2575 2576 if (try == max_tries - 1) { 2577 sata_down_spd_limit(link); 2578 if (slave) 2579 sata_down_spd_limit(slave); 2580 } else if (rc == -EPIPE) 2581 sata_down_spd_limit(failed_link); 2582 2583 if (hardreset) 2584 reset = hardreset; 2585 goto retry; 2586 } 2587 2588 static inline void ata_eh_pull_park_action(struct ata_port *ap) 2589 { 2590 struct ata_link *link; 2591 struct ata_device *dev; 2592 unsigned long flags; 2593 2594 /* 2595 * This function can be thought of as an extended version of 2596 * ata_eh_about_to_do() specially crafted to accommodate the 2597 * requirements of ATA_EH_PARK handling. Since the EH thread 2598 * does not leave the do {} while () loop in ata_eh_recover as 2599 * long as the timeout for a park request to *one* device on 2600 * the port has not expired, and since we still want to pick 2601 * up park requests to other devices on the same port or 2602 * timeout updates for the same device, we have to pull 2603 * ATA_EH_PARK actions from eh_info into eh_context.i 2604 * ourselves at the beginning of each pass over the loop. 2605 * 2606 * Additionally, all write accesses to &ap->park_req_pending 2607 * through INIT_COMPLETION() (see below) or complete_all() 2608 * (see ata_scsi_park_store()) are protected by the host lock. 2609 * As a result we have that park_req_pending.done is zero on 2610 * exit from this function, i.e. when ATA_EH_PARK actions for 2611 * *all* devices on port ap have been pulled into the 2612 * respective eh_context structs. If, and only if, 2613 * park_req_pending.done is non-zero by the time we reach 2614 * wait_for_completion_timeout(), another ATA_EH_PARK action 2615 * has been scheduled for at least one of the devices on port 2616 * ap and we have to cycle over the do {} while () loop in 2617 * ata_eh_recover() again. 2618 */ 2619 2620 spin_lock_irqsave(ap->lock, flags); 2621 INIT_COMPLETION(ap->park_req_pending); 2622 ata_port_for_each_link(link, ap) { 2623 ata_link_for_each_dev(dev, link) { 2624 struct ata_eh_info *ehi = &link->eh_info; 2625 2626 link->eh_context.i.dev_action[dev->devno] |= 2627 ehi->dev_action[dev->devno] & ATA_EH_PARK; 2628 ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK); 2629 } 2630 } 2631 spin_unlock_irqrestore(ap->lock, flags); 2632 } 2633 2634 static void ata_eh_park_issue_cmd(struct ata_device *dev, int park) 2635 { 2636 struct ata_eh_context *ehc = &dev->link->eh_context; 2637 struct ata_taskfile tf; 2638 unsigned int err_mask; 2639 2640 ata_tf_init(dev, &tf); 2641 if (park) { 2642 ehc->unloaded_mask |= 1 << dev->devno; 2643 tf.command = ATA_CMD_IDLEIMMEDIATE; 2644 tf.feature = 0x44; 2645 tf.lbal = 0x4c; 2646 tf.lbam = 0x4e; 2647 tf.lbah = 0x55; 2648 } else { 2649 ehc->unloaded_mask &= ~(1 << dev->devno); 2650 tf.command = ATA_CMD_CHK_POWER; 2651 } 2652 2653 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; 2654 tf.protocol |= ATA_PROT_NODATA; 2655 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); 2656 if (park && (err_mask || tf.lbal != 0xc4)) { 2657 ata_dev_printk(dev, KERN_ERR, "head unload failed!\n"); 2658 ehc->unloaded_mask &= ~(1 << dev->devno); 2659 } 2660 } 2661 2662 static int ata_eh_revalidate_and_attach(struct ata_link *link, 2663 struct ata_device **r_failed_dev) 2664 { 2665 struct ata_port *ap = link->ap; 2666 struct ata_eh_context *ehc = &link->eh_context; 2667 struct ata_device *dev; 2668 unsigned int new_mask = 0; 2669 unsigned long flags; 2670 int rc = 0; 2671 2672 DPRINTK("ENTER\n"); 2673 2674 /* For PATA drive side cable detection to work, IDENTIFY must 2675 * be done backwards such that PDIAG- is released by the slave 2676 * device before the master device is identified. 2677 */ 2678 ata_link_for_each_dev_reverse(dev, link) { 2679 unsigned int action = ata_eh_dev_action(dev); 2680 unsigned int readid_flags = 0; 2681 2682 if (ehc->i.flags & ATA_EHI_DID_RESET) 2683 readid_flags |= ATA_READID_POSTRESET; 2684 2685 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) { 2686 WARN_ON(dev->class == ATA_DEV_PMP); 2687 2688 if (ata_phys_link_offline(ata_dev_phys_link(dev))) { 2689 rc = -EIO; 2690 goto err; 2691 } 2692 2693 ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE); 2694 rc = ata_dev_revalidate(dev, ehc->classes[dev->devno], 2695 readid_flags); 2696 if (rc) 2697 goto err; 2698 2699 ata_eh_done(link, dev, ATA_EH_REVALIDATE); 2700 2701 /* Configuration may have changed, reconfigure 2702 * transfer mode. 2703 */ 2704 ehc->i.flags |= ATA_EHI_SETMODE; 2705 2706 /* schedule the scsi_rescan_device() here */ 2707 queue_work(ata_aux_wq, &(ap->scsi_rescan_task)); 2708 } else if (dev->class == ATA_DEV_UNKNOWN && 2709 ehc->tries[dev->devno] && 2710 ata_class_enabled(ehc->classes[dev->devno])) { 2711 dev->class = ehc->classes[dev->devno]; 2712 2713 if (dev->class == ATA_DEV_PMP) 2714 rc = sata_pmp_attach(dev); 2715 else 2716 rc = ata_dev_read_id(dev, &dev->class, 2717 readid_flags, dev->id); 2718 switch (rc) { 2719 case 0: 2720 new_mask |= 1 << dev->devno; 2721 break; 2722 case -ENOENT: 2723 /* IDENTIFY was issued to non-existent 2724 * device. No need to reset. Just 2725 * thaw and kill the device. 2726 */ 2727 ata_eh_thaw_port(ap); 2728 dev->class = ATA_DEV_UNKNOWN; 2729 break; 2730 default: 2731 dev->class = ATA_DEV_UNKNOWN; 2732 goto err; 2733 } 2734 } 2735 } 2736 2737 /* PDIAG- should have been released, ask cable type if post-reset */ 2738 if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) { 2739 if (ap->ops->cable_detect) 2740 ap->cbl = ap->ops->cable_detect(ap); 2741 ata_force_cbl(ap); 2742 } 2743 2744 /* Configure new devices forward such that user doesn't see 2745 * device detection messages backwards. 2746 */ 2747 ata_link_for_each_dev(dev, link) { 2748 if (!(new_mask & (1 << dev->devno)) || 2749 dev->class == ATA_DEV_PMP) 2750 continue; 2751 2752 ehc->i.flags |= ATA_EHI_PRINTINFO; 2753 rc = ata_dev_configure(dev); 2754 ehc->i.flags &= ~ATA_EHI_PRINTINFO; 2755 if (rc) 2756 goto err; 2757 2758 spin_lock_irqsave(ap->lock, flags); 2759 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG; 2760 spin_unlock_irqrestore(ap->lock, flags); 2761 2762 /* new device discovered, configure xfermode */ 2763 ehc->i.flags |= ATA_EHI_SETMODE; 2764 } 2765 2766 return 0; 2767 2768 err: 2769 *r_failed_dev = dev; 2770 DPRINTK("EXIT rc=%d\n", rc); 2771 return rc; 2772 } 2773 2774 /** 2775 * ata_set_mode - Program timings and issue SET FEATURES - XFER 2776 * @link: link on which timings will be programmed 2777 * @r_failed_dev: out paramter for failed device 2778 * 2779 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If 2780 * ata_set_mode() fails, pointer to the failing device is 2781 * returned in @r_failed_dev. 2782 * 2783 * LOCKING: 2784 * PCI/etc. bus probe sem. 2785 * 2786 * RETURNS: 2787 * 0 on success, negative errno otherwise 2788 */ 2789 int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) 2790 { 2791 struct ata_port *ap = link->ap; 2792 struct ata_device *dev; 2793 int rc; 2794 2795 /* if data transfer is verified, clear DUBIOUS_XFER on ering top */ 2796 ata_link_for_each_dev(dev, link) { 2797 if (!ata_dev_enabled(dev)) 2798 continue; 2799 2800 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) { 2801 struct ata_ering_entry *ent; 2802 2803 ent = ata_ering_top(&dev->ering); 2804 if (ent) 2805 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER; 2806 } 2807 } 2808 2809 /* has private set_mode? */ 2810 if (ap->ops->set_mode) 2811 rc = ap->ops->set_mode(link, r_failed_dev); 2812 else 2813 rc = ata_do_set_mode(link, r_failed_dev); 2814 2815 /* if transfer mode has changed, set DUBIOUS_XFER on device */ 2816 ata_link_for_each_dev(dev, link) { 2817 struct ata_eh_context *ehc = &link->eh_context; 2818 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno]; 2819 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno)); 2820 2821 if (!ata_dev_enabled(dev)) 2822 continue; 2823 2824 if (dev->xfer_mode != saved_xfer_mode || 2825 ata_ncq_enabled(dev) != saved_ncq) 2826 dev->flags |= ATA_DFLAG_DUBIOUS_XFER; 2827 } 2828 2829 return rc; 2830 } 2831 2832 /** 2833 * atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset 2834 * @dev: ATAPI device to clear UA for 2835 * 2836 * Resets and other operations can make an ATAPI device raise 2837 * UNIT ATTENTION which causes the next operation to fail. This 2838 * function clears UA. 2839 * 2840 * LOCKING: 2841 * EH context (may sleep). 2842 * 2843 * RETURNS: 2844 * 0 on success, -errno on failure. 2845 */ 2846 static int atapi_eh_clear_ua(struct ata_device *dev) 2847 { 2848 int i; 2849 2850 for (i = 0; i < ATA_EH_UA_TRIES; i++) { 2851 u8 sense_buffer[SCSI_SENSE_BUFFERSIZE]; 2852 u8 sense_key = 0; 2853 unsigned int err_mask; 2854 2855 err_mask = atapi_eh_tur(dev, &sense_key); 2856 if (err_mask != 0 && err_mask != AC_ERR_DEV) { 2857 ata_dev_printk(dev, KERN_WARNING, "TEST_UNIT_READY " 2858 "failed (err_mask=0x%x)\n", err_mask); 2859 return -EIO; 2860 } 2861 2862 if (!err_mask || sense_key != UNIT_ATTENTION) 2863 return 0; 2864 2865 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key); 2866 if (err_mask) { 2867 ata_dev_printk(dev, KERN_WARNING, "failed to clear " 2868 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask); 2869 return -EIO; 2870 } 2871 } 2872 2873 ata_dev_printk(dev, KERN_WARNING, 2874 "UNIT ATTENTION persists after %d tries\n", ATA_EH_UA_TRIES); 2875 2876 return 0; 2877 } 2878 2879 static int ata_link_nr_enabled(struct ata_link *link) 2880 { 2881 struct ata_device *dev; 2882 int cnt = 0; 2883 2884 ata_link_for_each_dev(dev, link) 2885 if (ata_dev_enabled(dev)) 2886 cnt++; 2887 return cnt; 2888 } 2889 2890 static int ata_link_nr_vacant(struct ata_link *link) 2891 { 2892 struct ata_device *dev; 2893 int cnt = 0; 2894 2895 ata_link_for_each_dev(dev, link) 2896 if (dev->class == ATA_DEV_UNKNOWN) 2897 cnt++; 2898 return cnt; 2899 } 2900 2901 static int ata_eh_skip_recovery(struct ata_link *link) 2902 { 2903 struct ata_port *ap = link->ap; 2904 struct ata_eh_context *ehc = &link->eh_context; 2905 struct ata_device *dev; 2906 2907 /* skip disabled links */ 2908 if (link->flags & ATA_LFLAG_DISABLED) 2909 return 1; 2910 2911 /* thaw frozen port and recover failed devices */ 2912 if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link)) 2913 return 0; 2914 2915 /* reset at least once if reset is requested */ 2916 if ((ehc->i.action & ATA_EH_RESET) && 2917 !(ehc->i.flags & ATA_EHI_DID_RESET)) 2918 return 0; 2919 2920 /* skip if class codes for all vacant slots are ATA_DEV_NONE */ 2921 ata_link_for_each_dev(dev, link) { 2922 if (dev->class == ATA_DEV_UNKNOWN && 2923 ehc->classes[dev->devno] != ATA_DEV_NONE) 2924 return 0; 2925 } 2926 2927 return 1; 2928 } 2929 2930 static int ata_eh_schedule_probe(struct ata_device *dev) 2931 { 2932 struct ata_eh_context *ehc = &dev->link->eh_context; 2933 2934 if (!(ehc->i.probe_mask & (1 << dev->devno)) || 2935 (ehc->did_probe_mask & (1 << dev->devno))) 2936 return 0; 2937 2938 ata_eh_detach_dev(dev); 2939 ata_dev_init(dev); 2940 ehc->did_probe_mask |= (1 << dev->devno); 2941 ehc->i.action |= ATA_EH_RESET; 2942 ehc->saved_xfer_mode[dev->devno] = 0; 2943 ehc->saved_ncq_enabled &= ~(1 << dev->devno); 2944 2945 return 1; 2946 } 2947 2948 static int ata_eh_handle_dev_fail(struct ata_device *dev, int err) 2949 { 2950 struct ata_eh_context *ehc = &dev->link->eh_context; 2951 2952 ehc->tries[dev->devno]--; 2953 2954 switch (err) { 2955 case -ENODEV: 2956 /* device missing or wrong IDENTIFY data, schedule probing */ 2957 ehc->i.probe_mask |= (1 << dev->devno); 2958 case -EINVAL: 2959 /* give it just one more chance */ 2960 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1); 2961 case -EIO: 2962 if (ehc->tries[dev->devno] == 1 && dev->pio_mode > XFER_PIO_0) { 2963 /* This is the last chance, better to slow 2964 * down than lose it. 2965 */ 2966 sata_down_spd_limit(ata_dev_phys_link(dev)); 2967 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO); 2968 } 2969 } 2970 2971 if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) { 2972 /* disable device if it has used up all its chances */ 2973 ata_dev_disable(dev); 2974 2975 /* detach if offline */ 2976 if (ata_phys_link_offline(ata_dev_phys_link(dev))) 2977 ata_eh_detach_dev(dev); 2978 2979 /* schedule probe if necessary */ 2980 if (ata_eh_schedule_probe(dev)) { 2981 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES; 2982 memset(ehc->cmd_timeout_idx[dev->devno], 0, 2983 sizeof(ehc->cmd_timeout_idx[dev->devno])); 2984 } 2985 2986 return 1; 2987 } else { 2988 ehc->i.action |= ATA_EH_RESET; 2989 return 0; 2990 } 2991 } 2992 2993 /** 2994 * ata_eh_recover - recover host port after error 2995 * @ap: host port to recover 2996 * @prereset: prereset method (can be NULL) 2997 * @softreset: softreset method (can be NULL) 2998 * @hardreset: hardreset method (can be NULL) 2999 * @postreset: postreset method (can be NULL) 3000 * @r_failed_link: out parameter for failed link 3001 * 3002 * This is the alpha and omega, eum and yang, heart and soul of 3003 * libata exception handling. On entry, actions required to 3004 * recover each link and hotplug requests are recorded in the 3005 * link's eh_context. This function executes all the operations 3006 * with appropriate retrials and fallbacks to resurrect failed 3007 * devices, detach goners and greet newcomers. 3008 * 3009 * LOCKING: 3010 * Kernel thread context (may sleep). 3011 * 3012 * RETURNS: 3013 * 0 on success, -errno on failure. 3014 */ 3015 int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset, 3016 ata_reset_fn_t softreset, ata_reset_fn_t hardreset, 3017 ata_postreset_fn_t postreset, 3018 struct ata_link **r_failed_link) 3019 { 3020 struct ata_link *link; 3021 struct ata_device *dev; 3022 int nr_failed_devs; 3023 int rc; 3024 unsigned long flags, deadline; 3025 3026 DPRINTK("ENTER\n"); 3027 3028 /* prep for recovery */ 3029 ata_port_for_each_link(link, ap) { 3030 struct ata_eh_context *ehc = &link->eh_context; 3031 3032 /* re-enable link? */ 3033 if (ehc->i.action & ATA_EH_ENABLE_LINK) { 3034 ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK); 3035 spin_lock_irqsave(ap->lock, flags); 3036 link->flags &= ~ATA_LFLAG_DISABLED; 3037 spin_unlock_irqrestore(ap->lock, flags); 3038 ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK); 3039 } 3040 3041 ata_link_for_each_dev(dev, link) { 3042 if (link->flags & ATA_LFLAG_NO_RETRY) 3043 ehc->tries[dev->devno] = 1; 3044 else 3045 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES; 3046 3047 /* collect port action mask recorded in dev actions */ 3048 ehc->i.action |= ehc->i.dev_action[dev->devno] & 3049 ~ATA_EH_PERDEV_MASK; 3050 ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK; 3051 3052 /* process hotplug request */ 3053 if (dev->flags & ATA_DFLAG_DETACH) 3054 ata_eh_detach_dev(dev); 3055 3056 /* schedule probe if necessary */ 3057 if (!ata_dev_enabled(dev)) 3058 ata_eh_schedule_probe(dev); 3059 } 3060 } 3061 3062 retry: 3063 rc = 0; 3064 nr_failed_devs = 0; 3065 3066 /* if UNLOADING, finish immediately */ 3067 if (ap->pflags & ATA_PFLAG_UNLOADING) 3068 goto out; 3069 3070 /* prep for EH */ 3071 ata_port_for_each_link(link, ap) { 3072 struct ata_eh_context *ehc = &link->eh_context; 3073 3074 /* skip EH if possible. */ 3075 if (ata_eh_skip_recovery(link)) 3076 ehc->i.action = 0; 3077 3078 ata_link_for_each_dev(dev, link) 3079 ehc->classes[dev->devno] = ATA_DEV_UNKNOWN; 3080 } 3081 3082 /* reset */ 3083 ata_port_for_each_link(link, ap) { 3084 struct ata_eh_context *ehc = &link->eh_context; 3085 3086 if (!(ehc->i.action & ATA_EH_RESET)) 3087 continue; 3088 3089 rc = ata_eh_reset(link, ata_link_nr_vacant(link), 3090 prereset, softreset, hardreset, postreset); 3091 if (rc) { 3092 ata_link_printk(link, KERN_ERR, 3093 "reset failed, giving up\n"); 3094 goto out; 3095 } 3096 } 3097 3098 do { 3099 unsigned long now; 3100 3101 /* 3102 * clears ATA_EH_PARK in eh_info and resets 3103 * ap->park_req_pending 3104 */ 3105 ata_eh_pull_park_action(ap); 3106 3107 deadline = jiffies; 3108 ata_port_for_each_link(link, ap) { 3109 ata_link_for_each_dev(dev, link) { 3110 struct ata_eh_context *ehc = &link->eh_context; 3111 unsigned long tmp; 3112 3113 if (dev->class != ATA_DEV_ATA) 3114 continue; 3115 if (!(ehc->i.dev_action[dev->devno] & 3116 ATA_EH_PARK)) 3117 continue; 3118 tmp = dev->unpark_deadline; 3119 if (time_before(deadline, tmp)) 3120 deadline = tmp; 3121 else if (time_before_eq(tmp, jiffies)) 3122 continue; 3123 if (ehc->unloaded_mask & (1 << dev->devno)) 3124 continue; 3125 3126 ata_eh_park_issue_cmd(dev, 1); 3127 } 3128 } 3129 3130 now = jiffies; 3131 if (time_before_eq(deadline, now)) 3132 break; 3133 3134 deadline = wait_for_completion_timeout(&ap->park_req_pending, 3135 deadline - now); 3136 } while (deadline); 3137 ata_port_for_each_link(link, ap) { 3138 ata_link_for_each_dev(dev, link) { 3139 if (!(link->eh_context.unloaded_mask & 3140 (1 << dev->devno))) 3141 continue; 3142 3143 ata_eh_park_issue_cmd(dev, 0); 3144 ata_eh_done(link, dev, ATA_EH_PARK); 3145 } 3146 } 3147 3148 /* the rest */ 3149 ata_port_for_each_link(link, ap) { 3150 struct ata_eh_context *ehc = &link->eh_context; 3151 3152 /* revalidate existing devices and attach new ones */ 3153 rc = ata_eh_revalidate_and_attach(link, &dev); 3154 if (rc) 3155 goto dev_fail; 3156 3157 /* if PMP got attached, return, pmp EH will take care of it */ 3158 if (link->device->class == ATA_DEV_PMP) { 3159 ehc->i.action = 0; 3160 return 0; 3161 } 3162 3163 /* configure transfer mode if necessary */ 3164 if (ehc->i.flags & ATA_EHI_SETMODE) { 3165 rc = ata_set_mode(link, &dev); 3166 if (rc) 3167 goto dev_fail; 3168 ehc->i.flags &= ~ATA_EHI_SETMODE; 3169 } 3170 3171 /* If reset has been issued, clear UA to avoid 3172 * disrupting the current users of the device. 3173 */ 3174 if (ehc->i.flags & ATA_EHI_DID_RESET) { 3175 ata_link_for_each_dev(dev, link) { 3176 if (dev->class != ATA_DEV_ATAPI) 3177 continue; 3178 rc = atapi_eh_clear_ua(dev); 3179 if (rc) 3180 goto dev_fail; 3181 } 3182 } 3183 3184 /* configure link power saving */ 3185 if (ehc->i.action & ATA_EH_LPM) 3186 ata_link_for_each_dev(dev, link) 3187 ata_dev_enable_pm(dev, ap->pm_policy); 3188 3189 /* this link is okay now */ 3190 ehc->i.flags = 0; 3191 continue; 3192 3193 dev_fail: 3194 nr_failed_devs++; 3195 ata_eh_handle_dev_fail(dev, rc); 3196 3197 if (ap->pflags & ATA_PFLAG_FROZEN) { 3198 /* PMP reset requires working host port. 3199 * Can't retry if it's frozen. 3200 */ 3201 if (sata_pmp_attached(ap)) 3202 goto out; 3203 break; 3204 } 3205 } 3206 3207 if (nr_failed_devs) 3208 goto retry; 3209 3210 out: 3211 if (rc && r_failed_link) 3212 *r_failed_link = link; 3213 3214 DPRINTK("EXIT, rc=%d\n", rc); 3215 return rc; 3216 } 3217 3218 /** 3219 * ata_eh_finish - finish up EH 3220 * @ap: host port to finish EH for 3221 * 3222 * Recovery is complete. Clean up EH states and retry or finish 3223 * failed qcs. 3224 * 3225 * LOCKING: 3226 * None. 3227 */ 3228 void ata_eh_finish(struct ata_port *ap) 3229 { 3230 int tag; 3231 3232 /* retry or finish qcs */ 3233 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { 3234 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); 3235 3236 if (!(qc->flags & ATA_QCFLAG_FAILED)) 3237 continue; 3238 3239 if (qc->err_mask) { 3240 /* FIXME: Once EH migration is complete, 3241 * generate sense data in this function, 3242 * considering both err_mask and tf. 3243 */ 3244 if (qc->flags & ATA_QCFLAG_RETRY) 3245 ata_eh_qc_retry(qc); 3246 else 3247 ata_eh_qc_complete(qc); 3248 } else { 3249 if (qc->flags & ATA_QCFLAG_SENSE_VALID) { 3250 ata_eh_qc_complete(qc); 3251 } else { 3252 /* feed zero TF to sense generation */ 3253 memset(&qc->result_tf, 0, sizeof(qc->result_tf)); 3254 ata_eh_qc_retry(qc); 3255 } 3256 } 3257 } 3258 3259 /* make sure nr_active_links is zero after EH */ 3260 WARN_ON(ap->nr_active_links); 3261 ap->nr_active_links = 0; 3262 } 3263 3264 /** 3265 * ata_do_eh - do standard error handling 3266 * @ap: host port to handle error for 3267 * 3268 * @prereset: prereset method (can be NULL) 3269 * @softreset: softreset method (can be NULL) 3270 * @hardreset: hardreset method (can be NULL) 3271 * @postreset: postreset method (can be NULL) 3272 * 3273 * Perform standard error handling sequence. 3274 * 3275 * LOCKING: 3276 * Kernel thread context (may sleep). 3277 */ 3278 void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset, 3279 ata_reset_fn_t softreset, ata_reset_fn_t hardreset, 3280 ata_postreset_fn_t postreset) 3281 { 3282 struct ata_device *dev; 3283 int rc; 3284 3285 ata_eh_autopsy(ap); 3286 ata_eh_report(ap); 3287 3288 rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset, 3289 NULL); 3290 if (rc) { 3291 ata_link_for_each_dev(dev, &ap->link) 3292 ata_dev_disable(dev); 3293 } 3294 3295 ata_eh_finish(ap); 3296 } 3297 3298 /** 3299 * ata_std_error_handler - standard error handler 3300 * @ap: host port to handle error for 3301 * 3302 * Standard error handler 3303 * 3304 * LOCKING: 3305 * Kernel thread context (may sleep). 3306 */ 3307 void ata_std_error_handler(struct ata_port *ap) 3308 { 3309 struct ata_port_operations *ops = ap->ops; 3310 ata_reset_fn_t hardreset = ops->hardreset; 3311 3312 /* ignore built-in hardreset if SCR access is not available */ 3313 if (ata_is_builtin_hardreset(hardreset) && !sata_scr_valid(&ap->link)) 3314 hardreset = NULL; 3315 3316 ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset); 3317 } 3318 3319 #ifdef CONFIG_PM 3320 /** 3321 * ata_eh_handle_port_suspend - perform port suspend operation 3322 * @ap: port to suspend 3323 * 3324 * Suspend @ap. 3325 * 3326 * LOCKING: 3327 * Kernel thread context (may sleep). 3328 */ 3329 static void ata_eh_handle_port_suspend(struct ata_port *ap) 3330 { 3331 unsigned long flags; 3332 int rc = 0; 3333 3334 /* are we suspending? */ 3335 spin_lock_irqsave(ap->lock, flags); 3336 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) || 3337 ap->pm_mesg.event == PM_EVENT_ON) { 3338 spin_unlock_irqrestore(ap->lock, flags); 3339 return; 3340 } 3341 spin_unlock_irqrestore(ap->lock, flags); 3342 3343 WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED); 3344 3345 /* tell ACPI we're suspending */ 3346 rc = ata_acpi_on_suspend(ap); 3347 if (rc) 3348 goto out; 3349 3350 /* suspend */ 3351 ata_eh_freeze_port(ap); 3352 3353 if (ap->ops->port_suspend) 3354 rc = ap->ops->port_suspend(ap, ap->pm_mesg); 3355 3356 ata_acpi_set_state(ap, PMSG_SUSPEND); 3357 out: 3358 /* report result */ 3359 spin_lock_irqsave(ap->lock, flags); 3360 3361 ap->pflags &= ~ATA_PFLAG_PM_PENDING; 3362 if (rc == 0) 3363 ap->pflags |= ATA_PFLAG_SUSPENDED; 3364 else if (ap->pflags & ATA_PFLAG_FROZEN) 3365 ata_port_schedule_eh(ap); 3366 3367 if (ap->pm_result) { 3368 *ap->pm_result = rc; 3369 ap->pm_result = NULL; 3370 } 3371 3372 spin_unlock_irqrestore(ap->lock, flags); 3373 3374 return; 3375 } 3376 3377 /** 3378 * ata_eh_handle_port_resume - perform port resume operation 3379 * @ap: port to resume 3380 * 3381 * Resume @ap. 3382 * 3383 * LOCKING: 3384 * Kernel thread context (may sleep). 3385 */ 3386 static void ata_eh_handle_port_resume(struct ata_port *ap) 3387 { 3388 unsigned long flags; 3389 int rc = 0; 3390 3391 /* are we resuming? */ 3392 spin_lock_irqsave(ap->lock, flags); 3393 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) || 3394 ap->pm_mesg.event != PM_EVENT_ON) { 3395 spin_unlock_irqrestore(ap->lock, flags); 3396 return; 3397 } 3398 spin_unlock_irqrestore(ap->lock, flags); 3399 3400 WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED)); 3401 3402 ata_acpi_set_state(ap, PMSG_ON); 3403 3404 if (ap->ops->port_resume) 3405 rc = ap->ops->port_resume(ap); 3406 3407 /* tell ACPI that we're resuming */ 3408 ata_acpi_on_resume(ap); 3409 3410 /* report result */ 3411 spin_lock_irqsave(ap->lock, flags); 3412 ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED); 3413 if (ap->pm_result) { 3414 *ap->pm_result = rc; 3415 ap->pm_result = NULL; 3416 } 3417 spin_unlock_irqrestore(ap->lock, flags); 3418 } 3419 #endif /* CONFIG_PM */ 3420