Merge git://git.kernel.org/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog
[linux-2.6] / drivers / ata / libata-eh.c
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 /**
563  *      ata_qc_timeout - Handle timeout of queued command
564  *      @qc: Command that timed out
565  *
566  *      Some part of the kernel (currently, only the SCSI layer)
567  *      has noticed that the active command on port @ap has not
568  *      completed after a specified length of time.  Handle this
569  *      condition by disabling DMA (if necessary) and completing
570  *      transactions, with error if necessary.
571  *
572  *      This also handles the case of the "lost interrupt", where
573  *      for some reason (possibly hardware bug, possibly driver bug)
574  *      an interrupt was not delivered to the driver, even though the
575  *      transaction completed successfully.
576  *
577  *      TODO: kill this function once old EH is gone.
578  *
579  *      LOCKING:
580  *      Inherited from SCSI layer (none, can sleep)
581  */
582 static void ata_qc_timeout(struct ata_queued_cmd *qc)
583 {
584         struct ata_port *ap = qc->ap;
585         u8 host_stat = 0, drv_stat;
586         unsigned long flags;
587
588         DPRINTK("ENTER\n");
589
590         ap->hsm_task_state = HSM_ST_IDLE;
591
592         spin_lock_irqsave(ap->lock, flags);
593
594         switch (qc->tf.protocol) {
595
596         case ATA_PROT_DMA:
597         case ATA_PROT_ATAPI_DMA:
598                 host_stat = ap->ops->bmdma_status(ap);
599
600                 /* before we do anything else, clear DMA-Start bit */
601                 ap->ops->bmdma_stop(qc);
602
603                 /* fall through */
604
605         default:
606                 ata_altstatus(ap);
607                 drv_stat = ata_chk_status(ap);
608
609                 /* ack bmdma irq events */
610                 ap->ops->irq_clear(ap);
611
612                 ata_dev_printk(qc->dev, KERN_ERR, "command 0x%x timeout, "
613                                "stat 0x%x host_stat 0x%x\n",
614                                qc->tf.command, drv_stat, host_stat);
615
616                 /* complete taskfile transaction */
617                 qc->err_mask |= AC_ERR_TIMEOUT;
618                 break;
619         }
620
621         spin_unlock_irqrestore(ap->lock, flags);
622
623         ata_eh_qc_complete(qc);
624
625         DPRINTK("EXIT\n");
626 }
627
628 /**
629  *      ata_eng_timeout - Handle timeout of queued command
630  *      @ap: Port on which timed-out command is active
631  *
632  *      Some part of the kernel (currently, only the SCSI layer)
633  *      has noticed that the active command on port @ap has not
634  *      completed after a specified length of time.  Handle this
635  *      condition by disabling DMA (if necessary) and completing
636  *      transactions, with error if necessary.
637  *
638  *      This also handles the case of the "lost interrupt", where
639  *      for some reason (possibly hardware bug, possibly driver bug)
640  *      an interrupt was not delivered to the driver, even though the
641  *      transaction completed successfully.
642  *
643  *      TODO: kill this function once old EH is gone.
644  *
645  *      LOCKING:
646  *      Inherited from SCSI layer (none, can sleep)
647  */
648 void ata_eng_timeout(struct ata_port *ap)
649 {
650         DPRINTK("ENTER\n");
651
652         ata_qc_timeout(ata_qc_from_tag(ap, ap->link.active_tag));
653
654         DPRINTK("EXIT\n");
655 }
656
657 static int ata_eh_nr_in_flight(struct ata_port *ap)
658 {
659         unsigned int tag;
660         int nr = 0;
661
662         /* count only non-internal commands */
663         for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
664                 if (ata_qc_from_tag(ap, tag))
665                         nr++;
666
667         return nr;
668 }
669
670 void ata_eh_fastdrain_timerfn(unsigned long arg)
671 {
672         struct ata_port *ap = (void *)arg;
673         unsigned long flags;
674         int cnt;
675
676         spin_lock_irqsave(ap->lock, flags);
677
678         cnt = ata_eh_nr_in_flight(ap);
679
680         /* are we done? */
681         if (!cnt)
682                 goto out_unlock;
683
684         if (cnt == ap->fastdrain_cnt) {
685                 unsigned int tag;
686
687                 /* No progress during the last interval, tag all
688                  * in-flight qcs as timed out and freeze the port.
689                  */
690                 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
691                         struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
692                         if (qc)
693                                 qc->err_mask |= AC_ERR_TIMEOUT;
694                 }
695
696                 ata_port_freeze(ap);
697         } else {
698                 /* some qcs have finished, give it another chance */
699                 ap->fastdrain_cnt = cnt;
700                 ap->fastdrain_timer.expires =
701                         jiffies + ATA_EH_FASTDRAIN_INTERVAL;
702                 add_timer(&ap->fastdrain_timer);
703         }
704
705  out_unlock:
706         spin_unlock_irqrestore(ap->lock, flags);
707 }
708
709 /**
710  *      ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
711  *      @ap: target ATA port
712  *      @fastdrain: activate fast drain
713  *
714  *      Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
715  *      is non-zero and EH wasn't pending before.  Fast drain ensures
716  *      that EH kicks in in timely manner.
717  *
718  *      LOCKING:
719  *      spin_lock_irqsave(host lock)
720  */
721 static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
722 {
723         int cnt;
724
725         /* already scheduled? */
726         if (ap->pflags & ATA_PFLAG_EH_PENDING)
727                 return;
728
729         ap->pflags |= ATA_PFLAG_EH_PENDING;
730
731         if (!fastdrain)
732                 return;
733
734         /* do we have in-flight qcs? */
735         cnt = ata_eh_nr_in_flight(ap);
736         if (!cnt)
737                 return;
738
739         /* activate fast drain */
740         ap->fastdrain_cnt = cnt;
741         ap->fastdrain_timer.expires = jiffies + ATA_EH_FASTDRAIN_INTERVAL;
742         add_timer(&ap->fastdrain_timer);
743 }
744
745 /**
746  *      ata_qc_schedule_eh - schedule qc for error handling
747  *      @qc: command to schedule error handling for
748  *
749  *      Schedule error handling for @qc.  EH will kick in as soon as
750  *      other commands are drained.
751  *
752  *      LOCKING:
753  *      spin_lock_irqsave(host lock)
754  */
755 void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
756 {
757         struct ata_port *ap = qc->ap;
758
759         WARN_ON(!ap->ops->error_handler);
760
761         qc->flags |= ATA_QCFLAG_FAILED;
762         ata_eh_set_pending(ap, 1);
763
764         /* The following will fail if timeout has already expired.
765          * ata_scsi_error() takes care of such scmds on EH entry.
766          * Note that ATA_QCFLAG_FAILED is unconditionally set after
767          * this function completes.
768          */
769         scsi_req_abort_cmd(qc->scsicmd);
770 }
771
772 /**
773  *      ata_port_schedule_eh - schedule error handling without a qc
774  *      @ap: ATA port to schedule EH for
775  *
776  *      Schedule error handling for @ap.  EH will kick in as soon as
777  *      all commands are drained.
778  *
779  *      LOCKING:
780  *      spin_lock_irqsave(host lock)
781  */
782 void ata_port_schedule_eh(struct ata_port *ap)
783 {
784         WARN_ON(!ap->ops->error_handler);
785
786         if (ap->pflags & ATA_PFLAG_INITIALIZING)
787                 return;
788
789         ata_eh_set_pending(ap, 1);
790         scsi_schedule_eh(ap->scsi_host);
791
792         DPRINTK("port EH scheduled\n");
793 }
794
795 static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
796 {
797         int tag, nr_aborted = 0;
798
799         WARN_ON(!ap->ops->error_handler);
800
801         /* we're gonna abort all commands, no need for fast drain */
802         ata_eh_set_pending(ap, 0);
803
804         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
805                 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
806
807                 if (qc && (!link || qc->dev->link == link)) {
808                         qc->flags |= ATA_QCFLAG_FAILED;
809                         ata_qc_complete(qc);
810                         nr_aborted++;
811                 }
812         }
813
814         if (!nr_aborted)
815                 ata_port_schedule_eh(ap);
816
817         return nr_aborted;
818 }
819
820 /**
821  *      ata_link_abort - abort all qc's on the link
822  *      @link: ATA link to abort qc's for
823  *
824  *      Abort all active qc's active on @link and schedule EH.
825  *
826  *      LOCKING:
827  *      spin_lock_irqsave(host lock)
828  *
829  *      RETURNS:
830  *      Number of aborted qc's.
831  */
832 int ata_link_abort(struct ata_link *link)
833 {
834         return ata_do_link_abort(link->ap, link);
835 }
836
837 /**
838  *      ata_port_abort - abort all qc's on the port
839  *      @ap: ATA port to abort qc's for
840  *
841  *      Abort all active qc's of @ap and schedule EH.
842  *
843  *      LOCKING:
844  *      spin_lock_irqsave(host_set lock)
845  *
846  *      RETURNS:
847  *      Number of aborted qc's.
848  */
849 int ata_port_abort(struct ata_port *ap)
850 {
851         return ata_do_link_abort(ap, NULL);
852 }
853
854 /**
855  *      __ata_port_freeze - freeze port
856  *      @ap: ATA port to freeze
857  *
858  *      This function is called when HSM violation or some other
859  *      condition disrupts normal operation of the port.  Frozen port
860  *      is not allowed to perform any operation until the port is
861  *      thawed, which usually follows a successful reset.
862  *
863  *      ap->ops->freeze() callback can be used for freezing the port
864  *      hardware-wise (e.g. mask interrupt and stop DMA engine).  If a
865  *      port cannot be frozen hardware-wise, the interrupt handler
866  *      must ack and clear interrupts unconditionally while the port
867  *      is frozen.
868  *
869  *      LOCKING:
870  *      spin_lock_irqsave(host lock)
871  */
872 static void __ata_port_freeze(struct ata_port *ap)
873 {
874         WARN_ON(!ap->ops->error_handler);
875
876         if (ap->ops->freeze)
877                 ap->ops->freeze(ap);
878
879         ap->pflags |= ATA_PFLAG_FROZEN;
880
881         DPRINTK("ata%u port frozen\n", ap->print_id);
882 }
883
884 /**
885  *      ata_port_freeze - abort & freeze port
886  *      @ap: ATA port to freeze
887  *
888  *      Abort and freeze @ap.
889  *
890  *      LOCKING:
891  *      spin_lock_irqsave(host lock)
892  *
893  *      RETURNS:
894  *      Number of aborted commands.
895  */
896 int ata_port_freeze(struct ata_port *ap)
897 {
898         int nr_aborted;
899
900         WARN_ON(!ap->ops->error_handler);
901
902         nr_aborted = ata_port_abort(ap);
903         __ata_port_freeze(ap);
904
905         return nr_aborted;
906 }
907
908 /**
909  *      sata_async_notification - SATA async notification handler
910  *      @ap: ATA port where async notification is received
911  *
912  *      Handler to be called when async notification via SDB FIS is
913  *      received.  This function schedules EH if necessary.
914  *
915  *      LOCKING:
916  *      spin_lock_irqsave(host lock)
917  *
918  *      RETURNS:
919  *      1 if EH is scheduled, 0 otherwise.
920  */
921 int sata_async_notification(struct ata_port *ap)
922 {
923         u32 sntf;
924         int rc;
925
926         if (!(ap->flags & ATA_FLAG_AN))
927                 return 0;
928
929         rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
930         if (rc == 0)
931                 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
932
933         if (!ap->nr_pmp_links || rc) {
934                 /* PMP is not attached or SNTF is not available */
935                 if (!ap->nr_pmp_links) {
936                         /* PMP is not attached.  Check whether ATAPI
937                          * AN is configured.  If so, notify media
938                          * change.
939                          */
940                         struct ata_device *dev = ap->link.device;
941
942                         if ((dev->class == ATA_DEV_ATAPI) &&
943                             (dev->flags & ATA_DFLAG_AN))
944                                 ata_scsi_media_change_notify(dev);
945                         return 0;
946                 } else {
947                         /* PMP is attached but SNTF is not available.
948                          * ATAPI async media change notification is
949                          * not used.  The PMP must be reporting PHY
950                          * status change, schedule EH.
951                          */
952                         ata_port_schedule_eh(ap);
953                         return 1;
954                 }
955         } else {
956                 /* PMP is attached and SNTF is available */
957                 struct ata_link *link;
958
959                 /* check and notify ATAPI AN */
960                 ata_port_for_each_link(link, ap) {
961                         if (!(sntf & (1 << link->pmp)))
962                                 continue;
963
964                         if ((link->device->class == ATA_DEV_ATAPI) &&
965                             (link->device->flags & ATA_DFLAG_AN))
966                                 ata_scsi_media_change_notify(link->device);
967                 }
968
969                 /* If PMP is reporting that PHY status of some
970                  * downstream ports has changed, schedule EH.
971                  */
972                 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
973                         ata_port_schedule_eh(ap);
974                         return 1;
975                 }
976
977                 return 0;
978         }
979 }
980
981 /**
982  *      ata_eh_freeze_port - EH helper to freeze port
983  *      @ap: ATA port to freeze
984  *
985  *      Freeze @ap.
986  *
987  *      LOCKING:
988  *      None.
989  */
990 void ata_eh_freeze_port(struct ata_port *ap)
991 {
992         unsigned long flags;
993
994         if (!ap->ops->error_handler)
995                 return;
996
997         spin_lock_irqsave(ap->lock, flags);
998         __ata_port_freeze(ap);
999         spin_unlock_irqrestore(ap->lock, flags);
1000 }
1001
1002 /**
1003  *      ata_port_thaw_port - EH helper to thaw port
1004  *      @ap: ATA port to thaw
1005  *
1006  *      Thaw frozen port @ap.
1007  *
1008  *      LOCKING:
1009  *      None.
1010  */
1011 void ata_eh_thaw_port(struct ata_port *ap)
1012 {
1013         unsigned long flags;
1014
1015         if (!ap->ops->error_handler)
1016                 return;
1017
1018         spin_lock_irqsave(ap->lock, flags);
1019
1020         ap->pflags &= ~ATA_PFLAG_FROZEN;
1021
1022         if (ap->ops->thaw)
1023                 ap->ops->thaw(ap);
1024
1025         spin_unlock_irqrestore(ap->lock, flags);
1026
1027         DPRINTK("ata%u port thawed\n", ap->print_id);
1028 }
1029
1030 static void ata_eh_scsidone(struct scsi_cmnd *scmd)
1031 {
1032         /* nada */
1033 }
1034
1035 static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
1036 {
1037         struct ata_port *ap = qc->ap;
1038         struct scsi_cmnd *scmd = qc->scsicmd;
1039         unsigned long flags;
1040
1041         spin_lock_irqsave(ap->lock, flags);
1042         qc->scsidone = ata_eh_scsidone;
1043         __ata_qc_complete(qc);
1044         WARN_ON(ata_tag_valid(qc->tag));
1045         spin_unlock_irqrestore(ap->lock, flags);
1046
1047         scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
1048 }
1049
1050 /**
1051  *      ata_eh_qc_complete - Complete an active ATA command from EH
1052  *      @qc: Command to complete
1053  *
1054  *      Indicate to the mid and upper layers that an ATA command has
1055  *      completed.  To be used from EH.
1056  */
1057 void ata_eh_qc_complete(struct ata_queued_cmd *qc)
1058 {
1059         struct scsi_cmnd *scmd = qc->scsicmd;
1060         scmd->retries = scmd->allowed;
1061         __ata_eh_qc_complete(qc);
1062 }
1063
1064 /**
1065  *      ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
1066  *      @qc: Command to retry
1067  *
1068  *      Indicate to the mid and upper layers that an ATA command
1069  *      should be retried.  To be used from EH.
1070  *
1071  *      SCSI midlayer limits the number of retries to scmd->allowed.
1072  *      scmd->retries is decremented for commands which get retried
1073  *      due to unrelated failures (qc->err_mask is zero).
1074  */
1075 void ata_eh_qc_retry(struct ata_queued_cmd *qc)
1076 {
1077         struct scsi_cmnd *scmd = qc->scsicmd;
1078         if (!qc->err_mask && scmd->retries)
1079                 scmd->retries--;
1080         __ata_eh_qc_complete(qc);
1081 }
1082
1083 /**
1084  *      ata_eh_detach_dev - detach ATA device
1085  *      @dev: ATA device to detach
1086  *
1087  *      Detach @dev.
1088  *
1089  *      LOCKING:
1090  *      None.
1091  */
1092 void ata_eh_detach_dev(struct ata_device *dev)
1093 {
1094         struct ata_link *link = dev->link;
1095         struct ata_port *ap = link->ap;
1096         unsigned long flags;
1097
1098         ata_dev_disable(dev);
1099
1100         spin_lock_irqsave(ap->lock, flags);
1101
1102         dev->flags &= ~ATA_DFLAG_DETACH;
1103
1104         if (ata_scsi_offline_dev(dev)) {
1105                 dev->flags |= ATA_DFLAG_DETACHED;
1106                 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
1107         }
1108
1109         /* clear per-dev EH actions */
1110         ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
1111         ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
1112
1113         spin_unlock_irqrestore(ap->lock, flags);
1114 }
1115
1116 /**
1117  *      ata_eh_about_to_do - about to perform eh_action
1118  *      @link: target ATA link
1119  *      @dev: target ATA dev for per-dev action (can be NULL)
1120  *      @action: action about to be performed
1121  *
1122  *      Called just before performing EH actions to clear related bits
1123  *      in @link->eh_info such that eh actions are not unnecessarily
1124  *      repeated.
1125  *
1126  *      LOCKING:
1127  *      None.
1128  */
1129 void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
1130                         unsigned int action)
1131 {
1132         struct ata_port *ap = link->ap;
1133         struct ata_eh_info *ehi = &link->eh_info;
1134         struct ata_eh_context *ehc = &link->eh_context;
1135         unsigned long flags;
1136
1137         spin_lock_irqsave(ap->lock, flags);
1138
1139         /* Reset is represented by combination of actions and EHI
1140          * flags.  Suck in all related bits before clearing eh_info to
1141          * avoid losing requested action.
1142          */
1143         if (action & ATA_EH_RESET_MASK) {
1144                 ehc->i.action |= ehi->action & ATA_EH_RESET_MASK;
1145                 ehc->i.flags |= ehi->flags & ATA_EHI_RESET_MODIFIER_MASK;
1146
1147                 /* make sure all reset actions are cleared & clear EHI flags */
1148                 action |= ATA_EH_RESET_MASK;
1149                 ehi->flags &= ~ATA_EHI_RESET_MODIFIER_MASK;
1150         }
1151
1152         ata_eh_clear_action(link, dev, ehi, action);
1153
1154         if (!(ehc->i.flags & ATA_EHI_QUIET))
1155                 ap->pflags |= ATA_PFLAG_RECOVERED;
1156
1157         spin_unlock_irqrestore(ap->lock, flags);
1158 }
1159
1160 /**
1161  *      ata_eh_done - EH action complete
1162 *       @ap: target ATA port
1163  *      @dev: target ATA dev for per-dev action (can be NULL)
1164  *      @action: action just completed
1165  *
1166  *      Called right after performing EH actions to clear related bits
1167  *      in @link->eh_context.
1168  *
1169  *      LOCKING:
1170  *      None.
1171  */
1172 void ata_eh_done(struct ata_link *link, struct ata_device *dev,
1173                  unsigned int action)
1174 {
1175         struct ata_eh_context *ehc = &link->eh_context;
1176
1177         /* if reset is complete, clear all reset actions & reset modifier */
1178         if (action & ATA_EH_RESET_MASK) {
1179                 action |= ATA_EH_RESET_MASK;
1180                 ehc->i.flags &= ~ATA_EHI_RESET_MODIFIER_MASK;
1181         }
1182
1183         ata_eh_clear_action(link, dev, &ehc->i, action);
1184 }
1185
1186 /**
1187  *      ata_err_string - convert err_mask to descriptive string
1188  *      @err_mask: error mask to convert to string
1189  *
1190  *      Convert @err_mask to descriptive string.  Errors are
1191  *      prioritized according to severity and only the most severe
1192  *      error is reported.
1193  *
1194  *      LOCKING:
1195  *      None.
1196  *
1197  *      RETURNS:
1198  *      Descriptive string for @err_mask
1199  */
1200 static const char *ata_err_string(unsigned int err_mask)
1201 {
1202         if (err_mask & AC_ERR_HOST_BUS)
1203                 return "host bus error";
1204         if (err_mask & AC_ERR_ATA_BUS)
1205                 return "ATA bus error";
1206         if (err_mask & AC_ERR_TIMEOUT)
1207                 return "timeout";
1208         if (err_mask & AC_ERR_HSM)
1209                 return "HSM violation";
1210         if (err_mask & AC_ERR_SYSTEM)
1211                 return "internal error";
1212         if (err_mask & AC_ERR_MEDIA)
1213                 return "media error";
1214         if (err_mask & AC_ERR_INVALID)
1215                 return "invalid argument";
1216         if (err_mask & AC_ERR_DEV)
1217                 return "device error";
1218         return "unknown error";
1219 }
1220
1221 /**
1222  *      ata_read_log_page - read a specific log page
1223  *      @dev: target device
1224  *      @page: page to read
1225  *      @buf: buffer to store read page
1226  *      @sectors: number of sectors to read
1227  *
1228  *      Read log page using READ_LOG_EXT command.
1229  *
1230  *      LOCKING:
1231  *      Kernel thread context (may sleep).
1232  *
1233  *      RETURNS:
1234  *      0 on success, AC_ERR_* mask otherwise.
1235  */
1236 static unsigned int ata_read_log_page(struct ata_device *dev,
1237                                       u8 page, void *buf, unsigned int sectors)
1238 {
1239         struct ata_taskfile tf;
1240         unsigned int err_mask;
1241
1242         DPRINTK("read log page - page %d\n", page);
1243
1244         ata_tf_init(dev, &tf);
1245         tf.command = ATA_CMD_READ_LOG_EXT;
1246         tf.lbal = page;
1247         tf.nsect = sectors;
1248         tf.hob_nsect = sectors >> 8;
1249         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
1250         tf.protocol = ATA_PROT_PIO;
1251
1252         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
1253                                      buf, sectors * ATA_SECT_SIZE, 0);
1254
1255         DPRINTK("EXIT, err_mask=%x\n", err_mask);
1256         return err_mask;
1257 }
1258
1259 /**
1260  *      ata_eh_read_log_10h - Read log page 10h for NCQ error details
1261  *      @dev: Device to read log page 10h from
1262  *      @tag: Resulting tag of the failed command
1263  *      @tf: Resulting taskfile registers of the failed command
1264  *
1265  *      Read log page 10h to obtain NCQ error details and clear error
1266  *      condition.
1267  *
1268  *      LOCKING:
1269  *      Kernel thread context (may sleep).
1270  *
1271  *      RETURNS:
1272  *      0 on success, -errno otherwise.
1273  */
1274 static int ata_eh_read_log_10h(struct ata_device *dev,
1275                                int *tag, struct ata_taskfile *tf)
1276 {
1277         u8 *buf = dev->link->ap->sector_buf;
1278         unsigned int err_mask;
1279         u8 csum;
1280         int i;
1281
1282         err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1);
1283         if (err_mask)
1284                 return -EIO;
1285
1286         csum = 0;
1287         for (i = 0; i < ATA_SECT_SIZE; i++)
1288                 csum += buf[i];
1289         if (csum)
1290                 ata_dev_printk(dev, KERN_WARNING,
1291                                "invalid checksum 0x%x on log page 10h\n", csum);
1292
1293         if (buf[0] & 0x80)
1294                 return -ENOENT;
1295
1296         *tag = buf[0] & 0x1f;
1297
1298         tf->command = buf[2];
1299         tf->feature = buf[3];
1300         tf->lbal = buf[4];
1301         tf->lbam = buf[5];
1302         tf->lbah = buf[6];
1303         tf->device = buf[7];
1304         tf->hob_lbal = buf[8];
1305         tf->hob_lbam = buf[9];
1306         tf->hob_lbah = buf[10];
1307         tf->nsect = buf[12];
1308         tf->hob_nsect = buf[13];
1309
1310         return 0;
1311 }
1312
1313 /**
1314  *      atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
1315  *      @dev: device to perform REQUEST_SENSE to
1316  *      @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
1317  *
1318  *      Perform ATAPI REQUEST_SENSE after the device reported CHECK
1319  *      SENSE.  This function is EH helper.
1320  *
1321  *      LOCKING:
1322  *      Kernel thread context (may sleep).
1323  *
1324  *      RETURNS:
1325  *      0 on success, AC_ERR_* mask on failure
1326  */
1327 static unsigned int atapi_eh_request_sense(struct ata_queued_cmd *qc)
1328 {
1329         struct ata_device *dev = qc->dev;
1330         unsigned char *sense_buf = qc->scsicmd->sense_buffer;
1331         struct ata_port *ap = dev->link->ap;
1332         struct ata_taskfile tf;
1333         u8 cdb[ATAPI_CDB_LEN];
1334
1335         DPRINTK("ATAPI request sense\n");
1336
1337         /* FIXME: is this needed? */
1338         memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
1339
1340         /* initialize sense_buf with the error register,
1341          * for the case where they are -not- overwritten
1342          */
1343         sense_buf[0] = 0x70;
1344         sense_buf[2] = qc->result_tf.feature >> 4;
1345
1346         /* some devices time out if garbage left in tf */
1347         ata_tf_init(dev, &tf);
1348
1349         memset(cdb, 0, ATAPI_CDB_LEN);
1350         cdb[0] = REQUEST_SENSE;
1351         cdb[4] = SCSI_SENSE_BUFFERSIZE;
1352
1353         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1354         tf.command = ATA_CMD_PACKET;
1355
1356         /* is it pointless to prefer PIO for "safety reasons"? */
1357         if (ap->flags & ATA_FLAG_PIO_DMA) {
1358                 tf.protocol = ATA_PROT_ATAPI_DMA;
1359                 tf.feature |= ATAPI_PKT_DMA;
1360         } else {
1361                 tf.protocol = ATA_PROT_ATAPI;
1362                 tf.lbam = (8 * 1024) & 0xff;
1363                 tf.lbah = (8 * 1024) >> 8;
1364         }
1365
1366         return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
1367                                  sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
1368 }
1369
1370 /**
1371  *      ata_eh_analyze_serror - analyze SError for a failed port
1372  *      @link: ATA link to analyze SError for
1373  *
1374  *      Analyze SError if available and further determine cause of
1375  *      failure.
1376  *
1377  *      LOCKING:
1378  *      None.
1379  */
1380 static void ata_eh_analyze_serror(struct ata_link *link)
1381 {
1382         struct ata_eh_context *ehc = &link->eh_context;
1383         u32 serror = ehc->i.serror;
1384         unsigned int err_mask = 0, action = 0;
1385         u32 hotplug_mask;
1386
1387         if (serror & SERR_PERSISTENT) {
1388                 err_mask |= AC_ERR_ATA_BUS;
1389                 action |= ATA_EH_HARDRESET;
1390         }
1391         if (serror &
1392             (SERR_DATA_RECOVERED | SERR_COMM_RECOVERED | SERR_DATA)) {
1393                 err_mask |= AC_ERR_ATA_BUS;
1394                 action |= ATA_EH_SOFTRESET;
1395         }
1396         if (serror & SERR_PROTOCOL) {
1397                 err_mask |= AC_ERR_HSM;
1398                 action |= ATA_EH_SOFTRESET;
1399         }
1400         if (serror & SERR_INTERNAL) {
1401                 err_mask |= AC_ERR_SYSTEM;
1402                 action |= ATA_EH_HARDRESET;
1403         }
1404
1405         /* Determine whether a hotplug event has occurred.  Both
1406          * SError.N/X are considered hotplug events for enabled or
1407          * host links.  For disabled PMP links, only N bit is
1408          * considered as X bit is left at 1 for link plugging.
1409          */
1410         hotplug_mask = 0;
1411
1412         if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
1413                 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
1414         else
1415                 hotplug_mask = SERR_PHYRDY_CHG;
1416
1417         if (serror & hotplug_mask)
1418                 ata_ehi_hotplugged(&ehc->i);
1419
1420         ehc->i.err_mask |= err_mask;
1421         ehc->i.action |= action;
1422 }
1423
1424 /**
1425  *      ata_eh_analyze_ncq_error - analyze NCQ error
1426  *      @link: ATA link to analyze NCQ error for
1427  *
1428  *      Read log page 10h, determine the offending qc and acquire
1429  *      error status TF.  For NCQ device errors, all LLDDs have to do
1430  *      is setting AC_ERR_DEV in ehi->err_mask.  This function takes
1431  *      care of the rest.
1432  *
1433  *      LOCKING:
1434  *      Kernel thread context (may sleep).
1435  */
1436 static void ata_eh_analyze_ncq_error(struct ata_link *link)
1437 {
1438         struct ata_port *ap = link->ap;
1439         struct ata_eh_context *ehc = &link->eh_context;
1440         struct ata_device *dev = link->device;
1441         struct ata_queued_cmd *qc;
1442         struct ata_taskfile tf;
1443         int tag, rc;
1444
1445         /* if frozen, we can't do much */
1446         if (ap->pflags & ATA_PFLAG_FROZEN)
1447                 return;
1448
1449         /* is it NCQ device error? */
1450         if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
1451                 return;
1452
1453         /* has LLDD analyzed already? */
1454         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1455                 qc = __ata_qc_from_tag(ap, tag);
1456
1457                 if (!(qc->flags & ATA_QCFLAG_FAILED))
1458                         continue;
1459
1460                 if (qc->err_mask)
1461                         return;
1462         }
1463
1464         /* okay, this error is ours */
1465         rc = ata_eh_read_log_10h(dev, &tag, &tf);
1466         if (rc) {
1467                 ata_link_printk(link, KERN_ERR, "failed to read log page 10h "
1468                                 "(errno=%d)\n", rc);
1469                 return;
1470         }
1471
1472         if (!(link->sactive & (1 << tag))) {
1473                 ata_link_printk(link, KERN_ERR, "log page 10h reported "
1474                                 "inactive tag %d\n", tag);
1475                 return;
1476         }
1477
1478         /* we've got the perpetrator, condemn it */
1479         qc = __ata_qc_from_tag(ap, tag);
1480         memcpy(&qc->result_tf, &tf, sizeof(tf));
1481         qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
1482         ehc->i.err_mask &= ~AC_ERR_DEV;
1483 }
1484
1485 /**
1486  *      ata_eh_analyze_tf - analyze taskfile of a failed qc
1487  *      @qc: qc to analyze
1488  *      @tf: Taskfile registers to analyze
1489  *
1490  *      Analyze taskfile of @qc and further determine cause of
1491  *      failure.  This function also requests ATAPI sense data if
1492  *      avaliable.
1493  *
1494  *      LOCKING:
1495  *      Kernel thread context (may sleep).
1496  *
1497  *      RETURNS:
1498  *      Determined recovery action
1499  */
1500 static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
1501                                       const struct ata_taskfile *tf)
1502 {
1503         unsigned int tmp, action = 0;
1504         u8 stat = tf->command, err = tf->feature;
1505
1506         if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
1507                 qc->err_mask |= AC_ERR_HSM;
1508                 return ATA_EH_SOFTRESET;
1509         }
1510
1511         if (stat & (ATA_ERR | ATA_DF))
1512                 qc->err_mask |= AC_ERR_DEV;
1513         else
1514                 return 0;
1515
1516         switch (qc->dev->class) {
1517         case ATA_DEV_ATA:
1518                 if (err & ATA_ICRC)
1519                         qc->err_mask |= AC_ERR_ATA_BUS;
1520                 if (err & ATA_UNC)
1521                         qc->err_mask |= AC_ERR_MEDIA;
1522                 if (err & ATA_IDNF)
1523                         qc->err_mask |= AC_ERR_INVALID;
1524                 break;
1525
1526         case ATA_DEV_ATAPI:
1527                 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
1528                         tmp = atapi_eh_request_sense(qc);
1529                         if (!tmp) {
1530                                 /* ATA_QCFLAG_SENSE_VALID is used to
1531                                  * tell atapi_qc_complete() that sense
1532                                  * data is already valid.
1533                                  *
1534                                  * TODO: interpret sense data and set
1535                                  * appropriate err_mask.
1536                                  */
1537                                 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1538                         } else
1539                                 qc->err_mask |= tmp;
1540                 }
1541         }
1542
1543         if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
1544                 action |= ATA_EH_SOFTRESET;
1545
1546         return action;
1547 }
1548
1549 static int ata_eh_categorize_error(int is_io, unsigned int err_mask)
1550 {
1551         if (err_mask & AC_ERR_ATA_BUS)
1552                 return 1;
1553
1554         if (err_mask & AC_ERR_TIMEOUT)
1555                 return 2;
1556
1557         if (is_io) {
1558                 if (err_mask & AC_ERR_HSM)
1559                         return 2;
1560                 if ((err_mask &
1561                      (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
1562                         return 3;
1563         }
1564
1565         return 0;
1566 }
1567
1568 struct speed_down_verdict_arg {
1569         u64 since;
1570         int nr_errors[4];
1571 };
1572
1573 static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
1574 {
1575         struct speed_down_verdict_arg *arg = void_arg;
1576         int cat = ata_eh_categorize_error(ent->is_io, ent->err_mask);
1577
1578         if (ent->timestamp < arg->since)
1579                 return -1;
1580
1581         arg->nr_errors[cat]++;
1582         return 0;
1583 }
1584
1585 /**
1586  *      ata_eh_speed_down_verdict - Determine speed down verdict
1587  *      @dev: Device of interest
1588  *
1589  *      This function examines error ring of @dev and determines
1590  *      whether NCQ needs to be turned off, transfer speed should be
1591  *      stepped down, or falling back to PIO is necessary.
1592  *
1593  *      Cat-1 is ATA_BUS error for any command.
1594  *
1595  *      Cat-2 is TIMEOUT for any command or HSM violation for known
1596  *      supported commands.
1597  *
1598  *      Cat-3 is is unclassified DEV error for known supported
1599  *      command.
1600  *
1601  *      NCQ needs to be turned off if there have been more than 3
1602  *      Cat-2 + Cat-3 errors during last 10 minutes.
1603  *
1604  *      Speed down is necessary if there have been more than 3 Cat-1 +
1605  *      Cat-2 errors or 10 Cat-3 errors during last 10 minutes.
1606  *
1607  *      Falling back to PIO mode is necessary if there have been more
1608  *      than 10 Cat-1 + Cat-2 + Cat-3 errors during last 5 minutes.
1609  *
1610  *      LOCKING:
1611  *      Inherited from caller.
1612  *
1613  *      RETURNS:
1614  *      OR of ATA_EH_SPDN_* flags.
1615  */
1616 static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
1617 {
1618         const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
1619         u64 j64 = get_jiffies_64();
1620         struct speed_down_verdict_arg arg;
1621         unsigned int verdict = 0;
1622
1623         /* scan past 10 mins of error history */
1624         memset(&arg, 0, sizeof(arg));
1625         arg.since = j64 - min(j64, j10mins);
1626         ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1627
1628         if (arg.nr_errors[2] + arg.nr_errors[3] > 3)
1629                 verdict |= ATA_EH_SPDN_NCQ_OFF;
1630         if (arg.nr_errors[1] + arg.nr_errors[2] > 3 || arg.nr_errors[3] > 10)
1631                 verdict |= ATA_EH_SPDN_SPEED_DOWN;
1632
1633         /* scan past 3 mins of error history */
1634         memset(&arg, 0, sizeof(arg));
1635         arg.since = j64 - min(j64, j5mins);
1636         ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1637
1638         if (arg.nr_errors[1] + arg.nr_errors[2] + arg.nr_errors[3] > 10)
1639                 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
1640
1641         return verdict;
1642 }
1643
1644 /**
1645  *      ata_eh_speed_down - record error and speed down if necessary
1646  *      @dev: Failed device
1647  *      @is_io: Did the device fail during normal IO?
1648  *      @err_mask: err_mask of the error
1649  *
1650  *      Record error and examine error history to determine whether
1651  *      adjusting transmission speed is necessary.  It also sets
1652  *      transmission limits appropriately if such adjustment is
1653  *      necessary.
1654  *
1655  *      LOCKING:
1656  *      Kernel thread context (may sleep).
1657  *
1658  *      RETURNS:
1659  *      Determined recovery action.
1660  */
1661 static unsigned int ata_eh_speed_down(struct ata_device *dev, int is_io,
1662                                       unsigned int err_mask)
1663 {
1664         unsigned int verdict;
1665         unsigned int action = 0;
1666
1667         /* don't bother if Cat-0 error */
1668         if (ata_eh_categorize_error(is_io, err_mask) == 0)
1669                 return 0;
1670
1671         /* record error and determine whether speed down is necessary */
1672         ata_ering_record(&dev->ering, is_io, err_mask);
1673         verdict = ata_eh_speed_down_verdict(dev);
1674
1675         /* turn off NCQ? */
1676         if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
1677             (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
1678                            ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
1679                 dev->flags |= ATA_DFLAG_NCQ_OFF;
1680                 ata_dev_printk(dev, KERN_WARNING,
1681                                "NCQ disabled due to excessive errors\n");
1682                 goto done;
1683         }
1684
1685         /* speed down? */
1686         if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
1687                 /* speed down SATA link speed if possible */
1688                 if (sata_down_spd_limit(dev->link) == 0) {
1689                         action |= ATA_EH_HARDRESET;
1690                         goto done;
1691                 }
1692
1693                 /* lower transfer mode */
1694                 if (dev->spdn_cnt < 2) {
1695                         static const int dma_dnxfer_sel[] =
1696                                 { ATA_DNXFER_DMA, ATA_DNXFER_40C };
1697                         static const int pio_dnxfer_sel[] =
1698                                 { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
1699                         int sel;
1700
1701                         if (dev->xfer_shift != ATA_SHIFT_PIO)
1702                                 sel = dma_dnxfer_sel[dev->spdn_cnt];
1703                         else
1704                                 sel = pio_dnxfer_sel[dev->spdn_cnt];
1705
1706                         dev->spdn_cnt++;
1707
1708                         if (ata_down_xfermask_limit(dev, sel) == 0) {
1709                                 action |= ATA_EH_SOFTRESET;
1710                                 goto done;
1711                         }
1712                 }
1713         }
1714
1715         /* Fall back to PIO?  Slowing down to PIO is meaningless for
1716          * SATA.  Consider it only for PATA.
1717          */
1718         if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
1719             (dev->link->ap->cbl != ATA_CBL_SATA) &&
1720             (dev->xfer_shift != ATA_SHIFT_PIO)) {
1721                 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
1722                         dev->spdn_cnt = 0;
1723                         action |= ATA_EH_SOFTRESET;
1724                         goto done;
1725                 }
1726         }
1727
1728         return 0;
1729  done:
1730         /* device has been slowed down, blow error history */
1731         ata_ering_clear(&dev->ering);
1732         return action;
1733 }
1734
1735 /**
1736  *      ata_eh_link_autopsy - analyze error and determine recovery action
1737  *      @link: host link to perform autopsy on
1738  *
1739  *      Analyze why @link failed and determine which recovery actions
1740  *      are needed.  This function also sets more detailed AC_ERR_*
1741  *      values and fills sense data for ATAPI CHECK SENSE.
1742  *
1743  *      LOCKING:
1744  *      Kernel thread context (may sleep).
1745  */
1746 static void ata_eh_link_autopsy(struct ata_link *link)
1747 {
1748         struct ata_port *ap = link->ap;
1749         struct ata_eh_context *ehc = &link->eh_context;
1750         unsigned int all_err_mask = 0;
1751         int tag, is_io = 0;
1752         u32 serror;
1753         int rc;
1754
1755         DPRINTK("ENTER\n");
1756
1757         if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
1758                 return;
1759
1760         /* obtain and analyze SError */
1761         rc = sata_scr_read(link, SCR_ERROR, &serror);
1762         if (rc == 0) {
1763                 ehc->i.serror |= serror;
1764                 ata_eh_analyze_serror(link);
1765         } else if (rc != -EOPNOTSUPP) {
1766                 /* SError read failed, force hardreset and probing */
1767                 ata_ehi_schedule_probe(&ehc->i);
1768                 ehc->i.action |= ATA_EH_HARDRESET;
1769                 ehc->i.err_mask |= AC_ERR_OTHER;
1770         }
1771
1772         /* analyze NCQ failure */
1773         ata_eh_analyze_ncq_error(link);
1774
1775         /* any real error trumps AC_ERR_OTHER */
1776         if (ehc->i.err_mask & ~AC_ERR_OTHER)
1777                 ehc->i.err_mask &= ~AC_ERR_OTHER;
1778
1779         all_err_mask |= ehc->i.err_mask;
1780
1781         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1782                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1783
1784                 if (!(qc->flags & ATA_QCFLAG_FAILED) || qc->dev->link != link)
1785                         continue;
1786
1787                 /* inherit upper level err_mask */
1788                 qc->err_mask |= ehc->i.err_mask;
1789
1790                 /* analyze TF */
1791                 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
1792
1793                 /* DEV errors are probably spurious in case of ATA_BUS error */
1794                 if (qc->err_mask & AC_ERR_ATA_BUS)
1795                         qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
1796                                           AC_ERR_INVALID);
1797
1798                 /* any real error trumps unknown error */
1799                 if (qc->err_mask & ~AC_ERR_OTHER)
1800                         qc->err_mask &= ~AC_ERR_OTHER;
1801
1802                 /* SENSE_VALID trumps dev/unknown error and revalidation */
1803                 if (qc->flags & ATA_QCFLAG_SENSE_VALID)
1804                         qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
1805
1806                 /* accumulate error info */
1807                 ehc->i.dev = qc->dev;
1808                 all_err_mask |= qc->err_mask;
1809                 if (qc->flags & ATA_QCFLAG_IO)
1810                         is_io = 1;
1811         }
1812
1813         /* enforce default EH actions */
1814         if (ap->pflags & ATA_PFLAG_FROZEN ||
1815             all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
1816                 ehc->i.action |= ATA_EH_SOFTRESET;
1817         else if ((is_io && all_err_mask) ||
1818                  (!is_io && (all_err_mask & ~AC_ERR_DEV)))
1819                 ehc->i.action |= ATA_EH_REVALIDATE;
1820
1821         /* if we have offending qcs and the associated failed device */
1822         if (ehc->i.dev) {
1823                 /* speed down */
1824                 ehc->i.action |= ata_eh_speed_down(ehc->i.dev, is_io,
1825                                                    all_err_mask);
1826
1827                 /* perform per-dev EH action only on the offending device */
1828                 ehc->i.dev_action[ehc->i.dev->devno] |=
1829                         ehc->i.action & ATA_EH_PERDEV_MASK;
1830                 ehc->i.action &= ~ATA_EH_PERDEV_MASK;
1831         }
1832
1833         DPRINTK("EXIT\n");
1834 }
1835
1836 /**
1837  *      ata_eh_autopsy - analyze error and determine recovery action
1838  *      @ap: host port to perform autopsy on
1839  *
1840  *      Analyze all links of @ap and determine why they failed and
1841  *      which recovery actions are needed.
1842  *
1843  *      LOCKING:
1844  *      Kernel thread context (may sleep).
1845  */
1846 void ata_eh_autopsy(struct ata_port *ap)
1847 {
1848         struct ata_link *link;
1849
1850         __ata_port_for_each_link(link, ap)
1851                 ata_eh_link_autopsy(link);
1852 }
1853
1854 /**
1855  *      ata_eh_link_report - report error handling to user
1856  *      @link: ATA link EH is going on
1857  *
1858  *      Report EH to user.
1859  *
1860  *      LOCKING:
1861  *      None.
1862  */
1863 static void ata_eh_link_report(struct ata_link *link)
1864 {
1865         struct ata_port *ap = link->ap;
1866         struct ata_eh_context *ehc = &link->eh_context;
1867         const char *frozen, *desc;
1868         char tries_buf[6];
1869         int tag, nr_failed = 0;
1870
1871         if (ehc->i.flags & ATA_EHI_QUIET)
1872                 return;
1873
1874         desc = NULL;
1875         if (ehc->i.desc[0] != '\0')
1876                 desc = ehc->i.desc;
1877
1878         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1879                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1880
1881                 if (!(qc->flags & ATA_QCFLAG_FAILED) || qc->dev->link != link ||
1882                     ((qc->flags & ATA_QCFLAG_QUIET) &&
1883                      qc->err_mask == AC_ERR_DEV))
1884                         continue;
1885                 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
1886                         continue;
1887
1888                 nr_failed++;
1889         }
1890
1891         if (!nr_failed && !ehc->i.err_mask)
1892                 return;
1893
1894         frozen = "";
1895         if (ap->pflags & ATA_PFLAG_FROZEN)
1896                 frozen = " frozen";
1897
1898         memset(tries_buf, 0, sizeof(tries_buf));
1899         if (ap->eh_tries < ATA_EH_MAX_TRIES)
1900                 snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
1901                          ap->eh_tries);
1902
1903         if (ehc->i.dev) {
1904                 ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x "
1905                                "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
1906                                ehc->i.err_mask, link->sactive, ehc->i.serror,
1907                                ehc->i.action, frozen, tries_buf);
1908                 if (desc)
1909                         ata_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc);
1910         } else {
1911                 ata_link_printk(link, KERN_ERR, "exception Emask 0x%x "
1912                                 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
1913                                 ehc->i.err_mask, link->sactive, ehc->i.serror,
1914                                 ehc->i.action, frozen, tries_buf);
1915                 if (desc)
1916                         ata_link_printk(link, KERN_ERR, "%s\n", desc);
1917         }
1918
1919         if (ehc->i.serror)
1920                 ata_port_printk(ap, KERN_ERR,
1921                   "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
1922                   ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
1923                   ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
1924                   ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
1925                   ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
1926                   ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
1927                   ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
1928                   ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
1929                   ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
1930                   ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
1931                   ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
1932                   ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
1933                   ehc->i.serror & SERR_CRC ? "BadCRC " : "",
1934                   ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
1935                   ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
1936                   ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
1937                   ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
1938                   ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
1939
1940         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1941                 static const char *dma_str[] = {
1942                         [DMA_BIDIRECTIONAL]     = "bidi",
1943                         [DMA_TO_DEVICE]         = "out",
1944                         [DMA_FROM_DEVICE]       = "in",
1945                         [DMA_NONE]              = "",
1946                 };
1947                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1948                 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
1949
1950                 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
1951                     qc->dev->link != link || !qc->err_mask)
1952                         continue;
1953
1954                 ata_dev_printk(qc->dev, KERN_ERR,
1955                         "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
1956                         "tag %d cdb 0x%x data %u %s\n         "
1957                         "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
1958                         "Emask 0x%x (%s)%s\n",
1959                         cmd->command, cmd->feature, cmd->nsect,
1960                         cmd->lbal, cmd->lbam, cmd->lbah,
1961                         cmd->hob_feature, cmd->hob_nsect,
1962                         cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
1963                         cmd->device, qc->tag, qc->cdb[0], qc->nbytes,
1964                         dma_str[qc->dma_dir],
1965                         res->command, res->feature, res->nsect,
1966                         res->lbal, res->lbam, res->lbah,
1967                         res->hob_feature, res->hob_nsect,
1968                         res->hob_lbal, res->hob_lbam, res->hob_lbah,
1969                         res->device, qc->err_mask, ata_err_string(qc->err_mask),
1970                         qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
1971
1972                 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
1973                                     ATA_ERR)) {
1974                         if (res->command & ATA_BUSY)
1975                                 ata_dev_printk(qc->dev, KERN_ERR,
1976                                   "status: { Busy }\n");
1977                         else
1978                                 ata_dev_printk(qc->dev, KERN_ERR,
1979                                   "status: { %s%s%s%s}\n",
1980                                   res->command & ATA_DRDY ? "DRDY " : "",
1981                                   res->command & ATA_DF ? "DF " : "",
1982                                   res->command & ATA_DRQ ? "DRQ " : "",
1983                                   res->command & ATA_ERR ? "ERR " : "");
1984                 }
1985
1986                 if (cmd->command != ATA_CMD_PACKET &&
1987                     (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
1988                                      ATA_ABORTED)))
1989                         ata_dev_printk(qc->dev, KERN_ERR,
1990                           "error: { %s%s%s%s}\n",
1991                           res->feature & ATA_ICRC ? "ICRC " : "",
1992                           res->feature & ATA_UNC ? "UNC " : "",
1993                           res->feature & ATA_IDNF ? "IDNF " : "",
1994                           res->feature & ATA_ABORTED ? "ABRT " : "");
1995         }
1996 }
1997
1998 /**
1999  *      ata_eh_report - report error handling to user
2000  *      @ap: ATA port to report EH about
2001  *
2002  *      Report EH to user.
2003  *
2004  *      LOCKING:
2005  *      None.
2006  */
2007 void ata_eh_report(struct ata_port *ap)
2008 {
2009         struct ata_link *link;
2010
2011         __ata_port_for_each_link(link, ap)
2012                 ata_eh_link_report(link);
2013 }
2014
2015 static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
2016                         unsigned int *classes, unsigned long deadline)
2017 {
2018         struct ata_device *dev;
2019         int rc;
2020
2021         ata_link_for_each_dev(dev, link)
2022                 classes[dev->devno] = ATA_DEV_UNKNOWN;
2023
2024         rc = reset(link, classes, deadline);
2025         if (rc)
2026                 return rc;
2027
2028         /* If any class isn't ATA_DEV_UNKNOWN, consider classification
2029          * is complete and convert all ATA_DEV_UNKNOWN to
2030          * ATA_DEV_NONE.
2031          */
2032         ata_link_for_each_dev(dev, link)
2033                 if (classes[dev->devno] != ATA_DEV_UNKNOWN)
2034                         break;
2035
2036         if (dev) {
2037                 ata_link_for_each_dev(dev, link) {
2038                         if (classes[dev->devno] == ATA_DEV_UNKNOWN)
2039                                 classes[dev->devno] = ATA_DEV_NONE;
2040                 }
2041         }
2042
2043         return 0;
2044 }
2045
2046 static int ata_eh_followup_srst_needed(struct ata_link *link,
2047                                        int rc, int classify,
2048                                        const unsigned int *classes)
2049 {
2050         if (link->flags & ATA_LFLAG_NO_SRST)
2051                 return 0;
2052         if (rc == -EAGAIN)
2053                 return 1;
2054         if (rc != 0)
2055                 return 0;
2056         if ((link->ap->flags & ATA_FLAG_PMP) && ata_is_host_link(link))
2057                 return 1;
2058         if (classify && !(link->flags & ATA_LFLAG_ASSUME_CLASS) &&
2059             classes[0] == ATA_DEV_UNKNOWN)
2060                 return 1;
2061         return 0;
2062 }
2063
2064 int ata_eh_reset(struct ata_link *link, int classify,
2065                  ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
2066                  ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
2067 {
2068         struct ata_port *ap = link->ap;
2069         struct ata_eh_context *ehc = &link->eh_context;
2070         unsigned int *classes = ehc->classes;
2071         int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
2072         int try = 0;
2073         struct ata_device *dev;
2074         unsigned long deadline;
2075         unsigned int tmp_action;
2076         ata_reset_fn_t reset;
2077         unsigned long flags;
2078         int rc;
2079
2080         /* about to reset */
2081         spin_lock_irqsave(ap->lock, flags);
2082         ap->pflags |= ATA_PFLAG_RESETTING;
2083         spin_unlock_irqrestore(ap->lock, flags);
2084
2085         ata_eh_about_to_do(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
2086
2087         ata_link_for_each_dev(dev, link) {
2088                 /* If we issue an SRST then an ATA drive (not ATAPI)
2089                  * may change configuration and be in PIO0 timing. If
2090                  * we do a hard reset (or are coming from power on)
2091                  * this is true for ATA or ATAPI. Until we've set a
2092                  * suitable controller mode we should not touch the
2093                  * bus as we may be talking too fast.
2094                  */
2095                 dev->pio_mode = XFER_PIO_0;
2096
2097                 /* If the controller has a pio mode setup function
2098                  * then use it to set the chipset to rights. Don't
2099                  * touch the DMA setup as that will be dealt with when
2100                  * configuring devices.
2101                  */
2102                 if (ap->ops->set_piomode)
2103                         ap->ops->set_piomode(ap, dev);
2104         }
2105
2106         /* Determine which reset to use and record in ehc->i.action.
2107          * prereset() may examine and modify it.
2108          */
2109         if (softreset && (!hardreset || (!(link->flags & ATA_LFLAG_NO_SRST) &&
2110                                          !sata_set_spd_needed(link) &&
2111                                          !(ehc->i.action & ATA_EH_HARDRESET))))
2112                 tmp_action = ATA_EH_SOFTRESET;
2113         else
2114                 tmp_action = ATA_EH_HARDRESET;
2115
2116         ehc->i.action = (ehc->i.action & ~ATA_EH_RESET_MASK) | tmp_action;
2117
2118         if (prereset) {
2119                 rc = prereset(link, jiffies + ATA_EH_PRERESET_TIMEOUT);
2120                 if (rc) {
2121                         if (rc == -ENOENT) {
2122                                 ata_link_printk(link, KERN_DEBUG,
2123                                                 "port disabled. ignoring.\n");
2124                                 ehc->i.action &= ~ATA_EH_RESET_MASK;
2125
2126                                 ata_link_for_each_dev(dev, link)
2127                                         classes[dev->devno] = ATA_DEV_NONE;
2128
2129                                 rc = 0;
2130                         } else
2131                                 ata_link_printk(link, KERN_ERR,
2132                                         "prereset failed (errno=%d)\n", rc);
2133                         goto out;
2134                 }
2135         }
2136
2137         /* prereset() might have modified ehc->i.action */
2138         if (ehc->i.action & ATA_EH_HARDRESET)
2139                 reset = hardreset;
2140         else if (ehc->i.action & ATA_EH_SOFTRESET)
2141                 reset = softreset;
2142         else {
2143                 /* prereset told us not to reset, bang classes and return */
2144                 ata_link_for_each_dev(dev, link)
2145                         classes[dev->devno] = ATA_DEV_NONE;
2146                 rc = 0;
2147                 goto out;
2148         }
2149
2150         /* did prereset() screw up?  if so, fix up to avoid oopsing */
2151         if (!reset) {
2152                 if (softreset)
2153                         reset = softreset;
2154                 else
2155                         reset = hardreset;
2156         }
2157
2158  retry:
2159         deadline = jiffies + ata_eh_reset_timeouts[try++];
2160
2161         /* shut up during boot probing */
2162         if (verbose)
2163                 ata_link_printk(link, KERN_INFO, "%s resetting link\n",
2164                                 reset == softreset ? "soft" : "hard");
2165
2166         /* mark that this EH session started with reset */
2167         if (reset == hardreset)
2168                 ehc->i.flags |= ATA_EHI_DID_HARDRESET;
2169         else
2170                 ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
2171
2172         rc = ata_do_reset(link, reset, classes, deadline);
2173
2174         if (reset == hardreset &&
2175             ata_eh_followup_srst_needed(link, rc, classify, classes)) {
2176                 /* okay, let's do follow-up softreset */
2177                 reset = softreset;
2178
2179                 if (!reset) {
2180                         ata_link_printk(link, KERN_ERR,
2181                                         "follow-up softreset required "
2182                                         "but no softreset avaliable\n");
2183                         rc = -EINVAL;
2184                         goto out;
2185                 }
2186
2187                 ata_eh_about_to_do(link, NULL, ATA_EH_RESET_MASK);
2188                 rc = ata_do_reset(link, reset, classes, deadline);
2189
2190                 if (rc == 0 && classify && classes[0] == ATA_DEV_UNKNOWN &&
2191                     !(link->flags & ATA_LFLAG_ASSUME_CLASS)) {
2192                         ata_link_printk(link, KERN_ERR,
2193                                         "classification failed\n");
2194                         rc = -EINVAL;
2195                         goto out;
2196                 }
2197         }
2198
2199         /* if we skipped follow-up srst, clear rc */
2200         if (rc == -EAGAIN)
2201                 rc = 0;
2202
2203         if (rc && rc != -ERESTART && try < ARRAY_SIZE(ata_eh_reset_timeouts)) {
2204                 unsigned long now = jiffies;
2205
2206                 if (time_before(now, deadline)) {
2207                         unsigned long delta = deadline - jiffies;
2208
2209                         ata_link_printk(link, KERN_WARNING, "reset failed "
2210                                 "(errno=%d), retrying in %u secs\n",
2211                                 rc, (jiffies_to_msecs(delta) + 999) / 1000);
2212
2213                         while (delta)
2214                                 delta = schedule_timeout_uninterruptible(delta);
2215                 }
2216
2217                 if (rc == -EPIPE ||
2218                     try == ARRAY_SIZE(ata_eh_reset_timeouts) - 1)
2219                         sata_down_spd_limit(link);
2220                 if (hardreset)
2221                         reset = hardreset;
2222                 goto retry;
2223         }
2224
2225         if (rc == 0) {
2226                 u32 sstatus;
2227
2228                 ata_link_for_each_dev(dev, link) {
2229                         /* After the reset, the device state is PIO 0
2230                          * and the controller state is undefined.
2231                          * Reset also wakes up drives from sleeping
2232                          * mode.
2233                          */
2234                         dev->pio_mode = XFER_PIO_0;
2235                         dev->flags &= ~ATA_DFLAG_SLEEPING;
2236
2237                         if (ata_link_offline(link))
2238                                 continue;
2239
2240                         /* apply class override and convert UNKNOWN to NONE */
2241                         if (link->flags & ATA_LFLAG_ASSUME_ATA)
2242                                 classes[dev->devno] = ATA_DEV_ATA;
2243                         else if (link->flags & ATA_LFLAG_ASSUME_SEMB)
2244                                 classes[dev->devno] = ATA_DEV_SEMB_UNSUP; /* not yet */
2245                         else if (classes[dev->devno] == ATA_DEV_UNKNOWN)
2246                                 classes[dev->devno] = ATA_DEV_NONE;
2247                 }
2248
2249                 /* record current link speed */
2250                 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
2251                         link->sata_spd = (sstatus >> 4) & 0xf;
2252
2253                 if (postreset)
2254                         postreset(link, classes);
2255
2256                 /* reset successful, schedule revalidation */
2257                 ata_eh_done(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
2258                 ehc->i.action |= ATA_EH_REVALIDATE;
2259         }
2260  out:
2261         /* clear hotplug flag */
2262         ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
2263
2264         spin_lock_irqsave(ap->lock, flags);
2265         ap->pflags &= ~ATA_PFLAG_RESETTING;
2266         spin_unlock_irqrestore(ap->lock, flags);
2267
2268         return rc;
2269 }
2270
2271 static int ata_eh_revalidate_and_attach(struct ata_link *link,
2272                                         struct ata_device **r_failed_dev)
2273 {
2274         struct ata_port *ap = link->ap;
2275         struct ata_eh_context *ehc = &link->eh_context;
2276         struct ata_device *dev;
2277         unsigned int new_mask = 0;
2278         unsigned long flags;
2279         int rc = 0;
2280
2281         DPRINTK("ENTER\n");
2282
2283         /* For PATA drive side cable detection to work, IDENTIFY must
2284          * be done backwards such that PDIAG- is released by the slave
2285          * device before the master device is identified.
2286          */
2287         ata_link_for_each_dev_reverse(dev, link) {
2288                 unsigned int action = ata_eh_dev_action(dev);
2289                 unsigned int readid_flags = 0;
2290
2291                 if (ehc->i.flags & ATA_EHI_DID_RESET)
2292                         readid_flags |= ATA_READID_POSTRESET;
2293
2294                 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
2295                         WARN_ON(dev->class == ATA_DEV_PMP);
2296
2297                         if (ata_link_offline(link)) {
2298                                 rc = -EIO;
2299                                 goto err;
2300                         }
2301
2302                         ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
2303                         rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
2304                                                 readid_flags);
2305                         if (rc)
2306                                 goto err;
2307
2308                         ata_eh_done(link, dev, ATA_EH_REVALIDATE);
2309
2310                         /* Configuration may have changed, reconfigure
2311                          * transfer mode.
2312                          */
2313                         ehc->i.flags |= ATA_EHI_SETMODE;
2314
2315                         /* schedule the scsi_rescan_device() here */
2316                         queue_work(ata_aux_wq, &(ap->scsi_rescan_task));
2317                 } else if (dev->class == ATA_DEV_UNKNOWN &&
2318                            ehc->tries[dev->devno] &&
2319                            ata_class_enabled(ehc->classes[dev->devno])) {
2320                         dev->class = ehc->classes[dev->devno];
2321
2322                         if (dev->class == ATA_DEV_PMP)
2323                                 rc = sata_pmp_attach(dev);
2324                         else
2325                                 rc = ata_dev_read_id(dev, &dev->class,
2326                                                      readid_flags, dev->id);
2327                         switch (rc) {
2328                         case 0:
2329                                 new_mask |= 1 << dev->devno;
2330                                 break;
2331                         case -ENOENT:
2332                                 /* IDENTIFY was issued to non-existent
2333                                  * device.  No need to reset.  Just
2334                                  * thaw and kill the device.
2335                                  */
2336                                 ata_eh_thaw_port(ap);
2337                                 dev->class = ATA_DEV_UNKNOWN;
2338                                 break;
2339                         default:
2340                                 dev->class = ATA_DEV_UNKNOWN;
2341                                 goto err;
2342                         }
2343                 }
2344         }
2345
2346         /* PDIAG- should have been released, ask cable type if post-reset */
2347         if (ata_is_host_link(link) && ap->ops->cable_detect &&
2348             (ehc->i.flags & ATA_EHI_DID_RESET))
2349                 ap->cbl = ap->ops->cable_detect(ap);
2350
2351         /* Configure new devices forward such that user doesn't see
2352          * device detection messages backwards.
2353          */
2354         ata_link_for_each_dev(dev, link) {
2355                 if (!(new_mask & (1 << dev->devno)) ||
2356                     dev->class == ATA_DEV_PMP)
2357                         continue;
2358
2359                 ehc->i.flags |= ATA_EHI_PRINTINFO;
2360                 rc = ata_dev_configure(dev);
2361                 ehc->i.flags &= ~ATA_EHI_PRINTINFO;
2362                 if (rc)
2363                         goto err;
2364
2365                 spin_lock_irqsave(ap->lock, flags);
2366                 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
2367                 spin_unlock_irqrestore(ap->lock, flags);
2368
2369                 /* new device discovered, configure xfermode */
2370                 ehc->i.flags |= ATA_EHI_SETMODE;
2371         }
2372
2373         return 0;
2374
2375  err:
2376         *r_failed_dev = dev;
2377         DPRINTK("EXIT rc=%d\n", rc);
2378         return rc;
2379 }
2380
2381 static int ata_link_nr_enabled(struct ata_link *link)
2382 {
2383         struct ata_device *dev;
2384         int cnt = 0;
2385
2386         ata_link_for_each_dev(dev, link)
2387                 if (ata_dev_enabled(dev))
2388                         cnt++;
2389         return cnt;
2390 }
2391
2392 static int ata_link_nr_vacant(struct ata_link *link)
2393 {
2394         struct ata_device *dev;
2395         int cnt = 0;
2396
2397         ata_link_for_each_dev(dev, link)
2398                 if (dev->class == ATA_DEV_UNKNOWN)
2399                         cnt++;
2400         return cnt;
2401 }
2402
2403 static int ata_eh_skip_recovery(struct ata_link *link)
2404 {
2405         struct ata_eh_context *ehc = &link->eh_context;
2406         struct ata_device *dev;
2407
2408         /* skip disabled links */
2409         if (link->flags & ATA_LFLAG_DISABLED)
2410                 return 1;
2411
2412         /* thaw frozen port, resume link and recover failed devices */
2413         if ((link->ap->pflags & ATA_PFLAG_FROZEN) ||
2414             (ehc->i.flags & ATA_EHI_RESUME_LINK) || ata_link_nr_enabled(link))
2415                 return 0;
2416
2417         /* skip if class codes for all vacant slots are ATA_DEV_NONE */
2418         ata_link_for_each_dev(dev, link) {
2419                 if (dev->class == ATA_DEV_UNKNOWN &&
2420                     ehc->classes[dev->devno] != ATA_DEV_NONE)
2421                         return 0;
2422         }
2423
2424         return 1;
2425 }
2426
2427 static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
2428 {
2429         struct ata_eh_context *ehc = &dev->link->eh_context;
2430
2431         ehc->tries[dev->devno]--;
2432
2433         switch (err) {
2434         case -ENODEV:
2435                 /* device missing or wrong IDENTIFY data, schedule probing */
2436                 ehc->i.probe_mask |= (1 << dev->devno);
2437         case -EINVAL:
2438                 /* give it just one more chance */
2439                 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
2440         case -EIO:
2441                 if (ehc->tries[dev->devno] == 1 && dev->pio_mode > XFER_PIO_0) {
2442                         /* This is the last chance, better to slow
2443                          * down than lose it.
2444                          */
2445                         sata_down_spd_limit(dev->link);
2446                         ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
2447                 }
2448         }
2449
2450         if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
2451                 /* disable device if it has used up all its chances */
2452                 ata_dev_disable(dev);
2453
2454                 /* detach if offline */
2455                 if (ata_link_offline(dev->link))
2456                         ata_eh_detach_dev(dev);
2457
2458                 /* probe if requested */
2459                 if ((ehc->i.probe_mask & (1 << dev->devno)) &&
2460                     !(ehc->did_probe_mask & (1 << dev->devno))) {
2461                         ata_eh_detach_dev(dev);
2462                         ata_dev_init(dev);
2463
2464                         ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
2465                         ehc->did_probe_mask |= (1 << dev->devno);
2466                         ehc->i.action |= ATA_EH_SOFTRESET;
2467                 }
2468
2469                 return 1;
2470         } else {
2471                 /* soft didn't work?  be haaaaard */
2472                 if (ehc->i.flags & ATA_EHI_DID_RESET)
2473                         ehc->i.action |= ATA_EH_HARDRESET;
2474                 else
2475                         ehc->i.action |= ATA_EH_SOFTRESET;
2476
2477                 return 0;
2478         }
2479 }
2480
2481 /**
2482  *      ata_eh_recover - recover host port after error
2483  *      @ap: host port to recover
2484  *      @prereset: prereset method (can be NULL)
2485  *      @softreset: softreset method (can be NULL)
2486  *      @hardreset: hardreset method (can be NULL)
2487  *      @postreset: postreset method (can be NULL)
2488  *      @r_failed_link: out parameter for failed link
2489  *
2490  *      This is the alpha and omega, eum and yang, heart and soul of
2491  *      libata exception handling.  On entry, actions required to
2492  *      recover each link and hotplug requests are recorded in the
2493  *      link's eh_context.  This function executes all the operations
2494  *      with appropriate retrials and fallbacks to resurrect failed
2495  *      devices, detach goners and greet newcomers.
2496  *
2497  *      LOCKING:
2498  *      Kernel thread context (may sleep).
2499  *
2500  *      RETURNS:
2501  *      0 on success, -errno on failure.
2502  */
2503 int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
2504                    ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
2505                    ata_postreset_fn_t postreset,
2506                    struct ata_link **r_failed_link)
2507 {
2508         struct ata_link *link;
2509         struct ata_device *dev;
2510         int nr_failed_devs, nr_disabled_devs;
2511         int reset, rc;
2512         unsigned long flags;
2513
2514         DPRINTK("ENTER\n");
2515
2516         /* prep for recovery */
2517         ata_port_for_each_link(link, ap) {
2518                 struct ata_eh_context *ehc = &link->eh_context;
2519
2520                 /* re-enable link? */
2521                 if (ehc->i.action & ATA_EH_ENABLE_LINK) {
2522                         ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
2523                         spin_lock_irqsave(ap->lock, flags);
2524                         link->flags &= ~ATA_LFLAG_DISABLED;
2525                         spin_unlock_irqrestore(ap->lock, flags);
2526                         ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
2527                 }
2528
2529                 ata_link_for_each_dev(dev, link) {
2530                         if (link->flags & ATA_LFLAG_NO_RETRY)
2531                                 ehc->tries[dev->devno] = 1;
2532                         else
2533                                 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
2534
2535                         /* collect port action mask recorded in dev actions */
2536                         ehc->i.action |= ehc->i.dev_action[dev->devno] &
2537                                          ~ATA_EH_PERDEV_MASK;
2538                         ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
2539
2540                         /* process hotplug request */
2541                         if (dev->flags & ATA_DFLAG_DETACH)
2542                                 ata_eh_detach_dev(dev);
2543
2544                         if (!ata_dev_enabled(dev) &&
2545                             ((ehc->i.probe_mask & (1 << dev->devno)) &&
2546                              !(ehc->did_probe_mask & (1 << dev->devno)))) {
2547                                 ata_eh_detach_dev(dev);
2548                                 ata_dev_init(dev);
2549                                 ehc->did_probe_mask |= (1 << dev->devno);
2550                                 ehc->i.action |= ATA_EH_SOFTRESET;
2551                         }
2552                 }
2553         }
2554
2555  retry:
2556         rc = 0;
2557         nr_failed_devs = 0;
2558         nr_disabled_devs = 0;
2559         reset = 0;
2560
2561         /* if UNLOADING, finish immediately */
2562         if (ap->pflags & ATA_PFLAG_UNLOADING)
2563                 goto out;
2564
2565         /* prep for EH */
2566         ata_port_for_each_link(link, ap) {
2567                 struct ata_eh_context *ehc = &link->eh_context;
2568
2569                 /* skip EH if possible. */
2570                 if (ata_eh_skip_recovery(link))
2571                         ehc->i.action = 0;
2572
2573                 /* do we need to reset? */
2574                 if (ehc->i.action & ATA_EH_RESET_MASK)
2575                         reset = 1;
2576
2577                 ata_link_for_each_dev(dev, link)
2578                         ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
2579         }
2580
2581         /* reset */
2582         if (reset) {
2583                 /* if PMP is attached, this function only deals with
2584                  * downstream links, port should stay thawed.
2585                  */
2586                 if (!ap->nr_pmp_links)
2587                         ata_eh_freeze_port(ap);
2588
2589                 ata_port_for_each_link(link, ap) {
2590                         struct ata_eh_context *ehc = &link->eh_context;
2591
2592                         if (!(ehc->i.action & ATA_EH_RESET_MASK))
2593                                 continue;
2594
2595                         rc = ata_eh_reset(link, ata_link_nr_vacant(link),
2596                                           prereset, softreset, hardreset,
2597                                           postreset);
2598                         if (rc) {
2599                                 ata_link_printk(link, KERN_ERR,
2600                                                 "reset failed, giving up\n");
2601                                 goto out;
2602                         }
2603                 }
2604
2605                 if (!ap->nr_pmp_links)
2606                         ata_eh_thaw_port(ap);
2607         }
2608
2609         /* the rest */
2610         ata_port_for_each_link(link, ap) {
2611                 struct ata_eh_context *ehc = &link->eh_context;
2612
2613                 /* revalidate existing devices and attach new ones */
2614                 rc = ata_eh_revalidate_and_attach(link, &dev);
2615                 if (rc)
2616                         goto dev_fail;
2617
2618                 /* if PMP got attached, return, pmp EH will take care of it */
2619                 if (link->device->class == ATA_DEV_PMP) {
2620                         ehc->i.action = 0;
2621                         return 0;
2622                 }
2623
2624                 /* configure transfer mode if necessary */
2625                 if (ehc->i.flags & ATA_EHI_SETMODE) {
2626                         rc = ata_set_mode(link, &dev);
2627                         if (rc)
2628                                 goto dev_fail;
2629                         ehc->i.flags &= ~ATA_EHI_SETMODE;
2630                 }
2631
2632                 if (ehc->i.action & ATA_EHI_LPM)
2633                         ata_link_for_each_dev(dev, link)
2634                                 ata_dev_enable_pm(dev, ap->pm_policy);
2635
2636                 /* this link is okay now */
2637                 ehc->i.flags = 0;
2638                 continue;
2639
2640 dev_fail:
2641                 nr_failed_devs++;
2642                 if (ata_eh_handle_dev_fail(dev, rc))
2643                         nr_disabled_devs++;
2644
2645                 if (ap->pflags & ATA_PFLAG_FROZEN) {
2646                         /* PMP reset requires working host port.
2647                          * Can't retry if it's frozen.
2648                          */
2649                         if (ap->nr_pmp_links)
2650                                 goto out;
2651                         break;
2652                 }
2653         }
2654
2655         if (nr_failed_devs) {
2656                 if (nr_failed_devs != nr_disabled_devs) {
2657                         ata_port_printk(ap, KERN_WARNING, "failed to recover "
2658                                         "some devices, retrying in 5 secs\n");
2659                         ssleep(5);
2660                 } else {
2661                         /* no device left to recover, repeat fast */
2662                         msleep(500);
2663                 }
2664
2665                 goto retry;
2666         }
2667
2668  out:
2669         if (rc && r_failed_link)
2670                 *r_failed_link = link;
2671
2672         DPRINTK("EXIT, rc=%d\n", rc);
2673         return rc;
2674 }
2675
2676 /**
2677  *      ata_eh_finish - finish up EH
2678  *      @ap: host port to finish EH for
2679  *
2680  *      Recovery is complete.  Clean up EH states and retry or finish
2681  *      failed qcs.
2682  *
2683  *      LOCKING:
2684  *      None.
2685  */
2686 void ata_eh_finish(struct ata_port *ap)
2687 {
2688         int tag;
2689
2690         /* retry or finish qcs */
2691         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2692                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2693
2694                 if (!(qc->flags & ATA_QCFLAG_FAILED))
2695                         continue;
2696
2697                 if (qc->err_mask) {
2698                         /* FIXME: Once EH migration is complete,
2699                          * generate sense data in this function,
2700                          * considering both err_mask and tf.
2701                          *
2702                          * There's no point in retrying invalid
2703                          * (detected by libata) and non-IO device
2704                          * errors (rejected by device).  Finish them
2705                          * immediately.
2706                          */
2707                         if ((qc->err_mask & AC_ERR_INVALID) ||
2708                             (!(qc->flags & ATA_QCFLAG_IO) &&
2709                              qc->err_mask == AC_ERR_DEV))
2710                                 ata_eh_qc_complete(qc);
2711                         else
2712                                 ata_eh_qc_retry(qc);
2713                 } else {
2714                         if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
2715                                 ata_eh_qc_complete(qc);
2716                         } else {
2717                                 /* feed zero TF to sense generation */
2718                                 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
2719                                 ata_eh_qc_retry(qc);
2720                         }
2721                 }
2722         }
2723
2724         /* make sure nr_active_links is zero after EH */
2725         WARN_ON(ap->nr_active_links);
2726         ap->nr_active_links = 0;
2727 }
2728
2729 /**
2730  *      ata_do_eh - do standard error handling
2731  *      @ap: host port to handle error for
2732  *      @prereset: prereset method (can be NULL)
2733  *      @softreset: softreset method (can be NULL)
2734  *      @hardreset: hardreset method (can be NULL)
2735  *      @postreset: postreset method (can be NULL)
2736  *
2737  *      Perform standard error handling sequence.
2738  *
2739  *      LOCKING:
2740  *      Kernel thread context (may sleep).
2741  */
2742 void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
2743                ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
2744                ata_postreset_fn_t postreset)
2745 {
2746         struct ata_device *dev;
2747         int rc;
2748
2749         ata_eh_autopsy(ap);
2750         ata_eh_report(ap);
2751
2752         rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
2753                             NULL);
2754         if (rc) {
2755                 ata_link_for_each_dev(dev, &ap->link)
2756                         ata_dev_disable(dev);
2757         }
2758
2759         ata_eh_finish(ap);
2760 }
2761
2762 #ifdef CONFIG_PM
2763 /**
2764  *      ata_eh_handle_port_suspend - perform port suspend operation
2765  *      @ap: port to suspend
2766  *
2767  *      Suspend @ap.
2768  *
2769  *      LOCKING:
2770  *      Kernel thread context (may sleep).
2771  */
2772 static void ata_eh_handle_port_suspend(struct ata_port *ap)
2773 {
2774         unsigned long flags;
2775         int rc = 0;
2776
2777         /* are we suspending? */
2778         spin_lock_irqsave(ap->lock, flags);
2779         if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
2780             ap->pm_mesg.event == PM_EVENT_ON) {
2781                 spin_unlock_irqrestore(ap->lock, flags);
2782                 return;
2783         }
2784         spin_unlock_irqrestore(ap->lock, flags);
2785
2786         WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
2787
2788         /* tell ACPI we're suspending */
2789         rc = ata_acpi_on_suspend(ap);
2790         if (rc)
2791                 goto out;
2792
2793         /* suspend */
2794         ata_eh_freeze_port(ap);
2795
2796         if (ap->ops->port_suspend)
2797                 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
2798
2799  out:
2800         /* report result */
2801         spin_lock_irqsave(ap->lock, flags);
2802
2803         ap->pflags &= ~ATA_PFLAG_PM_PENDING;
2804         if (rc == 0)
2805                 ap->pflags |= ATA_PFLAG_SUSPENDED;
2806         else if (ap->pflags & ATA_PFLAG_FROZEN)
2807                 ata_port_schedule_eh(ap);
2808
2809         if (ap->pm_result) {
2810                 *ap->pm_result = rc;
2811                 ap->pm_result = NULL;
2812         }
2813
2814         spin_unlock_irqrestore(ap->lock, flags);
2815
2816         return;
2817 }
2818
2819 /**
2820  *      ata_eh_handle_port_resume - perform port resume operation
2821  *      @ap: port to resume
2822  *
2823  *      Resume @ap.
2824  *
2825  *      LOCKING:
2826  *      Kernel thread context (may sleep).
2827  */
2828 static void ata_eh_handle_port_resume(struct ata_port *ap)
2829 {
2830         unsigned long flags;
2831         int rc = 0;
2832
2833         /* are we resuming? */
2834         spin_lock_irqsave(ap->lock, flags);
2835         if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
2836             ap->pm_mesg.event != PM_EVENT_ON) {
2837                 spin_unlock_irqrestore(ap->lock, flags);
2838                 return;
2839         }
2840         spin_unlock_irqrestore(ap->lock, flags);
2841
2842         WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
2843
2844         if (ap->ops->port_resume)
2845                 rc = ap->ops->port_resume(ap);
2846
2847         /* tell ACPI that we're resuming */
2848         ata_acpi_on_resume(ap);
2849
2850         /* report result */
2851         spin_lock_irqsave(ap->lock, flags);
2852         ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
2853         if (ap->pm_result) {
2854                 *ap->pm_result = rc;
2855                 ap->pm_result = NULL;
2856         }
2857         spin_unlock_irqrestore(ap->lock, flags);
2858 }
2859 #endif /* CONFIG_PM */