2 * libata-eh.c - libata error handling
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
8 * Copyright 2006 Tejun Heo <htejun@gmail.com>
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.
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.
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,
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
30 * Hardware documentation available from http://www.t13.org/ and
31 * http://www.sata-io.org/
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"
45 #include <linux/libata.h>
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),
57 ATA_EFLAG_IS_IO = (1 << 0),
58 ATA_EFLAG_DUBIOUS_XFER = (1 << 1),
60 /* error categories */
63 ATA_ECAT_TOUT_HSM = 2,
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,
71 ATA_EH_CMD_DFL_TIMEOUT = 5000,
73 /* always put at least this amount of time between resets */
74 ATA_EH_RESET_COOL_DOWN = 5000,
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.
81 ATA_EH_PRERESET_TIMEOUT = 10000,
82 ATA_EH_FASTDRAIN_INTERVAL = 3000,
86 /* probe speed down parameters, see ata_eh_schedule_probe() */
87 ATA_EH_PROBE_TRIAL_INTERVAL = 60000, /* 1 min */
88 ATA_EH_PROBE_TRIALS = 2,
91 /* The following table determines how we sequence resets. Each entry
92 * represents timeout for that try. The first try can be soft or
93 * hardreset. All others are hardreset if available. In most cases
94 * the first reset w/ 10sec timeout should succeed. Following entries
95 * are mostly for error handling, hotplug and retarded devices.
97 static const unsigned long ata_eh_reset_timeouts[] = {
98 10000, /* most drives spin up by 10sec */
99 10000, /* > 99% working drives spin up before 20sec */
100 35000, /* give > 30 secs of idleness for retarded devices */
101 5000, /* and sweet one last chance */
102 ULONG_MAX, /* > 1 min has elapsed, give up */
105 static const unsigned long ata_eh_identify_timeouts[] = {
106 5000, /* covers > 99% of successes and not too boring on failures */
107 10000, /* combined time till here is enough even for media access */
108 30000, /* for true idiots */
112 static const unsigned long ata_eh_other_timeouts[] = {
113 5000, /* same rationale as identify timeout */
115 /* but no merciful 30sec for other commands, it just isn't worth it */
119 struct ata_eh_cmd_timeout_ent {
121 const unsigned long *timeouts;
124 /* The following table determines timeouts to use for EH internal
125 * commands. Each table entry is a command class and matches the
126 * commands the entry applies to and the timeout table to use.
128 * On the retry after a command timed out, the next timeout value from
129 * the table is used. If the table doesn't contain further entries,
130 * the last value is used.
132 * ehc->cmd_timeout_idx keeps track of which timeout to use per
133 * command class, so if SET_FEATURES times out on the first try, the
134 * next try will use the second timeout value only for that class.
136 #define CMDS(cmds...) (const u8 []){ cmds, 0 }
137 static const struct ata_eh_cmd_timeout_ent
138 ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = {
139 { .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI),
140 .timeouts = ata_eh_identify_timeouts, },
141 { .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT),
142 .timeouts = ata_eh_other_timeouts, },
143 { .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT),
144 .timeouts = ata_eh_other_timeouts, },
145 { .commands = CMDS(ATA_CMD_SET_FEATURES),
146 .timeouts = ata_eh_other_timeouts, },
147 { .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS),
148 .timeouts = ata_eh_other_timeouts, },
152 static void __ata_port_freeze(struct ata_port *ap);
154 static void ata_eh_handle_port_suspend(struct ata_port *ap);
155 static void ata_eh_handle_port_resume(struct ata_port *ap);
156 #else /* CONFIG_PM */
157 static void ata_eh_handle_port_suspend(struct ata_port *ap)
160 static void ata_eh_handle_port_resume(struct ata_port *ap)
162 #endif /* CONFIG_PM */
164 static void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, const char *fmt,
167 ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
168 ATA_EH_DESC_LEN - ehi->desc_len,
173 * __ata_ehi_push_desc - push error description without adding separator
175 * @fmt: printf format string
177 * Format string according to @fmt and append it to @ehi->desc.
180 * spin_lock_irqsave(host lock)
182 void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
187 __ata_ehi_pushv_desc(ehi, fmt, args);
192 * ata_ehi_push_desc - push error description with separator
194 * @fmt: printf format string
196 * Format string according to @fmt and append it to @ehi->desc.
197 * If @ehi->desc is not empty, ", " is added in-between.
200 * spin_lock_irqsave(host lock)
202 void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
207 __ata_ehi_push_desc(ehi, ", ");
210 __ata_ehi_pushv_desc(ehi, fmt, args);
215 * ata_ehi_clear_desc - clean error description
221 * spin_lock_irqsave(host lock)
223 void ata_ehi_clear_desc(struct ata_eh_info *ehi)
230 * ata_port_desc - append port description
231 * @ap: target ATA port
232 * @fmt: printf format string
234 * Format string according to @fmt and append it to port
235 * description. If port description is not empty, " " is added
236 * in-between. This function is to be used while initializing
237 * ata_host. The description is printed on host registration.
242 void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
246 WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
248 if (ap->link.eh_info.desc_len)
249 __ata_ehi_push_desc(&ap->link.eh_info, " ");
252 __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
259 * ata_port_pbar_desc - append PCI BAR description
260 * @ap: target ATA port
261 * @bar: target PCI BAR
262 * @offset: offset into PCI BAR
263 * @name: name of the area
265 * If @offset is negative, this function formats a string which
266 * contains the name, address, size and type of the BAR and
267 * appends it to the port description. If @offset is zero or
268 * positive, only name and offsetted address is appended.
273 void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
276 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
278 unsigned long long start, len;
280 if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
282 else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
285 start = (unsigned long long)pci_resource_start(pdev, bar);
286 len = (unsigned long long)pci_resource_len(pdev, bar);
289 ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
291 ata_port_desc(ap, "%s 0x%llx", name,
292 start + (unsigned long long)offset);
295 #endif /* CONFIG_PCI */
297 static int ata_lookup_timeout_table(u8 cmd)
301 for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) {
304 for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++)
313 * ata_internal_cmd_timeout - determine timeout for an internal command
314 * @dev: target device
315 * @cmd: internal command to be issued
317 * Determine timeout for internal command @cmd for @dev.
323 * Determined timeout.
325 unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd)
327 struct ata_eh_context *ehc = &dev->link->eh_context;
328 int ent = ata_lookup_timeout_table(cmd);
332 return ATA_EH_CMD_DFL_TIMEOUT;
334 idx = ehc->cmd_timeout_idx[dev->devno][ent];
335 return ata_eh_cmd_timeout_table[ent].timeouts[idx];
339 * ata_internal_cmd_timed_out - notification for internal command timeout
340 * @dev: target device
341 * @cmd: internal command which timed out
343 * Notify EH that internal command @cmd for @dev timed out. This
344 * function should be called only for commands whose timeouts are
345 * determined using ata_internal_cmd_timeout().
350 void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd)
352 struct ata_eh_context *ehc = &dev->link->eh_context;
353 int ent = ata_lookup_timeout_table(cmd);
359 idx = ehc->cmd_timeout_idx[dev->devno][ent];
360 if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX)
361 ehc->cmd_timeout_idx[dev->devno][ent]++;
364 static void ata_ering_record(struct ata_ering *ering, unsigned int eflags,
365 unsigned int err_mask)
367 struct ata_ering_entry *ent;
372 ering->cursor %= ATA_ERING_SIZE;
374 ent = &ering->ring[ering->cursor];
375 ent->eflags = eflags;
376 ent->err_mask = err_mask;
377 ent->timestamp = get_jiffies_64();
380 static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
382 struct ata_ering_entry *ent = &ering->ring[ering->cursor];
389 static void ata_ering_clear(struct ata_ering *ering)
391 memset(ering, 0, sizeof(*ering));
394 static int ata_ering_map(struct ata_ering *ering,
395 int (*map_fn)(struct ata_ering_entry *, void *),
399 struct ata_ering_entry *ent;
403 ent = &ering->ring[idx];
406 rc = map_fn(ent, arg);
409 idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
410 } while (idx != ering->cursor);
415 static unsigned int ata_eh_dev_action(struct ata_device *dev)
417 struct ata_eh_context *ehc = &dev->link->eh_context;
419 return ehc->i.action | ehc->i.dev_action[dev->devno];
422 static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
423 struct ata_eh_info *ehi, unsigned int action)
425 struct ata_device *tdev;
428 ehi->action &= ~action;
429 ata_for_each_dev(tdev, link, ALL)
430 ehi->dev_action[tdev->devno] &= ~action;
432 /* doesn't make sense for port-wide EH actions */
433 WARN_ON(!(action & ATA_EH_PERDEV_MASK));
435 /* break ehi->action into ehi->dev_action */
436 if (ehi->action & action) {
437 ata_for_each_dev(tdev, link, ALL)
438 ehi->dev_action[tdev->devno] |=
439 ehi->action & action;
440 ehi->action &= ~action;
443 /* turn off the specified per-dev action */
444 ehi->dev_action[dev->devno] &= ~action;
449 * ata_scsi_timed_out - SCSI layer time out callback
450 * @cmd: timed out SCSI command
452 * Handles SCSI layer timeout. We race with normal completion of
453 * the qc for @cmd. If the qc is already gone, we lose and let
454 * the scsi command finish (EH_HANDLED). Otherwise, the qc has
455 * timed out and EH should be invoked. Prevent ata_qc_complete()
456 * from finishing it by setting EH_SCHEDULED and return
459 * TODO: kill this function once old EH is gone.
462 * Called from timer context
465 * EH_HANDLED or EH_NOT_HANDLED
467 enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
469 struct Scsi_Host *host = cmd->device->host;
470 struct ata_port *ap = ata_shost_to_port(host);
472 struct ata_queued_cmd *qc;
473 enum blk_eh_timer_return ret;
477 if (ap->ops->error_handler) {
478 ret = BLK_EH_NOT_HANDLED;
482 ret = BLK_EH_HANDLED;
483 spin_lock_irqsave(ap->lock, flags);
484 qc = ata_qc_from_tag(ap, ap->link.active_tag);
486 WARN_ON(qc->scsicmd != cmd);
487 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
488 qc->err_mask |= AC_ERR_TIMEOUT;
489 ret = BLK_EH_NOT_HANDLED;
491 spin_unlock_irqrestore(ap->lock, flags);
494 DPRINTK("EXIT, ret=%d\n", ret);
498 static void ata_eh_unload(struct ata_port *ap)
500 struct ata_link *link;
501 struct ata_device *dev;
504 /* Restore SControl IPM and SPD for the next driver and
505 * disable attached devices.
507 ata_for_each_link(link, ap, PMP_FIRST) {
508 sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);
509 ata_for_each_dev(dev, link, ALL)
510 ata_dev_disable(dev);
513 /* freeze and set UNLOADED */
514 spin_lock_irqsave(ap->lock, flags);
516 ata_port_freeze(ap); /* won't be thawed */
517 ap->pflags &= ~ATA_PFLAG_EH_PENDING; /* clear pending from freeze */
518 ap->pflags |= ATA_PFLAG_UNLOADED;
520 spin_unlock_irqrestore(ap->lock, flags);
524 * ata_scsi_error - SCSI layer error handler callback
525 * @host: SCSI host on which error occurred
527 * Handles SCSI-layer-thrown error events.
530 * Inherited from SCSI layer (none, can sleep)
535 void ata_scsi_error(struct Scsi_Host *host)
537 struct ata_port *ap = ata_shost_to_port(host);
543 /* synchronize with port task */
544 ata_port_flush_task(ap);
546 /* synchronize with host lock and sort out timeouts */
548 /* For new EH, all qcs are finished in one of three ways -
549 * normal completion, error completion, and SCSI timeout.
550 * Both cmpletions can race against SCSI timeout. When normal
551 * completion wins, the qc never reaches EH. When error
552 * completion wins, the qc has ATA_QCFLAG_FAILED set.
554 * When SCSI timeout wins, things are a bit more complex.
555 * Normal or error completion can occur after the timeout but
556 * before this point. In such cases, both types of
557 * completions are honored. A scmd is determined to have
558 * timed out iff its associated qc is active and not failed.
560 if (ap->ops->error_handler) {
561 struct scsi_cmnd *scmd, *tmp;
564 spin_lock_irqsave(ap->lock, flags);
566 list_for_each_entry_safe(scmd, tmp, &host->eh_cmd_q, eh_entry) {
567 struct ata_queued_cmd *qc;
569 for (i = 0; i < ATA_MAX_QUEUE; i++) {
570 qc = __ata_qc_from_tag(ap, i);
571 if (qc->flags & ATA_QCFLAG_ACTIVE &&
576 if (i < ATA_MAX_QUEUE) {
577 /* the scmd has an associated qc */
578 if (!(qc->flags & ATA_QCFLAG_FAILED)) {
579 /* which hasn't failed yet, timeout */
580 qc->err_mask |= AC_ERR_TIMEOUT;
581 qc->flags |= ATA_QCFLAG_FAILED;
585 /* Normal completion occurred after
586 * SCSI timeout but before this point.
587 * Successfully complete it.
589 scmd->retries = scmd->allowed;
590 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
594 /* If we have timed out qcs. They belong to EH from
595 * this point but the state of the controller is
596 * unknown. Freeze the port to make sure the IRQ
597 * handler doesn't diddle with those qcs. This must
598 * be done atomically w.r.t. setting QCFLAG_FAILED.
601 __ata_port_freeze(ap);
603 spin_unlock_irqrestore(ap->lock, flags);
605 /* initialize eh_tries */
606 ap->eh_tries = ATA_EH_MAX_TRIES;
608 spin_unlock_wait(ap->lock);
611 /* invoke error handler */
612 if (ap->ops->error_handler) {
613 struct ata_link *link;
615 /* kill fast drain timer */
616 del_timer_sync(&ap->fastdrain_timer);
618 /* process port resume request */
619 ata_eh_handle_port_resume(ap);
621 /* fetch & clear EH info */
622 spin_lock_irqsave(ap->lock, flags);
624 ata_for_each_link(link, ap, HOST_FIRST) {
625 struct ata_eh_context *ehc = &link->eh_context;
626 struct ata_device *dev;
628 memset(&link->eh_context, 0, sizeof(link->eh_context));
629 link->eh_context.i = link->eh_info;
630 memset(&link->eh_info, 0, sizeof(link->eh_info));
632 ata_for_each_dev(dev, link, ENABLED) {
633 int devno = dev->devno;
635 ehc->saved_xfer_mode[devno] = dev->xfer_mode;
636 if (ata_ncq_enabled(dev))
637 ehc->saved_ncq_enabled |= 1 << devno;
641 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
642 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
643 ap->excl_link = NULL; /* don't maintain exclusion over EH */
645 spin_unlock_irqrestore(ap->lock, flags);
647 /* invoke EH, skip if unloading or suspended */
648 if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
649 ap->ops->error_handler(ap);
651 /* if unloading, commence suicide */
652 if ((ap->pflags & ATA_PFLAG_UNLOADING) &&
653 !(ap->pflags & ATA_PFLAG_UNLOADED))
658 /* process port suspend request */
659 ata_eh_handle_port_suspend(ap);
661 /* Exception might have happend after ->error_handler
662 * recovered the port but before this point. Repeat
665 spin_lock_irqsave(ap->lock, flags);
667 if (ap->pflags & ATA_PFLAG_EH_PENDING) {
668 if (--ap->eh_tries) {
669 spin_unlock_irqrestore(ap->lock, flags);
672 ata_port_printk(ap, KERN_ERR, "EH pending after %d "
673 "tries, giving up\n", ATA_EH_MAX_TRIES);
674 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
677 /* this run is complete, make sure EH info is clear */
678 ata_for_each_link(link, ap, HOST_FIRST)
679 memset(&link->eh_info, 0, sizeof(link->eh_info));
681 /* Clear host_eh_scheduled while holding ap->lock such
682 * that if exception occurs after this point but
683 * before EH completion, SCSI midlayer will
686 host->host_eh_scheduled = 0;
688 spin_unlock_irqrestore(ap->lock, flags);
690 WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
691 ap->ops->eng_timeout(ap);
694 /* finish or retry handled scmd's and clean up */
695 WARN_ON(host->host_failed || !list_empty(&host->eh_cmd_q));
697 scsi_eh_flush_done_q(&ap->eh_done_q);
700 spin_lock_irqsave(ap->lock, flags);
702 if (ap->pflags & ATA_PFLAG_LOADING)
703 ap->pflags &= ~ATA_PFLAG_LOADING;
704 else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
705 queue_delayed_work(ata_aux_wq, &ap->hotplug_task, 0);
707 if (ap->pflags & ATA_PFLAG_RECOVERED)
708 ata_port_printk(ap, KERN_INFO, "EH complete\n");
710 ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
712 /* tell wait_eh that we're done */
713 ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
714 wake_up_all(&ap->eh_wait_q);
716 spin_unlock_irqrestore(ap->lock, flags);
722 * ata_port_wait_eh - Wait for the currently pending EH to complete
723 * @ap: Port to wait EH for
725 * Wait until the currently pending EH is complete.
728 * Kernel thread context (may sleep).
730 void ata_port_wait_eh(struct ata_port *ap)
736 spin_lock_irqsave(ap->lock, flags);
738 while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
739 prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
740 spin_unlock_irqrestore(ap->lock, flags);
742 spin_lock_irqsave(ap->lock, flags);
744 finish_wait(&ap->eh_wait_q, &wait);
746 spin_unlock_irqrestore(ap->lock, flags);
748 /* make sure SCSI EH is complete */
749 if (scsi_host_in_recovery(ap->scsi_host)) {
755 static int ata_eh_nr_in_flight(struct ata_port *ap)
760 /* count only non-internal commands */
761 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
762 if (ata_qc_from_tag(ap, tag))
768 void ata_eh_fastdrain_timerfn(unsigned long arg)
770 struct ata_port *ap = (void *)arg;
774 spin_lock_irqsave(ap->lock, flags);
776 cnt = ata_eh_nr_in_flight(ap);
782 if (cnt == ap->fastdrain_cnt) {
785 /* No progress during the last interval, tag all
786 * in-flight qcs as timed out and freeze the port.
788 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
789 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
791 qc->err_mask |= AC_ERR_TIMEOUT;
796 /* some qcs have finished, give it another chance */
797 ap->fastdrain_cnt = cnt;
798 ap->fastdrain_timer.expires =
799 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
800 add_timer(&ap->fastdrain_timer);
804 spin_unlock_irqrestore(ap->lock, flags);
808 * ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
809 * @ap: target ATA port
810 * @fastdrain: activate fast drain
812 * Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
813 * is non-zero and EH wasn't pending before. Fast drain ensures
814 * that EH kicks in in timely manner.
817 * spin_lock_irqsave(host lock)
819 static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
823 /* already scheduled? */
824 if (ap->pflags & ATA_PFLAG_EH_PENDING)
827 ap->pflags |= ATA_PFLAG_EH_PENDING;
832 /* do we have in-flight qcs? */
833 cnt = ata_eh_nr_in_flight(ap);
837 /* activate fast drain */
838 ap->fastdrain_cnt = cnt;
839 ap->fastdrain_timer.expires =
840 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
841 add_timer(&ap->fastdrain_timer);
845 * ata_qc_schedule_eh - schedule qc for error handling
846 * @qc: command to schedule error handling for
848 * Schedule error handling for @qc. EH will kick in as soon as
849 * other commands are drained.
852 * spin_lock_irqsave(host lock)
854 void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
856 struct ata_port *ap = qc->ap;
858 WARN_ON(!ap->ops->error_handler);
860 qc->flags |= ATA_QCFLAG_FAILED;
861 ata_eh_set_pending(ap, 1);
863 /* The following will fail if timeout has already expired.
864 * ata_scsi_error() takes care of such scmds on EH entry.
865 * Note that ATA_QCFLAG_FAILED is unconditionally set after
866 * this function completes.
868 blk_abort_request(qc->scsicmd->request);
872 * ata_port_schedule_eh - schedule error handling without a qc
873 * @ap: ATA port to schedule EH for
875 * Schedule error handling for @ap. EH will kick in as soon as
876 * all commands are drained.
879 * spin_lock_irqsave(host lock)
881 void ata_port_schedule_eh(struct ata_port *ap)
883 WARN_ON(!ap->ops->error_handler);
885 if (ap->pflags & ATA_PFLAG_INITIALIZING)
888 ata_eh_set_pending(ap, 1);
889 scsi_schedule_eh(ap->scsi_host);
891 DPRINTK("port EH scheduled\n");
894 static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
896 int tag, nr_aborted = 0;
898 WARN_ON(!ap->ops->error_handler);
900 /* we're gonna abort all commands, no need for fast drain */
901 ata_eh_set_pending(ap, 0);
903 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
904 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
906 if (qc && (!link || qc->dev->link == link)) {
907 qc->flags |= ATA_QCFLAG_FAILED;
914 ata_port_schedule_eh(ap);
920 * ata_link_abort - abort all qc's on the link
921 * @link: ATA link to abort qc's for
923 * Abort all active qc's active on @link and schedule EH.
926 * spin_lock_irqsave(host lock)
929 * Number of aborted qc's.
931 int ata_link_abort(struct ata_link *link)
933 return ata_do_link_abort(link->ap, link);
937 * ata_port_abort - abort all qc's on the port
938 * @ap: ATA port to abort qc's for
940 * Abort all active qc's of @ap and schedule EH.
943 * spin_lock_irqsave(host_set lock)
946 * Number of aborted qc's.
948 int ata_port_abort(struct ata_port *ap)
950 return ata_do_link_abort(ap, NULL);
954 * __ata_port_freeze - freeze port
955 * @ap: ATA port to freeze
957 * This function is called when HSM violation or some other
958 * condition disrupts normal operation of the port. Frozen port
959 * is not allowed to perform any operation until the port is
960 * thawed, which usually follows a successful reset.
962 * ap->ops->freeze() callback can be used for freezing the port
963 * hardware-wise (e.g. mask interrupt and stop DMA engine). If a
964 * port cannot be frozen hardware-wise, the interrupt handler
965 * must ack and clear interrupts unconditionally while the port
969 * spin_lock_irqsave(host lock)
971 static void __ata_port_freeze(struct ata_port *ap)
973 WARN_ON(!ap->ops->error_handler);
978 ap->pflags |= ATA_PFLAG_FROZEN;
980 DPRINTK("ata%u port frozen\n", ap->print_id);
984 * ata_port_freeze - abort & freeze port
985 * @ap: ATA port to freeze
987 * Abort and freeze @ap.
990 * spin_lock_irqsave(host lock)
993 * Number of aborted commands.
995 int ata_port_freeze(struct ata_port *ap)
999 WARN_ON(!ap->ops->error_handler);
1001 nr_aborted = ata_port_abort(ap);
1002 __ata_port_freeze(ap);
1008 * sata_async_notification - SATA async notification handler
1009 * @ap: ATA port where async notification is received
1011 * Handler to be called when async notification via SDB FIS is
1012 * received. This function schedules EH if necessary.
1015 * spin_lock_irqsave(host lock)
1018 * 1 if EH is scheduled, 0 otherwise.
1020 int sata_async_notification(struct ata_port *ap)
1025 if (!(ap->flags & ATA_FLAG_AN))
1028 rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1030 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1032 if (!sata_pmp_attached(ap) || rc) {
1033 /* PMP is not attached or SNTF is not available */
1034 if (!sata_pmp_attached(ap)) {
1035 /* PMP is not attached. Check whether ATAPI
1036 * AN is configured. If so, notify media
1039 struct ata_device *dev = ap->link.device;
1041 if ((dev->class == ATA_DEV_ATAPI) &&
1042 (dev->flags & ATA_DFLAG_AN))
1043 ata_scsi_media_change_notify(dev);
1046 /* PMP is attached but SNTF is not available.
1047 * ATAPI async media change notification is
1048 * not used. The PMP must be reporting PHY
1049 * status change, schedule EH.
1051 ata_port_schedule_eh(ap);
1055 /* PMP is attached and SNTF is available */
1056 struct ata_link *link;
1058 /* check and notify ATAPI AN */
1059 ata_for_each_link(link, ap, EDGE) {
1060 if (!(sntf & (1 << link->pmp)))
1063 if ((link->device->class == ATA_DEV_ATAPI) &&
1064 (link->device->flags & ATA_DFLAG_AN))
1065 ata_scsi_media_change_notify(link->device);
1068 /* If PMP is reporting that PHY status of some
1069 * downstream ports has changed, schedule EH.
1071 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
1072 ata_port_schedule_eh(ap);
1081 * ata_eh_freeze_port - EH helper to freeze port
1082 * @ap: ATA port to freeze
1089 void ata_eh_freeze_port(struct ata_port *ap)
1091 unsigned long flags;
1093 if (!ap->ops->error_handler)
1096 spin_lock_irqsave(ap->lock, flags);
1097 __ata_port_freeze(ap);
1098 spin_unlock_irqrestore(ap->lock, flags);
1102 * ata_port_thaw_port - EH helper to thaw port
1103 * @ap: ATA port to thaw
1105 * Thaw frozen port @ap.
1110 void ata_eh_thaw_port(struct ata_port *ap)
1112 unsigned long flags;
1114 if (!ap->ops->error_handler)
1117 spin_lock_irqsave(ap->lock, flags);
1119 ap->pflags &= ~ATA_PFLAG_FROZEN;
1124 spin_unlock_irqrestore(ap->lock, flags);
1126 DPRINTK("ata%u port thawed\n", ap->print_id);
1129 static void ata_eh_scsidone(struct scsi_cmnd *scmd)
1134 static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
1136 struct ata_port *ap = qc->ap;
1137 struct scsi_cmnd *scmd = qc->scsicmd;
1138 unsigned long flags;
1140 spin_lock_irqsave(ap->lock, flags);
1141 qc->scsidone = ata_eh_scsidone;
1142 __ata_qc_complete(qc);
1143 WARN_ON(ata_tag_valid(qc->tag));
1144 spin_unlock_irqrestore(ap->lock, flags);
1146 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
1150 * ata_eh_qc_complete - Complete an active ATA command from EH
1151 * @qc: Command to complete
1153 * Indicate to the mid and upper layers that an ATA command has
1154 * completed. To be used from EH.
1156 void ata_eh_qc_complete(struct ata_queued_cmd *qc)
1158 struct scsi_cmnd *scmd = qc->scsicmd;
1159 scmd->retries = scmd->allowed;
1160 __ata_eh_qc_complete(qc);
1164 * ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
1165 * @qc: Command to retry
1167 * Indicate to the mid and upper layers that an ATA command
1168 * should be retried. To be used from EH.
1170 * SCSI midlayer limits the number of retries to scmd->allowed.
1171 * scmd->retries is decremented for commands which get retried
1172 * due to unrelated failures (qc->err_mask is zero).
1174 void ata_eh_qc_retry(struct ata_queued_cmd *qc)
1176 struct scsi_cmnd *scmd = qc->scsicmd;
1177 if (!qc->err_mask && scmd->retries)
1179 __ata_eh_qc_complete(qc);
1183 * ata_dev_disable - disable ATA device
1184 * @dev: ATA device to disable
1191 void ata_dev_disable(struct ata_device *dev)
1193 if (!ata_dev_enabled(dev))
1196 if (ata_msg_drv(dev->link->ap))
1197 ata_dev_printk(dev, KERN_WARNING, "disabled\n");
1198 ata_acpi_on_disable(dev);
1199 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET);
1202 /* From now till the next successful probe, ering is used to
1203 * track probe failures. Clear accumulated device error info.
1205 ata_ering_clear(&dev->ering);
1209 * ata_eh_detach_dev - detach ATA device
1210 * @dev: ATA device to detach
1217 void ata_eh_detach_dev(struct ata_device *dev)
1219 struct ata_link *link = dev->link;
1220 struct ata_port *ap = link->ap;
1221 struct ata_eh_context *ehc = &link->eh_context;
1222 unsigned long flags;
1224 ata_dev_disable(dev);
1226 spin_lock_irqsave(ap->lock, flags);
1228 dev->flags &= ~ATA_DFLAG_DETACH;
1230 if (ata_scsi_offline_dev(dev)) {
1231 dev->flags |= ATA_DFLAG_DETACHED;
1232 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
1235 /* clear per-dev EH info */
1236 ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
1237 ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
1238 ehc->saved_xfer_mode[dev->devno] = 0;
1239 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
1241 spin_unlock_irqrestore(ap->lock, flags);
1245 * ata_eh_about_to_do - about to perform eh_action
1246 * @link: target ATA link
1247 * @dev: target ATA dev for per-dev action (can be NULL)
1248 * @action: action about to be performed
1250 * Called just before performing EH actions to clear related bits
1251 * in @link->eh_info such that eh actions are not unnecessarily
1257 void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
1258 unsigned int action)
1260 struct ata_port *ap = link->ap;
1261 struct ata_eh_info *ehi = &link->eh_info;
1262 struct ata_eh_context *ehc = &link->eh_context;
1263 unsigned long flags;
1265 spin_lock_irqsave(ap->lock, flags);
1267 ata_eh_clear_action(link, dev, ehi, action);
1269 /* About to take EH action, set RECOVERED. Ignore actions on
1270 * slave links as master will do them again.
1272 if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link)
1273 ap->pflags |= ATA_PFLAG_RECOVERED;
1275 spin_unlock_irqrestore(ap->lock, flags);
1279 * ata_eh_done - EH action complete
1280 * @ap: target ATA port
1281 * @dev: target ATA dev for per-dev action (can be NULL)
1282 * @action: action just completed
1284 * Called right after performing EH actions to clear related bits
1285 * in @link->eh_context.
1290 void ata_eh_done(struct ata_link *link, struct ata_device *dev,
1291 unsigned int action)
1293 struct ata_eh_context *ehc = &link->eh_context;
1295 ata_eh_clear_action(link, dev, &ehc->i, action);
1299 * ata_err_string - convert err_mask to descriptive string
1300 * @err_mask: error mask to convert to string
1302 * Convert @err_mask to descriptive string. Errors are
1303 * prioritized according to severity and only the most severe
1304 * error is reported.
1310 * Descriptive string for @err_mask
1312 static const char *ata_err_string(unsigned int err_mask)
1314 if (err_mask & AC_ERR_HOST_BUS)
1315 return "host bus error";
1316 if (err_mask & AC_ERR_ATA_BUS)
1317 return "ATA bus error";
1318 if (err_mask & AC_ERR_TIMEOUT)
1320 if (err_mask & AC_ERR_HSM)
1321 return "HSM violation";
1322 if (err_mask & AC_ERR_SYSTEM)
1323 return "internal error";
1324 if (err_mask & AC_ERR_MEDIA)
1325 return "media error";
1326 if (err_mask & AC_ERR_INVALID)
1327 return "invalid argument";
1328 if (err_mask & AC_ERR_DEV)
1329 return "device error";
1330 return "unknown error";
1334 * ata_read_log_page - read a specific log page
1335 * @dev: target device
1336 * @page: page to read
1337 * @buf: buffer to store read page
1338 * @sectors: number of sectors to read
1340 * Read log page using READ_LOG_EXT command.
1343 * Kernel thread context (may sleep).
1346 * 0 on success, AC_ERR_* mask otherwise.
1348 static unsigned int ata_read_log_page(struct ata_device *dev,
1349 u8 page, void *buf, unsigned int sectors)
1351 struct ata_taskfile tf;
1352 unsigned int err_mask;
1354 DPRINTK("read log page - page %d\n", page);
1356 ata_tf_init(dev, &tf);
1357 tf.command = ATA_CMD_READ_LOG_EXT;
1360 tf.hob_nsect = sectors >> 8;
1361 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
1362 tf.protocol = ATA_PROT_PIO;
1364 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
1365 buf, sectors * ATA_SECT_SIZE, 0);
1367 DPRINTK("EXIT, err_mask=%x\n", err_mask);
1372 * ata_eh_read_log_10h - Read log page 10h for NCQ error details
1373 * @dev: Device to read log page 10h from
1374 * @tag: Resulting tag of the failed command
1375 * @tf: Resulting taskfile registers of the failed command
1377 * Read log page 10h to obtain NCQ error details and clear error
1381 * Kernel thread context (may sleep).
1384 * 0 on success, -errno otherwise.
1386 static int ata_eh_read_log_10h(struct ata_device *dev,
1387 int *tag, struct ata_taskfile *tf)
1389 u8 *buf = dev->link->ap->sector_buf;
1390 unsigned int err_mask;
1394 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1);
1399 for (i = 0; i < ATA_SECT_SIZE; i++)
1402 ata_dev_printk(dev, KERN_WARNING,
1403 "invalid checksum 0x%x on log page 10h\n", csum);
1408 *tag = buf[0] & 0x1f;
1410 tf->command = buf[2];
1411 tf->feature = buf[3];
1415 tf->device = buf[7];
1416 tf->hob_lbal = buf[8];
1417 tf->hob_lbam = buf[9];
1418 tf->hob_lbah = buf[10];
1419 tf->nsect = buf[12];
1420 tf->hob_nsect = buf[13];
1426 * atapi_eh_tur - perform ATAPI TEST_UNIT_READY
1427 * @dev: target ATAPI device
1428 * @r_sense_key: out parameter for sense_key
1430 * Perform ATAPI TEST_UNIT_READY.
1433 * EH context (may sleep).
1436 * 0 on success, AC_ERR_* mask on failure.
1438 static unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
1440 u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 };
1441 struct ata_taskfile tf;
1442 unsigned int err_mask;
1444 ata_tf_init(dev, &tf);
1446 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1447 tf.command = ATA_CMD_PACKET;
1448 tf.protocol = ATAPI_PROT_NODATA;
1450 err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
1451 if (err_mask == AC_ERR_DEV)
1452 *r_sense_key = tf.feature >> 4;
1457 * atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
1458 * @dev: device to perform REQUEST_SENSE to
1459 * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
1460 * @dfl_sense_key: default sense key to use
1462 * Perform ATAPI REQUEST_SENSE after the device reported CHECK
1463 * SENSE. This function is EH helper.
1466 * Kernel thread context (may sleep).
1469 * 0 on success, AC_ERR_* mask on failure
1471 static unsigned int atapi_eh_request_sense(struct ata_device *dev,
1472 u8 *sense_buf, u8 dfl_sense_key)
1474 u8 cdb[ATAPI_CDB_LEN] =
1475 { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 };
1476 struct ata_port *ap = dev->link->ap;
1477 struct ata_taskfile tf;
1479 DPRINTK("ATAPI request sense\n");
1481 /* FIXME: is this needed? */
1482 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
1484 /* initialize sense_buf with the error register,
1485 * for the case where they are -not- overwritten
1487 sense_buf[0] = 0x70;
1488 sense_buf[2] = dfl_sense_key;
1490 /* some devices time out if garbage left in tf */
1491 ata_tf_init(dev, &tf);
1493 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1494 tf.command = ATA_CMD_PACKET;
1496 /* is it pointless to prefer PIO for "safety reasons"? */
1497 if (ap->flags & ATA_FLAG_PIO_DMA) {
1498 tf.protocol = ATAPI_PROT_DMA;
1499 tf.feature |= ATAPI_PKT_DMA;
1501 tf.protocol = ATAPI_PROT_PIO;
1502 tf.lbam = SCSI_SENSE_BUFFERSIZE;
1506 return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
1507 sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
1511 * ata_eh_analyze_serror - analyze SError for a failed port
1512 * @link: ATA link to analyze SError for
1514 * Analyze SError if available and further determine cause of
1520 static void ata_eh_analyze_serror(struct ata_link *link)
1522 struct ata_eh_context *ehc = &link->eh_context;
1523 u32 serror = ehc->i.serror;
1524 unsigned int err_mask = 0, action = 0;
1527 if (serror & (SERR_PERSISTENT | SERR_DATA)) {
1528 err_mask |= AC_ERR_ATA_BUS;
1529 action |= ATA_EH_RESET;
1531 if (serror & SERR_PROTOCOL) {
1532 err_mask |= AC_ERR_HSM;
1533 action |= ATA_EH_RESET;
1535 if (serror & SERR_INTERNAL) {
1536 err_mask |= AC_ERR_SYSTEM;
1537 action |= ATA_EH_RESET;
1540 /* Determine whether a hotplug event has occurred. Both
1541 * SError.N/X are considered hotplug events for enabled or
1542 * host links. For disabled PMP links, only N bit is
1543 * considered as X bit is left at 1 for link plugging.
1547 if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
1548 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
1550 hotplug_mask = SERR_PHYRDY_CHG;
1552 if (serror & hotplug_mask)
1553 ata_ehi_hotplugged(&ehc->i);
1555 ehc->i.err_mask |= err_mask;
1556 ehc->i.action |= action;
1560 * ata_eh_analyze_ncq_error - analyze NCQ error
1561 * @link: ATA link to analyze NCQ error for
1563 * Read log page 10h, determine the offending qc and acquire
1564 * error status TF. For NCQ device errors, all LLDDs have to do
1565 * is setting AC_ERR_DEV in ehi->err_mask. This function takes
1569 * Kernel thread context (may sleep).
1571 void ata_eh_analyze_ncq_error(struct ata_link *link)
1573 struct ata_port *ap = link->ap;
1574 struct ata_eh_context *ehc = &link->eh_context;
1575 struct ata_device *dev = link->device;
1576 struct ata_queued_cmd *qc;
1577 struct ata_taskfile tf;
1580 /* if frozen, we can't do much */
1581 if (ap->pflags & ATA_PFLAG_FROZEN)
1584 /* is it NCQ device error? */
1585 if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
1588 /* has LLDD analyzed already? */
1589 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1590 qc = __ata_qc_from_tag(ap, tag);
1592 if (!(qc->flags & ATA_QCFLAG_FAILED))
1599 /* okay, this error is ours */
1600 rc = ata_eh_read_log_10h(dev, &tag, &tf);
1602 ata_link_printk(link, KERN_ERR, "failed to read log page 10h "
1603 "(errno=%d)\n", rc);
1607 if (!(link->sactive & (1 << tag))) {
1608 ata_link_printk(link, KERN_ERR, "log page 10h reported "
1609 "inactive tag %d\n", tag);
1613 /* we've got the perpetrator, condemn it */
1614 qc = __ata_qc_from_tag(ap, tag);
1615 memcpy(&qc->result_tf, &tf, sizeof(tf));
1616 qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
1617 qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
1618 ehc->i.err_mask &= ~AC_ERR_DEV;
1622 * ata_eh_analyze_tf - analyze taskfile of a failed qc
1623 * @qc: qc to analyze
1624 * @tf: Taskfile registers to analyze
1626 * Analyze taskfile of @qc and further determine cause of
1627 * failure. This function also requests ATAPI sense data if
1631 * Kernel thread context (may sleep).
1634 * Determined recovery action
1636 static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
1637 const struct ata_taskfile *tf)
1639 unsigned int tmp, action = 0;
1640 u8 stat = tf->command, err = tf->feature;
1642 if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
1643 qc->err_mask |= AC_ERR_HSM;
1644 return ATA_EH_RESET;
1647 if (stat & (ATA_ERR | ATA_DF))
1648 qc->err_mask |= AC_ERR_DEV;
1652 switch (qc->dev->class) {
1655 qc->err_mask |= AC_ERR_ATA_BUS;
1657 qc->err_mask |= AC_ERR_MEDIA;
1659 qc->err_mask |= AC_ERR_INVALID;
1663 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
1664 tmp = atapi_eh_request_sense(qc->dev,
1665 qc->scsicmd->sense_buffer,
1666 qc->result_tf.feature >> 4);
1668 /* ATA_QCFLAG_SENSE_VALID is used to
1669 * tell atapi_qc_complete() that sense
1670 * data is already valid.
1672 * TODO: interpret sense data and set
1673 * appropriate err_mask.
1675 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1677 qc->err_mask |= tmp;
1681 if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
1682 action |= ATA_EH_RESET;
1687 static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
1692 if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
1696 base = ATA_ECAT_DUBIOUS_NONE;
1698 if (err_mask & AC_ERR_ATA_BUS)
1699 return base + ATA_ECAT_ATA_BUS;
1701 if (err_mask & AC_ERR_TIMEOUT)
1702 return base + ATA_ECAT_TOUT_HSM;
1704 if (eflags & ATA_EFLAG_IS_IO) {
1705 if (err_mask & AC_ERR_HSM)
1706 return base + ATA_ECAT_TOUT_HSM;
1708 (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
1709 return base + ATA_ECAT_UNK_DEV;
1715 struct speed_down_verdict_arg {
1718 int nr_errors[ATA_ECAT_NR];
1721 static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
1723 struct speed_down_verdict_arg *arg = void_arg;
1726 if (ent->timestamp < arg->since)
1729 cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
1731 arg->nr_errors[cat]++;
1737 * ata_eh_speed_down_verdict - Determine speed down verdict
1738 * @dev: Device of interest
1740 * This function examines error ring of @dev and determines
1741 * whether NCQ needs to be turned off, transfer speed should be
1742 * stepped down, or falling back to PIO is necessary.
1744 * ECAT_ATA_BUS : ATA_BUS error for any command
1746 * ECAT_TOUT_HSM : TIMEOUT for any command or HSM violation for
1749 * ECAT_UNK_DEV : Unknown DEV error for IO commands
1751 * ECAT_DUBIOUS_* : Identical to above three but occurred while
1752 * data transfer hasn't been verified.
1756 * NCQ_OFF : Turn off NCQ.
1758 * SPEED_DOWN : Speed down transfer speed but don't fall back
1761 * FALLBACK_TO_PIO : Fall back to PIO.
1763 * Even if multiple verdicts are returned, only one action is
1764 * taken per error. An action triggered by non-DUBIOUS errors
1765 * clears ering, while one triggered by DUBIOUS_* errors doesn't.
1766 * This is to expedite speed down decisions right after device is
1767 * initially configured.
1769 * The followings are speed down rules. #1 and #2 deal with
1772 * 1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors
1773 * occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO.
1775 * 2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors
1776 * occurred during last 5 mins, NCQ_OFF.
1778 * 3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
1779 * ocurred during last 5 mins, FALLBACK_TO_PIO
1781 * 4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
1782 * during last 10 mins, NCQ_OFF.
1784 * 5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6
1785 * UNK_DEV errors occurred during last 10 mins, SPEED_DOWN.
1788 * Inherited from caller.
1791 * OR of ATA_EH_SPDN_* flags.
1793 static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
1795 const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
1796 u64 j64 = get_jiffies_64();
1797 struct speed_down_verdict_arg arg;
1798 unsigned int verdict = 0;
1800 /* scan past 5 mins of error history */
1801 memset(&arg, 0, sizeof(arg));
1802 arg.since = j64 - min(j64, j5mins);
1803 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1805 if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
1806 arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
1807 verdict |= ATA_EH_SPDN_SPEED_DOWN |
1808 ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
1810 if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
1811 arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
1812 verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
1814 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1815 arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1816 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
1817 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
1819 /* scan past 10 mins of error history */
1820 memset(&arg, 0, sizeof(arg));
1821 arg.since = j64 - min(j64, j10mins);
1822 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1824 if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1825 arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
1826 verdict |= ATA_EH_SPDN_NCQ_OFF;
1828 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1829 arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
1830 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
1831 verdict |= ATA_EH_SPDN_SPEED_DOWN;
1837 * ata_eh_speed_down - record error and speed down if necessary
1838 * @dev: Failed device
1839 * @eflags: mask of ATA_EFLAG_* flags
1840 * @err_mask: err_mask of the error
1842 * Record error and examine error history to determine whether
1843 * adjusting transmission speed is necessary. It also sets
1844 * transmission limits appropriately if such adjustment is
1848 * Kernel thread context (may sleep).
1851 * Determined recovery action.
1853 static unsigned int ata_eh_speed_down(struct ata_device *dev,
1854 unsigned int eflags, unsigned int err_mask)
1856 struct ata_link *link = ata_dev_phys_link(dev);
1858 unsigned int verdict;
1859 unsigned int action = 0;
1861 /* don't bother if Cat-0 error */
1862 if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
1865 /* record error and determine whether speed down is necessary */
1866 ata_ering_record(&dev->ering, eflags, err_mask);
1867 verdict = ata_eh_speed_down_verdict(dev);
1870 if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
1871 (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
1872 ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
1873 dev->flags |= ATA_DFLAG_NCQ_OFF;
1874 ata_dev_printk(dev, KERN_WARNING,
1875 "NCQ disabled due to excessive errors\n");
1880 if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
1881 /* speed down SATA link speed if possible */
1882 if (sata_down_spd_limit(link, 0) == 0) {
1883 action |= ATA_EH_RESET;
1887 /* lower transfer mode */
1888 if (dev->spdn_cnt < 2) {
1889 static const int dma_dnxfer_sel[] =
1890 { ATA_DNXFER_DMA, ATA_DNXFER_40C };
1891 static const int pio_dnxfer_sel[] =
1892 { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
1895 if (dev->xfer_shift != ATA_SHIFT_PIO)
1896 sel = dma_dnxfer_sel[dev->spdn_cnt];
1898 sel = pio_dnxfer_sel[dev->spdn_cnt];
1902 if (ata_down_xfermask_limit(dev, sel) == 0) {
1903 action |= ATA_EH_RESET;
1909 /* Fall back to PIO? Slowing down to PIO is meaningless for
1910 * SATA ATA devices. Consider it only for PATA and SATAPI.
1912 if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
1913 (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) &&
1914 (dev->xfer_shift != ATA_SHIFT_PIO)) {
1915 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
1917 action |= ATA_EH_RESET;
1924 /* device has been slowed down, blow error history */
1925 if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS))
1926 ata_ering_clear(&dev->ering);
1931 * ata_eh_link_autopsy - analyze error and determine recovery action
1932 * @link: host link to perform autopsy on
1934 * Analyze why @link failed and determine which recovery actions
1935 * are needed. This function also sets more detailed AC_ERR_*
1936 * values and fills sense data for ATAPI CHECK SENSE.
1939 * Kernel thread context (may sleep).
1941 static void ata_eh_link_autopsy(struct ata_link *link)
1943 struct ata_port *ap = link->ap;
1944 struct ata_eh_context *ehc = &link->eh_context;
1945 struct ata_device *dev;
1946 unsigned int all_err_mask = 0, eflags = 0;
1953 if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
1956 /* obtain and analyze SError */
1957 rc = sata_scr_read(link, SCR_ERROR, &serror);
1959 ehc->i.serror |= serror;
1960 ata_eh_analyze_serror(link);
1961 } else if (rc != -EOPNOTSUPP) {
1962 /* SError read failed, force reset and probing */
1963 ehc->i.probe_mask |= ATA_ALL_DEVICES;
1964 ehc->i.action |= ATA_EH_RESET;
1965 ehc->i.err_mask |= AC_ERR_OTHER;
1968 /* analyze NCQ failure */
1969 ata_eh_analyze_ncq_error(link);
1971 /* any real error trumps AC_ERR_OTHER */
1972 if (ehc->i.err_mask & ~AC_ERR_OTHER)
1973 ehc->i.err_mask &= ~AC_ERR_OTHER;
1975 all_err_mask |= ehc->i.err_mask;
1977 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1978 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1980 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
1981 ata_dev_phys_link(qc->dev) != link)
1984 /* inherit upper level err_mask */
1985 qc->err_mask |= ehc->i.err_mask;
1988 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
1990 /* DEV errors are probably spurious in case of ATA_BUS error */
1991 if (qc->err_mask & AC_ERR_ATA_BUS)
1992 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
1995 /* any real error trumps unknown error */
1996 if (qc->err_mask & ~AC_ERR_OTHER)
1997 qc->err_mask &= ~AC_ERR_OTHER;
1999 /* SENSE_VALID trumps dev/unknown error and revalidation */
2000 if (qc->flags & ATA_QCFLAG_SENSE_VALID)
2001 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
2003 /* determine whether the command is worth retrying */
2004 if (!(qc->err_mask & AC_ERR_INVALID) &&
2005 ((qc->flags & ATA_QCFLAG_IO) || qc->err_mask != AC_ERR_DEV))
2006 qc->flags |= ATA_QCFLAG_RETRY;
2008 /* accumulate error info */
2009 ehc->i.dev = qc->dev;
2010 all_err_mask |= qc->err_mask;
2011 if (qc->flags & ATA_QCFLAG_IO)
2012 eflags |= ATA_EFLAG_IS_IO;
2015 /* enforce default EH actions */
2016 if (ap->pflags & ATA_PFLAG_FROZEN ||
2017 all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
2018 ehc->i.action |= ATA_EH_RESET;
2019 else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) ||
2020 (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV)))
2021 ehc->i.action |= ATA_EH_REVALIDATE;
2023 /* If we have offending qcs and the associated failed device,
2024 * perform per-dev EH action only on the offending device.
2027 ehc->i.dev_action[ehc->i.dev->devno] |=
2028 ehc->i.action & ATA_EH_PERDEV_MASK;
2029 ehc->i.action &= ~ATA_EH_PERDEV_MASK;
2032 /* propagate timeout to host link */
2033 if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link))
2034 ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT;
2036 /* record error and consider speeding down */
2038 if (!dev && ((ata_link_max_devices(link) == 1 &&
2039 ata_dev_enabled(link->device))))
2043 if (dev->flags & ATA_DFLAG_DUBIOUS_XFER)
2044 eflags |= ATA_EFLAG_DUBIOUS_XFER;
2045 ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask);
2052 * ata_eh_autopsy - analyze error and determine recovery action
2053 * @ap: host port to perform autopsy on
2055 * Analyze all links of @ap and determine why they failed and
2056 * which recovery actions are needed.
2059 * Kernel thread context (may sleep).
2061 void ata_eh_autopsy(struct ata_port *ap)
2063 struct ata_link *link;
2065 ata_for_each_link(link, ap, EDGE)
2066 ata_eh_link_autopsy(link);
2068 /* Handle the frigging slave link. Autopsy is done similarly
2069 * but actions and flags are transferred over to the master
2070 * link and handled from there.
2072 if (ap->slave_link) {
2073 struct ata_eh_context *mehc = &ap->link.eh_context;
2074 struct ata_eh_context *sehc = &ap->slave_link->eh_context;
2076 /* transfer control flags from master to slave */
2077 sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK;
2079 /* perform autopsy on the slave link */
2080 ata_eh_link_autopsy(ap->slave_link);
2082 /* transfer actions from slave to master and clear slave */
2083 ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2084 mehc->i.action |= sehc->i.action;
2085 mehc->i.dev_action[1] |= sehc->i.dev_action[1];
2086 mehc->i.flags |= sehc->i.flags;
2087 ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2090 /* Autopsy of fanout ports can affect host link autopsy.
2091 * Perform host link autopsy last.
2093 if (sata_pmp_attached(ap))
2094 ata_eh_link_autopsy(&ap->link);
2098 * ata_eh_link_report - report error handling to user
2099 * @link: ATA link EH is going on
2101 * Report EH to user.
2106 static void ata_eh_link_report(struct ata_link *link)
2108 struct ata_port *ap = link->ap;
2109 struct ata_eh_context *ehc = &link->eh_context;
2110 const char *frozen, *desc;
2112 int tag, nr_failed = 0;
2114 if (ehc->i.flags & ATA_EHI_QUIET)
2118 if (ehc->i.desc[0] != '\0')
2121 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2122 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2124 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2125 ata_dev_phys_link(qc->dev) != link ||
2126 ((qc->flags & ATA_QCFLAG_QUIET) &&
2127 qc->err_mask == AC_ERR_DEV))
2129 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
2135 if (!nr_failed && !ehc->i.err_mask)
2139 if (ap->pflags & ATA_PFLAG_FROZEN)
2142 memset(tries_buf, 0, sizeof(tries_buf));
2143 if (ap->eh_tries < ATA_EH_MAX_TRIES)
2144 snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
2148 ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x "
2149 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2150 ehc->i.err_mask, link->sactive, ehc->i.serror,
2151 ehc->i.action, frozen, tries_buf);
2153 ata_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc);
2155 ata_link_printk(link, KERN_ERR, "exception Emask 0x%x "
2156 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2157 ehc->i.err_mask, link->sactive, ehc->i.serror,
2158 ehc->i.action, frozen, tries_buf);
2160 ata_link_printk(link, KERN_ERR, "%s\n", desc);
2164 ata_link_printk(link, KERN_ERR,
2165 "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
2166 ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
2167 ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
2168 ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
2169 ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
2170 ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
2171 ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
2172 ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
2173 ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
2174 ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
2175 ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
2176 ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
2177 ehc->i.serror & SERR_CRC ? "BadCRC " : "",
2178 ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
2179 ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
2180 ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
2181 ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
2182 ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
2184 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2185 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2186 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
2187 const u8 *cdb = qc->cdb;
2188 char data_buf[20] = "";
2189 char cdb_buf[70] = "";
2191 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2192 ata_dev_phys_link(qc->dev) != link || !qc->err_mask)
2195 if (qc->dma_dir != DMA_NONE) {
2196 static const char *dma_str[] = {
2197 [DMA_BIDIRECTIONAL] = "bidi",
2198 [DMA_TO_DEVICE] = "out",
2199 [DMA_FROM_DEVICE] = "in",
2201 static const char *prot_str[] = {
2202 [ATA_PROT_PIO] = "pio",
2203 [ATA_PROT_DMA] = "dma",
2204 [ATA_PROT_NCQ] = "ncq",
2205 [ATAPI_PROT_PIO] = "pio",
2206 [ATAPI_PROT_DMA] = "dma",
2209 snprintf(data_buf, sizeof(data_buf), " %s %u %s",
2210 prot_str[qc->tf.protocol], qc->nbytes,
2211 dma_str[qc->dma_dir]);
2214 if (ata_is_atapi(qc->tf.protocol))
2215 snprintf(cdb_buf, sizeof(cdb_buf),
2216 "cdb %02x %02x %02x %02x %02x %02x %02x %02x "
2217 "%02x %02x %02x %02x %02x %02x %02x %02x\n ",
2218 cdb[0], cdb[1], cdb[2], cdb[3],
2219 cdb[4], cdb[5], cdb[6], cdb[7],
2220 cdb[8], cdb[9], cdb[10], cdb[11],
2221 cdb[12], cdb[13], cdb[14], cdb[15]);
2223 ata_dev_printk(qc->dev, KERN_ERR,
2224 "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
2226 "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
2227 "Emask 0x%x (%s)%s\n",
2228 cmd->command, cmd->feature, cmd->nsect,
2229 cmd->lbal, cmd->lbam, cmd->lbah,
2230 cmd->hob_feature, cmd->hob_nsect,
2231 cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
2232 cmd->device, qc->tag, data_buf, cdb_buf,
2233 res->command, res->feature, res->nsect,
2234 res->lbal, res->lbam, res->lbah,
2235 res->hob_feature, res->hob_nsect,
2236 res->hob_lbal, res->hob_lbam, res->hob_lbah,
2237 res->device, qc->err_mask, ata_err_string(qc->err_mask),
2238 qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
2240 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
2242 if (res->command & ATA_BUSY)
2243 ata_dev_printk(qc->dev, KERN_ERR,
2244 "status: { Busy }\n");
2246 ata_dev_printk(qc->dev, KERN_ERR,
2247 "status: { %s%s%s%s}\n",
2248 res->command & ATA_DRDY ? "DRDY " : "",
2249 res->command & ATA_DF ? "DF " : "",
2250 res->command & ATA_DRQ ? "DRQ " : "",
2251 res->command & ATA_ERR ? "ERR " : "");
2254 if (cmd->command != ATA_CMD_PACKET &&
2255 (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
2257 ata_dev_printk(qc->dev, KERN_ERR,
2258 "error: { %s%s%s%s}\n",
2259 res->feature & ATA_ICRC ? "ICRC " : "",
2260 res->feature & ATA_UNC ? "UNC " : "",
2261 res->feature & ATA_IDNF ? "IDNF " : "",
2262 res->feature & ATA_ABORTED ? "ABRT " : "");
2267 * ata_eh_report - report error handling to user
2268 * @ap: ATA port to report EH about
2270 * Report EH to user.
2275 void ata_eh_report(struct ata_port *ap)
2277 struct ata_link *link;
2279 ata_for_each_link(link, ap, HOST_FIRST)
2280 ata_eh_link_report(link);
2283 static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
2284 unsigned int *classes, unsigned long deadline,
2287 struct ata_device *dev;
2290 ata_for_each_dev(dev, link, ALL)
2291 classes[dev->devno] = ATA_DEV_UNKNOWN;
2293 return reset(link, classes, deadline);
2296 static int ata_eh_followup_srst_needed(struct ata_link *link,
2297 int rc, const unsigned int *classes)
2299 if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link))
2303 if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
2308 int ata_eh_reset(struct ata_link *link, int classify,
2309 ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
2310 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
2312 struct ata_port *ap = link->ap;
2313 struct ata_link *slave = ap->slave_link;
2314 struct ata_eh_context *ehc = &link->eh_context;
2315 struct ata_eh_context *sehc = &slave->eh_context;
2316 unsigned int *classes = ehc->classes;
2317 unsigned int lflags = link->flags;
2318 int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
2319 int max_tries = 0, try = 0;
2320 struct ata_link *failed_link;
2321 struct ata_device *dev;
2322 unsigned long deadline, now;
2323 ata_reset_fn_t reset;
2324 unsigned long flags;
2331 while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX)
2333 if (link->flags & ATA_LFLAG_NO_HRST)
2335 if (link->flags & ATA_LFLAG_NO_SRST)
2338 /* make sure each reset attemp is at least COOL_DOWN apart */
2339 if (ehc->i.flags & ATA_EHI_DID_RESET) {
2341 WARN_ON(time_after(ehc->last_reset, now));
2342 deadline = ata_deadline(ehc->last_reset,
2343 ATA_EH_RESET_COOL_DOWN);
2344 if (time_before(now, deadline))
2345 schedule_timeout_uninterruptible(deadline - now);
2348 spin_lock_irqsave(ap->lock, flags);
2349 ap->pflags |= ATA_PFLAG_RESETTING;
2350 spin_unlock_irqrestore(ap->lock, flags);
2352 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
2354 ata_for_each_dev(dev, link, ALL) {
2355 /* If we issue an SRST then an ATA drive (not ATAPI)
2356 * may change configuration and be in PIO0 timing. If
2357 * we do a hard reset (or are coming from power on)
2358 * this is true for ATA or ATAPI. Until we've set a
2359 * suitable controller mode we should not touch the
2360 * bus as we may be talking too fast.
2362 dev->pio_mode = XFER_PIO_0;
2364 /* If the controller has a pio mode setup function
2365 * then use it to set the chipset to rights. Don't
2366 * touch the DMA setup as that will be dealt with when
2367 * configuring devices.
2369 if (ap->ops->set_piomode)
2370 ap->ops->set_piomode(ap, dev);
2373 /* prefer hardreset */
2375 ehc->i.action &= ~ATA_EH_RESET;
2378 ehc->i.action |= ATA_EH_HARDRESET;
2379 } else if (softreset) {
2381 ehc->i.action |= ATA_EH_SOFTRESET;
2385 unsigned long deadline = ata_deadline(jiffies,
2386 ATA_EH_PRERESET_TIMEOUT);
2389 sehc->i.action &= ~ATA_EH_RESET;
2390 sehc->i.action |= ehc->i.action;
2393 rc = prereset(link, deadline);
2395 /* If present, do prereset on slave link too. Reset
2396 * is skipped iff both master and slave links report
2397 * -ENOENT or clear ATA_EH_RESET.
2399 if (slave && (rc == 0 || rc == -ENOENT)) {
2402 tmp = prereset(slave, deadline);
2406 ehc->i.action |= sehc->i.action;
2410 if (rc == -ENOENT) {
2411 ata_link_printk(link, KERN_DEBUG,
2412 "port disabled. ignoring.\n");
2413 ehc->i.action &= ~ATA_EH_RESET;
2415 ata_for_each_dev(dev, link, ALL)
2416 classes[dev->devno] = ATA_DEV_NONE;
2420 ata_link_printk(link, KERN_ERR,
2421 "prereset failed (errno=%d)\n", rc);
2425 /* prereset() might have cleared ATA_EH_RESET. If so,
2426 * bang classes, thaw and return.
2428 if (reset && !(ehc->i.action & ATA_EH_RESET)) {
2429 ata_for_each_dev(dev, link, ALL)
2430 classes[dev->devno] = ATA_DEV_NONE;
2431 if ((ap->pflags & ATA_PFLAG_FROZEN) &&
2432 ata_is_host_link(link))
2433 ata_eh_thaw_port(ap);
2443 if (ata_is_host_link(link))
2444 ata_eh_freeze_port(ap);
2446 deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]);
2450 ata_link_printk(link, KERN_INFO, "%s resetting link\n",
2451 reset == softreset ? "soft" : "hard");
2453 /* mark that this EH session started with reset */
2454 ehc->last_reset = jiffies;
2455 if (reset == hardreset)
2456 ehc->i.flags |= ATA_EHI_DID_HARDRESET;
2458 ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
2460 rc = ata_do_reset(link, reset, classes, deadline, true);
2461 if (rc && rc != -EAGAIN) {
2466 /* hardreset slave link if existent */
2467 if (slave && reset == hardreset) {
2471 ata_link_printk(slave, KERN_INFO,
2472 "hard resetting link\n");
2474 ata_eh_about_to_do(slave, NULL, ATA_EH_RESET);
2475 tmp = ata_do_reset(slave, reset, classes, deadline,
2483 failed_link = slave;
2489 /* perform follow-up SRST if necessary */
2490 if (reset == hardreset &&
2491 ata_eh_followup_srst_needed(link, rc, classes)) {
2495 ata_link_printk(link, KERN_ERR,
2496 "follow-up softreset required "
2497 "but no softreset avaliable\n");
2503 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
2504 rc = ata_do_reset(link, reset, classes, deadline, true);
2508 ata_link_printk(link, KERN_INFO, "no reset method "
2509 "available, skipping reset\n");
2510 if (!(lflags & ATA_LFLAG_ASSUME_CLASS))
2511 lflags |= ATA_LFLAG_ASSUME_ATA;
2515 * Post-reset processing
2517 ata_for_each_dev(dev, link, ALL) {
2518 /* After the reset, the device state is PIO 0 and the
2519 * controller state is undefined. Reset also wakes up
2520 * drives from sleeping mode.
2522 dev->pio_mode = XFER_PIO_0;
2523 dev->flags &= ~ATA_DFLAG_SLEEPING;
2525 if (!ata_phys_link_offline(ata_dev_phys_link(dev))) {
2526 /* apply class override */
2527 if (lflags & ATA_LFLAG_ASSUME_ATA)
2528 classes[dev->devno] = ATA_DEV_ATA;
2529 else if (lflags & ATA_LFLAG_ASSUME_SEMB)
2530 classes[dev->devno] = ATA_DEV_SEMB_UNSUP;
2532 classes[dev->devno] = ATA_DEV_NONE;
2535 /* record current link speed */
2536 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
2537 link->sata_spd = (sstatus >> 4) & 0xf;
2538 if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0)
2539 slave->sata_spd = (sstatus >> 4) & 0xf;
2542 if (ata_is_host_link(link))
2543 ata_eh_thaw_port(ap);
2545 /* postreset() should clear hardware SError. Although SError
2546 * is cleared during link resume, clearing SError here is
2547 * necessary as some PHYs raise hotplug events after SRST.
2548 * This introduces race condition where hotplug occurs between
2549 * reset and here. This race is mediated by cross checking
2550 * link onlineness and classification result later.
2553 postreset(link, classes);
2555 postreset(slave, classes);
2558 /* clear cached SError */
2559 spin_lock_irqsave(link->ap->lock, flags);
2560 link->eh_info.serror = 0;
2562 slave->eh_info.serror = 0;
2563 spin_unlock_irqrestore(link->ap->lock, flags);
2565 /* Make sure onlineness and classification result correspond.
2566 * Hotplug could have happened during reset and some
2567 * controllers fail to wait while a drive is spinning up after
2568 * being hotplugged causing misdetection. By cross checking
2569 * link onlineness and classification result, those conditions
2570 * can be reliably detected and retried.
2573 ata_for_each_dev(dev, link, ALL) {
2574 /* convert all ATA_DEV_UNKNOWN to ATA_DEV_NONE */
2575 if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
2576 classes[dev->devno] = ATA_DEV_NONE;
2577 if (ata_phys_link_online(ata_dev_phys_link(dev)))
2582 if (classify && nr_unknown) {
2583 if (try < max_tries) {
2584 ata_link_printk(link, KERN_WARNING, "link online but "
2585 "device misclassified, retrying\n");
2590 ata_link_printk(link, KERN_WARNING,
2591 "link online but device misclassified, "
2592 "device detection might fail\n");
2595 /* reset successful, schedule revalidation */
2596 ata_eh_done(link, NULL, ATA_EH_RESET);
2598 ata_eh_done(slave, NULL, ATA_EH_RESET);
2599 ehc->last_reset = jiffies; /* update to completion time */
2600 ehc->i.action |= ATA_EH_REVALIDATE;
2604 /* clear hotplug flag */
2605 ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
2607 sehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
2609 spin_lock_irqsave(ap->lock, flags);
2610 ap->pflags &= ~ATA_PFLAG_RESETTING;
2611 spin_unlock_irqrestore(ap->lock, flags);
2616 /* if SCR isn't accessible on a fan-out port, PMP needs to be reset */
2617 if (!ata_is_host_link(link) &&
2618 sata_scr_read(link, SCR_STATUS, &sstatus))
2621 if (rc == -ERESTART || try >= max_tries)
2625 if (time_before(now, deadline)) {
2626 unsigned long delta = deadline - now;
2628 ata_link_printk(failed_link, KERN_WARNING,
2629 "reset failed (errno=%d), retrying in %u secs\n",
2630 rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));
2633 delta = schedule_timeout_uninterruptible(delta);
2636 if (try == max_tries - 1) {
2637 sata_down_spd_limit(link, 0);
2639 sata_down_spd_limit(slave, 0);
2640 } else if (rc == -EPIPE)
2641 sata_down_spd_limit(failed_link, 0);
2648 static inline void ata_eh_pull_park_action(struct ata_port *ap)
2650 struct ata_link *link;
2651 struct ata_device *dev;
2652 unsigned long flags;
2655 * This function can be thought of as an extended version of
2656 * ata_eh_about_to_do() specially crafted to accommodate the
2657 * requirements of ATA_EH_PARK handling. Since the EH thread
2658 * does not leave the do {} while () loop in ata_eh_recover as
2659 * long as the timeout for a park request to *one* device on
2660 * the port has not expired, and since we still want to pick
2661 * up park requests to other devices on the same port or
2662 * timeout updates for the same device, we have to pull
2663 * ATA_EH_PARK actions from eh_info into eh_context.i
2664 * ourselves at the beginning of each pass over the loop.
2666 * Additionally, all write accesses to &ap->park_req_pending
2667 * through INIT_COMPLETION() (see below) or complete_all()
2668 * (see ata_scsi_park_store()) are protected by the host lock.
2669 * As a result we have that park_req_pending.done is zero on
2670 * exit from this function, i.e. when ATA_EH_PARK actions for
2671 * *all* devices on port ap have been pulled into the
2672 * respective eh_context structs. If, and only if,
2673 * park_req_pending.done is non-zero by the time we reach
2674 * wait_for_completion_timeout(), another ATA_EH_PARK action
2675 * has been scheduled for at least one of the devices on port
2676 * ap and we have to cycle over the do {} while () loop in
2677 * ata_eh_recover() again.
2680 spin_lock_irqsave(ap->lock, flags);
2681 INIT_COMPLETION(ap->park_req_pending);
2682 ata_for_each_link(link, ap, EDGE) {
2683 ata_for_each_dev(dev, link, ALL) {
2684 struct ata_eh_info *ehi = &link->eh_info;
2686 link->eh_context.i.dev_action[dev->devno] |=
2687 ehi->dev_action[dev->devno] & ATA_EH_PARK;
2688 ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK);
2691 spin_unlock_irqrestore(ap->lock, flags);
2694 static void ata_eh_park_issue_cmd(struct ata_device *dev, int park)
2696 struct ata_eh_context *ehc = &dev->link->eh_context;
2697 struct ata_taskfile tf;
2698 unsigned int err_mask;
2700 ata_tf_init(dev, &tf);
2702 ehc->unloaded_mask |= 1 << dev->devno;
2703 tf.command = ATA_CMD_IDLEIMMEDIATE;
2709 ehc->unloaded_mask &= ~(1 << dev->devno);
2710 tf.command = ATA_CMD_CHK_POWER;
2713 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
2714 tf.protocol |= ATA_PROT_NODATA;
2715 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
2716 if (park && (err_mask || tf.lbal != 0xc4)) {
2717 ata_dev_printk(dev, KERN_ERR, "head unload failed!\n");
2718 ehc->unloaded_mask &= ~(1 << dev->devno);
2722 static int ata_eh_revalidate_and_attach(struct ata_link *link,
2723 struct ata_device **r_failed_dev)
2725 struct ata_port *ap = link->ap;
2726 struct ata_eh_context *ehc = &link->eh_context;
2727 struct ata_device *dev;
2728 unsigned int new_mask = 0;
2729 unsigned long flags;
2734 /* For PATA drive side cable detection to work, IDENTIFY must
2735 * be done backwards such that PDIAG- is released by the slave
2736 * device before the master device is identified.
2738 ata_for_each_dev(dev, link, ALL_REVERSE) {
2739 unsigned int action = ata_eh_dev_action(dev);
2740 unsigned int readid_flags = 0;
2742 if (ehc->i.flags & ATA_EHI_DID_RESET)
2743 readid_flags |= ATA_READID_POSTRESET;
2745 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
2746 WARN_ON(dev->class == ATA_DEV_PMP);
2748 if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
2753 ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
2754 rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
2759 ata_eh_done(link, dev, ATA_EH_REVALIDATE);
2761 /* Configuration may have changed, reconfigure
2764 ehc->i.flags |= ATA_EHI_SETMODE;
2766 /* schedule the scsi_rescan_device() here */
2767 queue_work(ata_aux_wq, &(ap->scsi_rescan_task));
2768 } else if (dev->class == ATA_DEV_UNKNOWN &&
2769 ehc->tries[dev->devno] &&
2770 ata_class_enabled(ehc->classes[dev->devno])) {
2771 dev->class = ehc->classes[dev->devno];
2773 if (dev->class == ATA_DEV_PMP)
2774 rc = sata_pmp_attach(dev);
2776 rc = ata_dev_read_id(dev, &dev->class,
2777 readid_flags, dev->id);
2780 /* clear error info accumulated during probe */
2781 ata_ering_clear(&dev->ering);
2782 new_mask |= 1 << dev->devno;
2785 /* IDENTIFY was issued to non-existent
2786 * device. No need to reset. Just
2787 * thaw and kill the device.
2789 ata_eh_thaw_port(ap);
2790 dev->class = ATA_DEV_UNKNOWN;
2793 dev->class = ATA_DEV_UNKNOWN;
2799 /* PDIAG- should have been released, ask cable type if post-reset */
2800 if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) {
2801 if (ap->ops->cable_detect)
2802 ap->cbl = ap->ops->cable_detect(ap);
2806 /* Configure new devices forward such that user doesn't see
2807 * device detection messages backwards.
2809 ata_for_each_dev(dev, link, ALL) {
2810 if (!(new_mask & (1 << dev->devno)) ||
2811 dev->class == ATA_DEV_PMP)
2814 ehc->i.flags |= ATA_EHI_PRINTINFO;
2815 rc = ata_dev_configure(dev);
2816 ehc->i.flags &= ~ATA_EHI_PRINTINFO;
2820 spin_lock_irqsave(ap->lock, flags);
2821 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
2822 spin_unlock_irqrestore(ap->lock, flags);
2824 /* new device discovered, configure xfermode */
2825 ehc->i.flags |= ATA_EHI_SETMODE;
2831 *r_failed_dev = dev;
2832 DPRINTK("EXIT rc=%d\n", rc);
2837 * ata_set_mode - Program timings and issue SET FEATURES - XFER
2838 * @link: link on which timings will be programmed
2839 * @r_failed_dev: out paramter for failed device
2841 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If
2842 * ata_set_mode() fails, pointer to the failing device is
2843 * returned in @r_failed_dev.
2846 * PCI/etc. bus probe sem.
2849 * 0 on success, negative errno otherwise
2851 int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
2853 struct ata_port *ap = link->ap;
2854 struct ata_device *dev;
2857 /* if data transfer is verified, clear DUBIOUS_XFER on ering top */
2858 ata_for_each_dev(dev, link, ENABLED) {
2859 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) {
2860 struct ata_ering_entry *ent;
2862 ent = ata_ering_top(&dev->ering);
2864 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER;
2868 /* has private set_mode? */
2869 if (ap->ops->set_mode)
2870 rc = ap->ops->set_mode(link, r_failed_dev);
2872 rc = ata_do_set_mode(link, r_failed_dev);
2874 /* if transfer mode has changed, set DUBIOUS_XFER on device */
2875 ata_for_each_dev(dev, link, ENABLED) {
2876 struct ata_eh_context *ehc = &link->eh_context;
2877 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno];
2878 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno));
2880 if (dev->xfer_mode != saved_xfer_mode ||
2881 ata_ncq_enabled(dev) != saved_ncq)
2882 dev->flags |= ATA_DFLAG_DUBIOUS_XFER;
2889 * atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset
2890 * @dev: ATAPI device to clear UA for
2892 * Resets and other operations can make an ATAPI device raise
2893 * UNIT ATTENTION which causes the next operation to fail. This
2894 * function clears UA.
2897 * EH context (may sleep).
2900 * 0 on success, -errno on failure.
2902 static int atapi_eh_clear_ua(struct ata_device *dev)
2906 for (i = 0; i < ATA_EH_UA_TRIES; i++) {
2907 u8 *sense_buffer = dev->link->ap->sector_buf;
2909 unsigned int err_mask;
2911 err_mask = atapi_eh_tur(dev, &sense_key);
2912 if (err_mask != 0 && err_mask != AC_ERR_DEV) {
2913 ata_dev_printk(dev, KERN_WARNING, "TEST_UNIT_READY "
2914 "failed (err_mask=0x%x)\n", err_mask);
2918 if (!err_mask || sense_key != UNIT_ATTENTION)
2921 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key);
2923 ata_dev_printk(dev, KERN_WARNING, "failed to clear "
2924 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask);
2929 ata_dev_printk(dev, KERN_WARNING,
2930 "UNIT ATTENTION persists after %d tries\n", ATA_EH_UA_TRIES);
2935 static int ata_link_nr_enabled(struct ata_link *link)
2937 struct ata_device *dev;
2940 ata_for_each_dev(dev, link, ENABLED)
2945 static int ata_link_nr_vacant(struct ata_link *link)
2947 struct ata_device *dev;
2950 ata_for_each_dev(dev, link, ALL)
2951 if (dev->class == ATA_DEV_UNKNOWN)
2956 static int ata_eh_skip_recovery(struct ata_link *link)
2958 struct ata_port *ap = link->ap;
2959 struct ata_eh_context *ehc = &link->eh_context;
2960 struct ata_device *dev;
2962 /* skip disabled links */
2963 if (link->flags & ATA_LFLAG_DISABLED)
2966 /* thaw frozen port and recover failed devices */
2967 if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link))
2970 /* reset at least once if reset is requested */
2971 if ((ehc->i.action & ATA_EH_RESET) &&
2972 !(ehc->i.flags & ATA_EHI_DID_RESET))
2975 /* skip if class codes for all vacant slots are ATA_DEV_NONE */
2976 ata_for_each_dev(dev, link, ALL) {
2977 if (dev->class == ATA_DEV_UNKNOWN &&
2978 ehc->classes[dev->devno] != ATA_DEV_NONE)
2985 static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg)
2987 u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL);
2988 u64 now = get_jiffies_64();
2989 int *trials = void_arg;
2991 if (ent->timestamp < now - min(now, interval))
2998 static int ata_eh_schedule_probe(struct ata_device *dev)
3000 struct ata_eh_context *ehc = &dev->link->eh_context;
3001 struct ata_link *link = ata_dev_phys_link(dev);
3004 if (!(ehc->i.probe_mask & (1 << dev->devno)) ||
3005 (ehc->did_probe_mask & (1 << dev->devno)))
3008 ata_eh_detach_dev(dev);
3010 ehc->did_probe_mask |= (1 << dev->devno);
3011 ehc->i.action |= ATA_EH_RESET;
3012 ehc->saved_xfer_mode[dev->devno] = 0;
3013 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
3015 /* Record and count probe trials on the ering. The specific
3016 * error mask used is irrelevant. Because a successful device
3017 * detection clears the ering, this count accumulates only if
3018 * there are consecutive failed probes.
3020 * If the count is equal to or higher than ATA_EH_PROBE_TRIALS
3021 * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is
3022 * forced to 1.5Gbps.
3024 * This is to work around cases where failed link speed
3025 * negotiation results in device misdetection leading to
3026 * infinite DEVXCHG or PHRDY CHG events.
3028 ata_ering_record(&dev->ering, 0, AC_ERR_OTHER);
3029 ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials);
3031 if (trials > ATA_EH_PROBE_TRIALS)
3032 sata_down_spd_limit(link, 1);
3037 static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
3039 struct ata_eh_context *ehc = &dev->link->eh_context;
3041 /* -EAGAIN from EH routine indicates retry without prejudice.
3042 * The requester is responsible for ensuring forward progress.
3045 ehc->tries[dev->devno]--;
3049 /* device missing or wrong IDENTIFY data, schedule probing */
3050 ehc->i.probe_mask |= (1 << dev->devno);
3052 /* give it just one more chance */
3053 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
3055 if (ehc->tries[dev->devno] == 1) {
3056 /* This is the last chance, better to slow
3057 * down than lose it.
3059 sata_down_spd_limit(ata_dev_phys_link(dev), 0);
3060 if (dev->pio_mode > XFER_PIO_0)
3061 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
3065 if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
3066 /* disable device if it has used up all its chances */
3067 ata_dev_disable(dev);
3069 /* detach if offline */
3070 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
3071 ata_eh_detach_dev(dev);
3073 /* schedule probe if necessary */
3074 if (ata_eh_schedule_probe(dev)) {
3075 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
3076 memset(ehc->cmd_timeout_idx[dev->devno], 0,
3077 sizeof(ehc->cmd_timeout_idx[dev->devno]));
3082 ehc->i.action |= ATA_EH_RESET;
3088 * ata_eh_recover - recover host port after error
3089 * @ap: host port to recover
3090 * @prereset: prereset method (can be NULL)
3091 * @softreset: softreset method (can be NULL)
3092 * @hardreset: hardreset method (can be NULL)
3093 * @postreset: postreset method (can be NULL)
3094 * @r_failed_link: out parameter for failed link
3096 * This is the alpha and omega, eum and yang, heart and soul of
3097 * libata exception handling. On entry, actions required to
3098 * recover each link and hotplug requests are recorded in the
3099 * link's eh_context. This function executes all the operations
3100 * with appropriate retrials and fallbacks to resurrect failed
3101 * devices, detach goners and greet newcomers.
3104 * Kernel thread context (may sleep).
3107 * 0 on success, -errno on failure.
3109 int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
3110 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3111 ata_postreset_fn_t postreset,
3112 struct ata_link **r_failed_link)
3114 struct ata_link *link;
3115 struct ata_device *dev;
3118 unsigned long flags, deadline;
3122 /* prep for recovery */
3123 ata_for_each_link(link, ap, EDGE) {
3124 struct ata_eh_context *ehc = &link->eh_context;
3126 /* re-enable link? */
3127 if (ehc->i.action & ATA_EH_ENABLE_LINK) {
3128 ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
3129 spin_lock_irqsave(ap->lock, flags);
3130 link->flags &= ~ATA_LFLAG_DISABLED;
3131 spin_unlock_irqrestore(ap->lock, flags);
3132 ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
3135 ata_for_each_dev(dev, link, ALL) {
3136 if (link->flags & ATA_LFLAG_NO_RETRY)
3137 ehc->tries[dev->devno] = 1;
3139 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
3141 /* collect port action mask recorded in dev actions */
3142 ehc->i.action |= ehc->i.dev_action[dev->devno] &
3143 ~ATA_EH_PERDEV_MASK;
3144 ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
3146 /* process hotplug request */
3147 if (dev->flags & ATA_DFLAG_DETACH)
3148 ata_eh_detach_dev(dev);
3150 /* schedule probe if necessary */
3151 if (!ata_dev_enabled(dev))
3152 ata_eh_schedule_probe(dev);
3160 /* if UNLOADING, finish immediately */
3161 if (ap->pflags & ATA_PFLAG_UNLOADING)
3165 ata_for_each_link(link, ap, EDGE) {
3166 struct ata_eh_context *ehc = &link->eh_context;
3168 /* skip EH if possible. */
3169 if (ata_eh_skip_recovery(link))
3172 ata_for_each_dev(dev, link, ALL)
3173 ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
3177 ata_for_each_link(link, ap, EDGE) {
3178 struct ata_eh_context *ehc = &link->eh_context;
3180 if (!(ehc->i.action & ATA_EH_RESET))
3183 rc = ata_eh_reset(link, ata_link_nr_vacant(link),
3184 prereset, softreset, hardreset, postreset);
3186 ata_link_printk(link, KERN_ERR,
3187 "reset failed, giving up\n");
3196 * clears ATA_EH_PARK in eh_info and resets
3197 * ap->park_req_pending
3199 ata_eh_pull_park_action(ap);
3202 ata_for_each_link(link, ap, EDGE) {
3203 ata_for_each_dev(dev, link, ALL) {
3204 struct ata_eh_context *ehc = &link->eh_context;
3207 if (dev->class != ATA_DEV_ATA)
3209 if (!(ehc->i.dev_action[dev->devno] &
3212 tmp = dev->unpark_deadline;
3213 if (time_before(deadline, tmp))
3215 else if (time_before_eq(tmp, jiffies))
3217 if (ehc->unloaded_mask & (1 << dev->devno))
3220 ata_eh_park_issue_cmd(dev, 1);
3225 if (time_before_eq(deadline, now))
3228 deadline = wait_for_completion_timeout(&ap->park_req_pending,
3231 ata_for_each_link(link, ap, EDGE) {
3232 ata_for_each_dev(dev, link, ALL) {
3233 if (!(link->eh_context.unloaded_mask &
3237 ata_eh_park_issue_cmd(dev, 0);
3238 ata_eh_done(link, dev, ATA_EH_PARK);
3243 ata_for_each_link(link, ap, EDGE) {
3244 struct ata_eh_context *ehc = &link->eh_context;
3246 /* revalidate existing devices and attach new ones */
3247 rc = ata_eh_revalidate_and_attach(link, &dev);
3251 /* if PMP got attached, return, pmp EH will take care of it */
3252 if (link->device->class == ATA_DEV_PMP) {
3257 /* configure transfer mode if necessary */
3258 if (ehc->i.flags & ATA_EHI_SETMODE) {
3259 rc = ata_set_mode(link, &dev);
3262 ehc->i.flags &= ~ATA_EHI_SETMODE;
3265 /* If reset has been issued, clear UA to avoid
3266 * disrupting the current users of the device.
3268 if (ehc->i.flags & ATA_EHI_DID_RESET) {
3269 ata_for_each_dev(dev, link, ALL) {
3270 if (dev->class != ATA_DEV_ATAPI)
3272 rc = atapi_eh_clear_ua(dev);
3278 /* configure link power saving */
3279 if (ehc->i.action & ATA_EH_LPM)
3280 ata_for_each_dev(dev, link, ALL)
3281 ata_dev_enable_pm(dev, ap->pm_policy);
3283 /* this link is okay now */
3289 ata_eh_handle_dev_fail(dev, rc);
3291 if (ap->pflags & ATA_PFLAG_FROZEN) {
3292 /* PMP reset requires working host port.
3293 * Can't retry if it's frozen.
3295 if (sata_pmp_attached(ap))
3305 if (rc && r_failed_link)
3306 *r_failed_link = link;
3308 DPRINTK("EXIT, rc=%d\n", rc);
3313 * ata_eh_finish - finish up EH
3314 * @ap: host port to finish EH for
3316 * Recovery is complete. Clean up EH states and retry or finish
3322 void ata_eh_finish(struct ata_port *ap)
3326 /* retry or finish qcs */
3327 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
3328 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
3330 if (!(qc->flags & ATA_QCFLAG_FAILED))
3334 /* FIXME: Once EH migration is complete,
3335 * generate sense data in this function,
3336 * considering both err_mask and tf.
3338 if (qc->flags & ATA_QCFLAG_RETRY)
3339 ata_eh_qc_retry(qc);
3341 ata_eh_qc_complete(qc);
3343 if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
3344 ata_eh_qc_complete(qc);
3346 /* feed zero TF to sense generation */
3347 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
3348 ata_eh_qc_retry(qc);
3353 /* make sure nr_active_links is zero after EH */
3354 WARN_ON(ap->nr_active_links);
3355 ap->nr_active_links = 0;
3359 * ata_do_eh - do standard error handling
3360 * @ap: host port to handle error for
3362 * @prereset: prereset method (can be NULL)
3363 * @softreset: softreset method (can be NULL)
3364 * @hardreset: hardreset method (can be NULL)
3365 * @postreset: postreset method (can be NULL)
3367 * Perform standard error handling sequence.
3370 * Kernel thread context (may sleep).
3372 void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
3373 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3374 ata_postreset_fn_t postreset)
3376 struct ata_device *dev;
3382 rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
3385 ata_for_each_dev(dev, &ap->link, ALL)
3386 ata_dev_disable(dev);
3393 * ata_std_error_handler - standard error handler
3394 * @ap: host port to handle error for
3396 * Standard error handler
3399 * Kernel thread context (may sleep).
3401 void ata_std_error_handler(struct ata_port *ap)
3403 struct ata_port_operations *ops = ap->ops;
3404 ata_reset_fn_t hardreset = ops->hardreset;
3406 /* ignore built-in hardreset if SCR access is not available */
3407 if (ata_is_builtin_hardreset(hardreset) && !sata_scr_valid(&ap->link))
3410 ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);
3415 * ata_eh_handle_port_suspend - perform port suspend operation
3416 * @ap: port to suspend
3421 * Kernel thread context (may sleep).
3423 static void ata_eh_handle_port_suspend(struct ata_port *ap)
3425 unsigned long flags;
3428 /* are we suspending? */
3429 spin_lock_irqsave(ap->lock, flags);
3430 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
3431 ap->pm_mesg.event == PM_EVENT_ON) {
3432 spin_unlock_irqrestore(ap->lock, flags);
3435 spin_unlock_irqrestore(ap->lock, flags);
3437 WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
3439 /* tell ACPI we're suspending */
3440 rc = ata_acpi_on_suspend(ap);
3445 ata_eh_freeze_port(ap);
3447 if (ap->ops->port_suspend)
3448 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
3450 ata_acpi_set_state(ap, PMSG_SUSPEND);
3453 spin_lock_irqsave(ap->lock, flags);
3455 ap->pflags &= ~ATA_PFLAG_PM_PENDING;
3457 ap->pflags |= ATA_PFLAG_SUSPENDED;
3458 else if (ap->pflags & ATA_PFLAG_FROZEN)
3459 ata_port_schedule_eh(ap);
3461 if (ap->pm_result) {
3462 *ap->pm_result = rc;
3463 ap->pm_result = NULL;
3466 spin_unlock_irqrestore(ap->lock, flags);
3472 * ata_eh_handle_port_resume - perform port resume operation
3473 * @ap: port to resume
3478 * Kernel thread context (may sleep).
3480 static void ata_eh_handle_port_resume(struct ata_port *ap)
3482 unsigned long flags;
3485 /* are we resuming? */
3486 spin_lock_irqsave(ap->lock, flags);
3487 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
3488 ap->pm_mesg.event != PM_EVENT_ON) {
3489 spin_unlock_irqrestore(ap->lock, flags);
3492 spin_unlock_irqrestore(ap->lock, flags);
3494 WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
3496 ata_acpi_set_state(ap, PMSG_ON);
3498 if (ap->ops->port_resume)
3499 rc = ap->ops->port_resume(ap);
3501 /* tell ACPI that we're resuming */
3502 ata_acpi_on_resume(ap);
3505 spin_lock_irqsave(ap->lock, flags);
3506 ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
3507 if (ap->pm_result) {
3508 *ap->pm_result = rc;
3509 ap->pm_result = NULL;
3511 spin_unlock_irqrestore(ap->lock, flags);
3513 #endif /* CONFIG_PM */