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