Pull thinkpad-2.6.24 into release branch
[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         struct ata_device *dev;
1751         unsigned int all_err_mask = 0;
1752         int tag, is_io = 0;
1753         u32 serror;
1754         int rc;
1755
1756         DPRINTK("ENTER\n");
1757
1758         if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
1759                 return;
1760
1761         /* obtain and analyze SError */
1762         rc = sata_scr_read(link, SCR_ERROR, &serror);
1763         if (rc == 0) {
1764                 ehc->i.serror |= serror;
1765                 ata_eh_analyze_serror(link);
1766         } else if (rc != -EOPNOTSUPP) {
1767                 /* SError read failed, force hardreset and probing */
1768                 ata_ehi_schedule_probe(&ehc->i);
1769                 ehc->i.action |= ATA_EH_HARDRESET;
1770                 ehc->i.err_mask |= AC_ERR_OTHER;
1771         }
1772
1773         /* analyze NCQ failure */
1774         ata_eh_analyze_ncq_error(link);
1775
1776         /* any real error trumps AC_ERR_OTHER */
1777         if (ehc->i.err_mask & ~AC_ERR_OTHER)
1778                 ehc->i.err_mask &= ~AC_ERR_OTHER;
1779
1780         all_err_mask |= ehc->i.err_mask;
1781
1782         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1783                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1784
1785                 if (!(qc->flags & ATA_QCFLAG_FAILED) || qc->dev->link != link)
1786                         continue;
1787
1788                 /* inherit upper level err_mask */
1789                 qc->err_mask |= ehc->i.err_mask;
1790
1791                 /* analyze TF */
1792                 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
1793
1794                 /* DEV errors are probably spurious in case of ATA_BUS error */
1795                 if (qc->err_mask & AC_ERR_ATA_BUS)
1796                         qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
1797                                           AC_ERR_INVALID);
1798
1799                 /* any real error trumps unknown error */
1800                 if (qc->err_mask & ~AC_ERR_OTHER)
1801                         qc->err_mask &= ~AC_ERR_OTHER;
1802
1803                 /* SENSE_VALID trumps dev/unknown error and revalidation */
1804                 if (qc->flags & ATA_QCFLAG_SENSE_VALID)
1805                         qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
1806
1807                 /* accumulate error info */
1808                 ehc->i.dev = qc->dev;
1809                 all_err_mask |= qc->err_mask;
1810                 if (qc->flags & ATA_QCFLAG_IO)
1811                         is_io = 1;
1812         }
1813
1814         /* enforce default EH actions */
1815         if (ap->pflags & ATA_PFLAG_FROZEN ||
1816             all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
1817                 ehc->i.action |= ATA_EH_SOFTRESET;
1818         else if ((is_io && all_err_mask) ||
1819                  (!is_io && (all_err_mask & ~AC_ERR_DEV)))
1820                 ehc->i.action |= ATA_EH_REVALIDATE;
1821
1822         /* If we have offending qcs and the associated failed device,
1823          * perform per-dev EH action only on the offending device.
1824          */
1825         if (ehc->i.dev) {
1826                 ehc->i.dev_action[ehc->i.dev->devno] |=
1827                         ehc->i.action & ATA_EH_PERDEV_MASK;
1828                 ehc->i.action &= ~ATA_EH_PERDEV_MASK;
1829         }
1830
1831         /* consider speeding down */
1832         dev = ehc->i.dev;
1833         if (!dev && ata_link_max_devices(link) == 1 &&
1834             ata_dev_enabled(link->device))
1835                 dev = link->device;
1836
1837         if (dev)
1838                 ehc->i.action |= ata_eh_speed_down(dev, is_io, all_err_mask);
1839
1840         DPRINTK("EXIT\n");
1841 }
1842
1843 /**
1844  *      ata_eh_autopsy - analyze error and determine recovery action
1845  *      @ap: host port to perform autopsy on
1846  *
1847  *      Analyze all links of @ap and determine why they failed and
1848  *      which recovery actions are needed.
1849  *
1850  *      LOCKING:
1851  *      Kernel thread context (may sleep).
1852  */
1853 void ata_eh_autopsy(struct ata_port *ap)
1854 {
1855         struct ata_link *link;
1856
1857         __ata_port_for_each_link(link, ap)
1858                 ata_eh_link_autopsy(link);
1859 }
1860
1861 /**
1862  *      ata_eh_link_report - report error handling to user
1863  *      @link: ATA link EH is going on
1864  *
1865  *      Report EH to user.
1866  *
1867  *      LOCKING:
1868  *      None.
1869  */
1870 static void ata_eh_link_report(struct ata_link *link)
1871 {
1872         struct ata_port *ap = link->ap;
1873         struct ata_eh_context *ehc = &link->eh_context;
1874         const char *frozen, *desc;
1875         char tries_buf[6];
1876         int tag, nr_failed = 0;
1877
1878         if (ehc->i.flags & ATA_EHI_QUIET)
1879                 return;
1880
1881         desc = NULL;
1882         if (ehc->i.desc[0] != '\0')
1883                 desc = ehc->i.desc;
1884
1885         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1886                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1887
1888                 if (!(qc->flags & ATA_QCFLAG_FAILED) || qc->dev->link != link ||
1889                     ((qc->flags & ATA_QCFLAG_QUIET) &&
1890                      qc->err_mask == AC_ERR_DEV))
1891                         continue;
1892                 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
1893                         continue;
1894
1895                 nr_failed++;
1896         }
1897
1898         if (!nr_failed && !ehc->i.err_mask)
1899                 return;
1900
1901         frozen = "";
1902         if (ap->pflags & ATA_PFLAG_FROZEN)
1903                 frozen = " frozen";
1904
1905         memset(tries_buf, 0, sizeof(tries_buf));
1906         if (ap->eh_tries < ATA_EH_MAX_TRIES)
1907                 snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
1908                          ap->eh_tries);
1909
1910         if (ehc->i.dev) {
1911                 ata_dev_printk(ehc->i.dev, 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_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc);
1917         } else {
1918                 ata_link_printk(link, KERN_ERR, "exception Emask 0x%x "
1919                                 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
1920                                 ehc->i.err_mask, link->sactive, ehc->i.serror,
1921                                 ehc->i.action, frozen, tries_buf);
1922                 if (desc)
1923                         ata_link_printk(link, KERN_ERR, "%s\n", desc);
1924         }
1925
1926         if (ehc->i.serror)
1927                 ata_port_printk(ap, KERN_ERR,
1928                   "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
1929                   ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
1930                   ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
1931                   ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
1932                   ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
1933                   ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
1934                   ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
1935                   ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
1936                   ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
1937                   ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
1938                   ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
1939                   ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
1940                   ehc->i.serror & SERR_CRC ? "BadCRC " : "",
1941                   ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
1942                   ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
1943                   ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
1944                   ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
1945                   ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
1946
1947         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1948                 static const char *dma_str[] = {
1949                         [DMA_BIDIRECTIONAL]     = "bidi",
1950                         [DMA_TO_DEVICE]         = "out",
1951                         [DMA_FROM_DEVICE]       = "in",
1952                         [DMA_NONE]              = "",
1953                 };
1954                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1955                 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
1956
1957                 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
1958                     qc->dev->link != link || !qc->err_mask)
1959                         continue;
1960
1961                 ata_dev_printk(qc->dev, KERN_ERR,
1962                         "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
1963                         "tag %d cdb 0x%x data %u %s\n         "
1964                         "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
1965                         "Emask 0x%x (%s)%s\n",
1966                         cmd->command, cmd->feature, cmd->nsect,
1967                         cmd->lbal, cmd->lbam, cmd->lbah,
1968                         cmd->hob_feature, cmd->hob_nsect,
1969                         cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
1970                         cmd->device, qc->tag, qc->cdb[0], qc->nbytes,
1971                         dma_str[qc->dma_dir],
1972                         res->command, res->feature, res->nsect,
1973                         res->lbal, res->lbam, res->lbah,
1974                         res->hob_feature, res->hob_nsect,
1975                         res->hob_lbal, res->hob_lbam, res->hob_lbah,
1976                         res->device, qc->err_mask, ata_err_string(qc->err_mask),
1977                         qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
1978
1979                 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
1980                                     ATA_ERR)) {
1981                         if (res->command & ATA_BUSY)
1982                                 ata_dev_printk(qc->dev, KERN_ERR,
1983                                   "status: { Busy }\n");
1984                         else
1985                                 ata_dev_printk(qc->dev, KERN_ERR,
1986                                   "status: { %s%s%s%s}\n",
1987                                   res->command & ATA_DRDY ? "DRDY " : "",
1988                                   res->command & ATA_DF ? "DF " : "",
1989                                   res->command & ATA_DRQ ? "DRQ " : "",
1990                                   res->command & ATA_ERR ? "ERR " : "");
1991                 }
1992
1993                 if (cmd->command != ATA_CMD_PACKET &&
1994                     (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
1995                                      ATA_ABORTED)))
1996                         ata_dev_printk(qc->dev, KERN_ERR,
1997                           "error: { %s%s%s%s}\n",
1998                           res->feature & ATA_ICRC ? "ICRC " : "",
1999                           res->feature & ATA_UNC ? "UNC " : "",
2000                           res->feature & ATA_IDNF ? "IDNF " : "",
2001                           res->feature & ATA_ABORTED ? "ABRT " : "");
2002         }
2003 }
2004
2005 /**
2006  *      ata_eh_report - report error handling to user
2007  *      @ap: ATA port to report EH about
2008  *
2009  *      Report EH to user.
2010  *
2011  *      LOCKING:
2012  *      None.
2013  */
2014 void ata_eh_report(struct ata_port *ap)
2015 {
2016         struct ata_link *link;
2017
2018         __ata_port_for_each_link(link, ap)
2019                 ata_eh_link_report(link);
2020 }
2021
2022 static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
2023                         unsigned int *classes, unsigned long deadline)
2024 {
2025         struct ata_device *dev;
2026         int rc;
2027
2028         ata_link_for_each_dev(dev, link)
2029                 classes[dev->devno] = ATA_DEV_UNKNOWN;
2030
2031         rc = reset(link, classes, deadline);
2032         if (rc)
2033                 return rc;
2034
2035         /* If any class isn't ATA_DEV_UNKNOWN, consider classification
2036          * is complete and convert all ATA_DEV_UNKNOWN to
2037          * ATA_DEV_NONE.
2038          */
2039         ata_link_for_each_dev(dev, link)
2040                 if (classes[dev->devno] != ATA_DEV_UNKNOWN)
2041                         break;
2042
2043         if (dev) {
2044                 ata_link_for_each_dev(dev, link) {
2045                         if (classes[dev->devno] == ATA_DEV_UNKNOWN)
2046                                 classes[dev->devno] = ATA_DEV_NONE;
2047                 }
2048         }
2049
2050         return 0;
2051 }
2052
2053 static int ata_eh_followup_srst_needed(struct ata_link *link,
2054                                        int rc, int classify,
2055                                        const unsigned int *classes)
2056 {
2057         if (link->flags & ATA_LFLAG_NO_SRST)
2058                 return 0;
2059         if (rc == -EAGAIN)
2060                 return 1;
2061         if (rc != 0)
2062                 return 0;
2063         if ((link->ap->flags & ATA_FLAG_PMP) && ata_is_host_link(link))
2064                 return 1;
2065         if (classify && !(link->flags & ATA_LFLAG_ASSUME_CLASS) &&
2066             classes[0] == ATA_DEV_UNKNOWN)
2067                 return 1;
2068         return 0;
2069 }
2070
2071 int ata_eh_reset(struct ata_link *link, int classify,
2072                  ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
2073                  ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
2074 {
2075         const int max_tries = ARRAY_SIZE(ata_eh_reset_timeouts);
2076         struct ata_port *ap = link->ap;
2077         struct ata_eh_context *ehc = &link->eh_context;
2078         unsigned int *classes = ehc->classes;
2079         unsigned int lflags = link->flags;
2080         int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
2081         int try = 0;
2082         struct ata_device *dev;
2083         unsigned long deadline, now;
2084         unsigned int tmp_action;
2085         ata_reset_fn_t reset;
2086         unsigned long flags;
2087         u32 sstatus;
2088         int rc;
2089
2090         /* about to reset */
2091         spin_lock_irqsave(ap->lock, flags);
2092         ap->pflags |= ATA_PFLAG_RESETTING;
2093         spin_unlock_irqrestore(ap->lock, flags);
2094
2095         ata_eh_about_to_do(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
2096
2097         ata_link_for_each_dev(dev, link) {
2098                 /* If we issue an SRST then an ATA drive (not ATAPI)
2099                  * may change configuration and be in PIO0 timing. If
2100                  * we do a hard reset (or are coming from power on)
2101                  * this is true for ATA or ATAPI. Until we've set a
2102                  * suitable controller mode we should not touch the
2103                  * bus as we may be talking too fast.
2104                  */
2105                 dev->pio_mode = XFER_PIO_0;
2106
2107                 /* If the controller has a pio mode setup function
2108                  * then use it to set the chipset to rights. Don't
2109                  * touch the DMA setup as that will be dealt with when
2110                  * configuring devices.
2111                  */
2112                 if (ap->ops->set_piomode)
2113                         ap->ops->set_piomode(ap, dev);
2114         }
2115
2116         /* Determine which reset to use and record in ehc->i.action.
2117          * prereset() may examine and modify it.
2118          */
2119         if (softreset && (!hardreset || (!(lflags & ATA_LFLAG_NO_SRST) &&
2120                                          !sata_set_spd_needed(link) &&
2121                                          !(ehc->i.action & ATA_EH_HARDRESET))))
2122                 tmp_action = ATA_EH_SOFTRESET;
2123         else
2124                 tmp_action = ATA_EH_HARDRESET;
2125
2126         ehc->i.action = (ehc->i.action & ~ATA_EH_RESET_MASK) | tmp_action;
2127
2128         if (prereset) {
2129                 rc = prereset(link, jiffies + ATA_EH_PRERESET_TIMEOUT);
2130                 if (rc) {
2131                         if (rc == -ENOENT) {
2132                                 ata_link_printk(link, KERN_DEBUG,
2133                                                 "port disabled. ignoring.\n");
2134                                 ehc->i.action &= ~ATA_EH_RESET_MASK;
2135
2136                                 ata_link_for_each_dev(dev, link)
2137                                         classes[dev->devno] = ATA_DEV_NONE;
2138
2139                                 rc = 0;
2140                         } else
2141                                 ata_link_printk(link, KERN_ERR,
2142                                         "prereset failed (errno=%d)\n", rc);
2143                         goto out;
2144                 }
2145         }
2146
2147         /* prereset() might have modified ehc->i.action */
2148         if (ehc->i.action & ATA_EH_HARDRESET)
2149                 reset = hardreset;
2150         else if (ehc->i.action & ATA_EH_SOFTRESET)
2151                 reset = softreset;
2152         else {
2153                 /* prereset told us not to reset, bang classes and return */
2154                 ata_link_for_each_dev(dev, link)
2155                         classes[dev->devno] = ATA_DEV_NONE;
2156                 rc = 0;
2157                 goto out;
2158         }
2159
2160         /* did prereset() screw up?  if so, fix up to avoid oopsing */
2161         if (!reset) {
2162                 if (softreset)
2163                         reset = softreset;
2164                 else
2165                         reset = hardreset;
2166         }
2167
2168  retry:
2169         deadline = jiffies + ata_eh_reset_timeouts[try++];
2170
2171         /* shut up during boot probing */
2172         if (verbose)
2173                 ata_link_printk(link, KERN_INFO, "%s resetting link\n",
2174                                 reset == softreset ? "soft" : "hard");
2175
2176         /* mark that this EH session started with reset */
2177         if (reset == hardreset)
2178                 ehc->i.flags |= ATA_EHI_DID_HARDRESET;
2179         else
2180                 ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
2181
2182         rc = ata_do_reset(link, reset, classes, deadline);
2183
2184         if (reset == hardreset &&
2185             ata_eh_followup_srst_needed(link, rc, classify, classes)) {
2186                 /* okay, let's do follow-up softreset */
2187                 reset = softreset;
2188
2189                 if (!reset) {
2190                         ata_link_printk(link, KERN_ERR,
2191                                         "follow-up softreset required "
2192                                         "but no softreset avaliable\n");
2193                         rc = -EINVAL;
2194                         goto fail;
2195                 }
2196
2197                 ata_eh_about_to_do(link, NULL, ATA_EH_RESET_MASK);
2198                 rc = ata_do_reset(link, reset, classes, deadline);
2199         }
2200
2201         /* -EAGAIN can happen if we skipped followup SRST */
2202         if (rc && rc != -EAGAIN)
2203                 goto fail;
2204
2205         /* was classification successful? */
2206         if (classify && classes[0] == ATA_DEV_UNKNOWN &&
2207             !(lflags & ATA_LFLAG_ASSUME_CLASS)) {
2208                 if (try < max_tries) {
2209                         ata_link_printk(link, KERN_WARNING,
2210                                         "classification failed\n");
2211                         rc = -EINVAL;
2212                         goto fail;
2213                 }
2214
2215                 ata_link_printk(link, KERN_WARNING,
2216                                 "classfication failed, assuming ATA\n");
2217                 lflags |= ATA_LFLAG_ASSUME_ATA;
2218         }
2219
2220         ata_link_for_each_dev(dev, link) {
2221                 /* After the reset, the device state is PIO 0 and the
2222                  * controller state is undefined.  Reset also wakes up
2223                  * drives from sleeping mode.
2224                  */
2225                 dev->pio_mode = XFER_PIO_0;
2226                 dev->flags &= ~ATA_DFLAG_SLEEPING;
2227
2228                 if (ata_link_offline(link))
2229                         continue;
2230
2231                 /* apply class override and convert UNKNOWN to NONE */
2232                 if (lflags & ATA_LFLAG_ASSUME_ATA)
2233                         classes[dev->devno] = ATA_DEV_ATA;
2234                 else if (lflags & ATA_LFLAG_ASSUME_SEMB)
2235                         classes[dev->devno] = ATA_DEV_SEMB_UNSUP; /* not yet */
2236                 else if (classes[dev->devno] == ATA_DEV_UNKNOWN)
2237                         classes[dev->devno] = ATA_DEV_NONE;
2238         }
2239
2240         /* record current link speed */
2241         if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
2242                 link->sata_spd = (sstatus >> 4) & 0xf;
2243
2244         if (postreset)
2245                 postreset(link, classes);
2246
2247         /* reset successful, schedule revalidation */
2248         ata_eh_done(link, NULL, ehc->i.action & ATA_EH_RESET_MASK);
2249         ehc->i.action |= ATA_EH_REVALIDATE;
2250
2251         rc = 0;
2252  out:
2253         /* clear hotplug flag */
2254         ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
2255
2256         spin_lock_irqsave(ap->lock, flags);
2257         ap->pflags &= ~ATA_PFLAG_RESETTING;
2258         spin_unlock_irqrestore(ap->lock, flags);
2259
2260         return rc;
2261
2262  fail:
2263         if (rc == -ERESTART || try >= max_tries)
2264                 goto out;
2265
2266         now = jiffies;
2267         if (time_before(now, deadline)) {
2268                 unsigned long delta = deadline - now;
2269
2270                 ata_link_printk(link, KERN_WARNING, "reset failed "
2271                                 "(errno=%d), retrying in %u secs\n",
2272                                 rc, (jiffies_to_msecs(delta) + 999) / 1000);
2273
2274                 while (delta)
2275                         delta = schedule_timeout_uninterruptible(delta);
2276         }
2277
2278         if (rc == -EPIPE || try == max_tries - 1)
2279                 sata_down_spd_limit(link);
2280         if (hardreset)
2281                 reset = hardreset;
2282         goto retry;
2283 }
2284
2285 static int ata_eh_revalidate_and_attach(struct ata_link *link,
2286                                         struct ata_device **r_failed_dev)
2287 {
2288         struct ata_port *ap = link->ap;
2289         struct ata_eh_context *ehc = &link->eh_context;
2290         struct ata_device *dev;
2291         unsigned int new_mask = 0;
2292         unsigned long flags;
2293         int rc = 0;
2294
2295         DPRINTK("ENTER\n");
2296
2297         /* For PATA drive side cable detection to work, IDENTIFY must
2298          * be done backwards such that PDIAG- is released by the slave
2299          * device before the master device is identified.
2300          */
2301         ata_link_for_each_dev_reverse(dev, link) {
2302                 unsigned int action = ata_eh_dev_action(dev);
2303                 unsigned int readid_flags = 0;
2304
2305                 if (ehc->i.flags & ATA_EHI_DID_RESET)
2306                         readid_flags |= ATA_READID_POSTRESET;
2307
2308                 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
2309                         WARN_ON(dev->class == ATA_DEV_PMP);
2310
2311                         if (ata_link_offline(link)) {
2312                                 rc = -EIO;
2313                                 goto err;
2314                         }
2315
2316                         ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
2317                         rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
2318                                                 readid_flags);
2319                         if (rc)
2320                                 goto err;
2321
2322                         ata_eh_done(link, dev, ATA_EH_REVALIDATE);
2323
2324                         /* Configuration may have changed, reconfigure
2325                          * transfer mode.
2326                          */
2327                         ehc->i.flags |= ATA_EHI_SETMODE;
2328
2329                         /* schedule the scsi_rescan_device() here */
2330                         queue_work(ata_aux_wq, &(ap->scsi_rescan_task));
2331                 } else if (dev->class == ATA_DEV_UNKNOWN &&
2332                            ehc->tries[dev->devno] &&
2333                            ata_class_enabled(ehc->classes[dev->devno])) {
2334                         dev->class = ehc->classes[dev->devno];
2335
2336                         if (dev->class == ATA_DEV_PMP)
2337                                 rc = sata_pmp_attach(dev);
2338                         else
2339                                 rc = ata_dev_read_id(dev, &dev->class,
2340                                                      readid_flags, dev->id);
2341                         switch (rc) {
2342                         case 0:
2343                                 new_mask |= 1 << dev->devno;
2344                                 break;
2345                         case -ENOENT:
2346                                 /* IDENTIFY was issued to non-existent
2347                                  * device.  No need to reset.  Just
2348                                  * thaw and kill the device.
2349                                  */
2350                                 ata_eh_thaw_port(ap);
2351                                 dev->class = ATA_DEV_UNKNOWN;
2352                                 break;
2353                         default:
2354                                 dev->class = ATA_DEV_UNKNOWN;
2355                                 goto err;
2356                         }
2357                 }
2358         }
2359
2360         /* PDIAG- should have been released, ask cable type if post-reset */
2361         if (ata_is_host_link(link) && ap->ops->cable_detect &&
2362             (ehc->i.flags & ATA_EHI_DID_RESET))
2363                 ap->cbl = ap->ops->cable_detect(ap);
2364
2365         /* Configure new devices forward such that user doesn't see
2366          * device detection messages backwards.
2367          */
2368         ata_link_for_each_dev(dev, link) {
2369                 if (!(new_mask & (1 << dev->devno)) ||
2370                     dev->class == ATA_DEV_PMP)
2371                         continue;
2372
2373                 ehc->i.flags |= ATA_EHI_PRINTINFO;
2374                 rc = ata_dev_configure(dev);
2375                 ehc->i.flags &= ~ATA_EHI_PRINTINFO;
2376                 if (rc)
2377                         goto err;
2378
2379                 spin_lock_irqsave(ap->lock, flags);
2380                 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
2381                 spin_unlock_irqrestore(ap->lock, flags);
2382
2383                 /* new device discovered, configure xfermode */
2384                 ehc->i.flags |= ATA_EHI_SETMODE;
2385         }
2386
2387         return 0;
2388
2389  err:
2390         *r_failed_dev = dev;
2391         DPRINTK("EXIT rc=%d\n", rc);
2392         return rc;
2393 }
2394
2395 static int ata_link_nr_enabled(struct ata_link *link)
2396 {
2397         struct ata_device *dev;
2398         int cnt = 0;
2399
2400         ata_link_for_each_dev(dev, link)
2401                 if (ata_dev_enabled(dev))
2402                         cnt++;
2403         return cnt;
2404 }
2405
2406 static int ata_link_nr_vacant(struct ata_link *link)
2407 {
2408         struct ata_device *dev;
2409         int cnt = 0;
2410
2411         ata_link_for_each_dev(dev, link)
2412                 if (dev->class == ATA_DEV_UNKNOWN)
2413                         cnt++;
2414         return cnt;
2415 }
2416
2417 static int ata_eh_skip_recovery(struct ata_link *link)
2418 {
2419         struct ata_eh_context *ehc = &link->eh_context;
2420         struct ata_device *dev;
2421
2422         /* skip disabled links */
2423         if (link->flags & ATA_LFLAG_DISABLED)
2424                 return 1;
2425
2426         /* thaw frozen port, resume link and recover failed devices */
2427         if ((link->ap->pflags & ATA_PFLAG_FROZEN) ||
2428             (ehc->i.flags & ATA_EHI_RESUME_LINK) || ata_link_nr_enabled(link))
2429                 return 0;
2430
2431         /* skip if class codes for all vacant slots are ATA_DEV_NONE */
2432         ata_link_for_each_dev(dev, link) {
2433                 if (dev->class == ATA_DEV_UNKNOWN &&
2434                     ehc->classes[dev->devno] != ATA_DEV_NONE)
2435                         return 0;
2436         }
2437
2438         return 1;
2439 }
2440
2441 static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
2442 {
2443         struct ata_eh_context *ehc = &dev->link->eh_context;
2444
2445         ehc->tries[dev->devno]--;
2446
2447         switch (err) {
2448         case -ENODEV:
2449                 /* device missing or wrong IDENTIFY data, schedule probing */
2450                 ehc->i.probe_mask |= (1 << dev->devno);
2451         case -EINVAL:
2452                 /* give it just one more chance */
2453                 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
2454         case -EIO:
2455                 if (ehc->tries[dev->devno] == 1 && dev->pio_mode > XFER_PIO_0) {
2456                         /* This is the last chance, better to slow
2457                          * down than lose it.
2458                          */
2459                         sata_down_spd_limit(dev->link);
2460                         ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
2461                 }
2462         }
2463
2464         if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
2465                 /* disable device if it has used up all its chances */
2466                 ata_dev_disable(dev);
2467
2468                 /* detach if offline */
2469                 if (ata_link_offline(dev->link))
2470                         ata_eh_detach_dev(dev);
2471
2472                 /* probe if requested */
2473                 if ((ehc->i.probe_mask & (1 << dev->devno)) &&
2474                     !(ehc->did_probe_mask & (1 << dev->devno))) {
2475                         ata_eh_detach_dev(dev);
2476                         ata_dev_init(dev);
2477
2478                         ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
2479                         ehc->did_probe_mask |= (1 << dev->devno);
2480                         ehc->i.action |= ATA_EH_SOFTRESET;
2481                 }
2482
2483                 return 1;
2484         } else {
2485                 /* soft didn't work?  be haaaaard */
2486                 if (ehc->i.flags & ATA_EHI_DID_RESET)
2487                         ehc->i.action |= ATA_EH_HARDRESET;
2488                 else
2489                         ehc->i.action |= ATA_EH_SOFTRESET;
2490
2491                 return 0;
2492         }
2493 }
2494
2495 /**
2496  *      ata_eh_recover - recover host port after error
2497  *      @ap: host port to recover
2498  *      @prereset: prereset method (can be NULL)
2499  *      @softreset: softreset method (can be NULL)
2500  *      @hardreset: hardreset method (can be NULL)
2501  *      @postreset: postreset method (can be NULL)
2502  *      @r_failed_link: out parameter for failed link
2503  *
2504  *      This is the alpha and omega, eum and yang, heart and soul of
2505  *      libata exception handling.  On entry, actions required to
2506  *      recover each link and hotplug requests are recorded in the
2507  *      link's eh_context.  This function executes all the operations
2508  *      with appropriate retrials and fallbacks to resurrect failed
2509  *      devices, detach goners and greet newcomers.
2510  *
2511  *      LOCKING:
2512  *      Kernel thread context (may sleep).
2513  *
2514  *      RETURNS:
2515  *      0 on success, -errno on failure.
2516  */
2517 int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
2518                    ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
2519                    ata_postreset_fn_t postreset,
2520                    struct ata_link **r_failed_link)
2521 {
2522         struct ata_link *link;
2523         struct ata_device *dev;
2524         int nr_failed_devs, nr_disabled_devs;
2525         int reset, rc;
2526         unsigned long flags;
2527
2528         DPRINTK("ENTER\n");
2529
2530         /* prep for recovery */
2531         ata_port_for_each_link(link, ap) {
2532                 struct ata_eh_context *ehc = &link->eh_context;
2533
2534                 /* re-enable link? */
2535                 if (ehc->i.action & ATA_EH_ENABLE_LINK) {
2536                         ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
2537                         spin_lock_irqsave(ap->lock, flags);
2538                         link->flags &= ~ATA_LFLAG_DISABLED;
2539                         spin_unlock_irqrestore(ap->lock, flags);
2540                         ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
2541                 }
2542
2543                 ata_link_for_each_dev(dev, link) {
2544                         if (link->flags & ATA_LFLAG_NO_RETRY)
2545                                 ehc->tries[dev->devno] = 1;
2546                         else
2547                                 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
2548
2549                         /* collect port action mask recorded in dev actions */
2550                         ehc->i.action |= ehc->i.dev_action[dev->devno] &
2551                                          ~ATA_EH_PERDEV_MASK;
2552                         ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
2553
2554                         /* process hotplug request */
2555                         if (dev->flags & ATA_DFLAG_DETACH)
2556                                 ata_eh_detach_dev(dev);
2557
2558                         if (!ata_dev_enabled(dev) &&
2559                             ((ehc->i.probe_mask & (1 << dev->devno)) &&
2560                              !(ehc->did_probe_mask & (1 << dev->devno)))) {
2561                                 ata_eh_detach_dev(dev);
2562                                 ata_dev_init(dev);
2563                                 ehc->did_probe_mask |= (1 << dev->devno);
2564                                 ehc->i.action |= ATA_EH_SOFTRESET;
2565                         }
2566                 }
2567         }
2568
2569  retry:
2570         rc = 0;
2571         nr_failed_devs = 0;
2572         nr_disabled_devs = 0;
2573         reset = 0;
2574
2575         /* if UNLOADING, finish immediately */
2576         if (ap->pflags & ATA_PFLAG_UNLOADING)
2577                 goto out;
2578
2579         /* prep for EH */
2580         ata_port_for_each_link(link, ap) {
2581                 struct ata_eh_context *ehc = &link->eh_context;
2582
2583                 /* skip EH if possible. */
2584                 if (ata_eh_skip_recovery(link))
2585                         ehc->i.action = 0;
2586
2587                 /* do we need to reset? */
2588                 if (ehc->i.action & ATA_EH_RESET_MASK)
2589                         reset = 1;
2590
2591                 ata_link_for_each_dev(dev, link)
2592                         ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
2593         }
2594
2595         /* reset */
2596         if (reset) {
2597                 /* if PMP is attached, this function only deals with
2598                  * downstream links, port should stay thawed.
2599                  */
2600                 if (!ap->nr_pmp_links)
2601                         ata_eh_freeze_port(ap);
2602
2603                 ata_port_for_each_link(link, ap) {
2604                         struct ata_eh_context *ehc = &link->eh_context;
2605
2606                         if (!(ehc->i.action & ATA_EH_RESET_MASK))
2607                                 continue;
2608
2609                         rc = ata_eh_reset(link, ata_link_nr_vacant(link),
2610                                           prereset, softreset, hardreset,
2611                                           postreset);
2612                         if (rc) {
2613                                 ata_link_printk(link, KERN_ERR,
2614                                                 "reset failed, giving up\n");
2615                                 goto out;
2616                         }
2617                 }
2618
2619                 if (!ap->nr_pmp_links)
2620                         ata_eh_thaw_port(ap);
2621         }
2622
2623         /* the rest */
2624         ata_port_for_each_link(link, ap) {
2625                 struct ata_eh_context *ehc = &link->eh_context;
2626
2627                 /* revalidate existing devices and attach new ones */
2628                 rc = ata_eh_revalidate_and_attach(link, &dev);
2629                 if (rc)
2630                         goto dev_fail;
2631
2632                 /* if PMP got attached, return, pmp EH will take care of it */
2633                 if (link->device->class == ATA_DEV_PMP) {
2634                         ehc->i.action = 0;
2635                         return 0;
2636                 }
2637
2638                 /* configure transfer mode if necessary */
2639                 if (ehc->i.flags & ATA_EHI_SETMODE) {
2640                         rc = ata_set_mode(link, &dev);
2641                         if (rc)
2642                                 goto dev_fail;
2643                         ehc->i.flags &= ~ATA_EHI_SETMODE;
2644                 }
2645
2646                 if (ehc->i.action & ATA_EHI_LPM)
2647                         ata_link_for_each_dev(dev, link)
2648                                 ata_dev_enable_pm(dev, ap->pm_policy);
2649
2650                 /* this link is okay now */
2651                 ehc->i.flags = 0;
2652                 continue;
2653
2654 dev_fail:
2655                 nr_failed_devs++;
2656                 if (ata_eh_handle_dev_fail(dev, rc))
2657                         nr_disabled_devs++;
2658
2659                 if (ap->pflags & ATA_PFLAG_FROZEN) {
2660                         /* PMP reset requires working host port.
2661                          * Can't retry if it's frozen.
2662                          */
2663                         if (ap->nr_pmp_links)
2664                                 goto out;
2665                         break;
2666                 }
2667         }
2668
2669         if (nr_failed_devs) {
2670                 if (nr_failed_devs != nr_disabled_devs) {
2671                         ata_port_printk(ap, KERN_WARNING, "failed to recover "
2672                                         "some devices, retrying in 5 secs\n");
2673                         ssleep(5);
2674                 } else {
2675                         /* no device left to recover, repeat fast */
2676                         msleep(500);
2677                 }
2678
2679                 goto retry;
2680         }
2681
2682  out:
2683         if (rc && r_failed_link)
2684                 *r_failed_link = link;
2685
2686         DPRINTK("EXIT, rc=%d\n", rc);
2687         return rc;
2688 }
2689
2690 /**
2691  *      ata_eh_finish - finish up EH
2692  *      @ap: host port to finish EH for
2693  *
2694  *      Recovery is complete.  Clean up EH states and retry or finish
2695  *      failed qcs.
2696  *
2697  *      LOCKING:
2698  *      None.
2699  */
2700 void ata_eh_finish(struct ata_port *ap)
2701 {
2702         int tag;
2703
2704         /* retry or finish qcs */
2705         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2706                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2707
2708                 if (!(qc->flags & ATA_QCFLAG_FAILED))
2709                         continue;
2710
2711                 if (qc->err_mask) {
2712                         /* FIXME: Once EH migration is complete,
2713                          * generate sense data in this function,
2714                          * considering both err_mask and tf.
2715                          *
2716                          * There's no point in retrying invalid
2717                          * (detected by libata) and non-IO device
2718                          * errors (rejected by device).  Finish them
2719                          * immediately.
2720                          */
2721                         if ((qc->err_mask & AC_ERR_INVALID) ||
2722                             (!(qc->flags & ATA_QCFLAG_IO) &&
2723                              qc->err_mask == AC_ERR_DEV))
2724                                 ata_eh_qc_complete(qc);
2725                         else
2726                                 ata_eh_qc_retry(qc);
2727                 } else {
2728                         if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
2729                                 ata_eh_qc_complete(qc);
2730                         } else {
2731                                 /* feed zero TF to sense generation */
2732                                 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
2733                                 ata_eh_qc_retry(qc);
2734                         }
2735                 }
2736         }
2737
2738         /* make sure nr_active_links is zero after EH */
2739         WARN_ON(ap->nr_active_links);
2740         ap->nr_active_links = 0;
2741 }
2742
2743 /**
2744  *      ata_do_eh - do standard error handling
2745  *      @ap: host port to handle error for
2746  *      @prereset: prereset method (can be NULL)
2747  *      @softreset: softreset method (can be NULL)
2748  *      @hardreset: hardreset method (can be NULL)
2749  *      @postreset: postreset method (can be NULL)
2750  *
2751  *      Perform standard error handling sequence.
2752  *
2753  *      LOCKING:
2754  *      Kernel thread context (may sleep).
2755  */
2756 void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
2757                ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
2758                ata_postreset_fn_t postreset)
2759 {
2760         struct ata_device *dev;
2761         int rc;
2762
2763         ata_eh_autopsy(ap);
2764         ata_eh_report(ap);
2765
2766         rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
2767                             NULL);
2768         if (rc) {
2769                 ata_link_for_each_dev(dev, &ap->link)
2770                         ata_dev_disable(dev);
2771         }
2772
2773         ata_eh_finish(ap);
2774 }
2775
2776 #ifdef CONFIG_PM
2777 /**
2778  *      ata_eh_handle_port_suspend - perform port suspend operation
2779  *      @ap: port to suspend
2780  *
2781  *      Suspend @ap.
2782  *
2783  *      LOCKING:
2784  *      Kernel thread context (may sleep).
2785  */
2786 static void ata_eh_handle_port_suspend(struct ata_port *ap)
2787 {
2788         unsigned long flags;
2789         int rc = 0;
2790
2791         /* are we suspending? */
2792         spin_lock_irqsave(ap->lock, flags);
2793         if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
2794             ap->pm_mesg.event == PM_EVENT_ON) {
2795                 spin_unlock_irqrestore(ap->lock, flags);
2796                 return;
2797         }
2798         spin_unlock_irqrestore(ap->lock, flags);
2799
2800         WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
2801
2802         /* tell ACPI we're suspending */
2803         rc = ata_acpi_on_suspend(ap);
2804         if (rc)
2805                 goto out;
2806
2807         /* suspend */
2808         ata_eh_freeze_port(ap);
2809
2810         if (ap->ops->port_suspend)
2811                 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
2812
2813  out:
2814         /* report result */
2815         spin_lock_irqsave(ap->lock, flags);
2816
2817         ap->pflags &= ~ATA_PFLAG_PM_PENDING;
2818         if (rc == 0)
2819                 ap->pflags |= ATA_PFLAG_SUSPENDED;
2820         else if (ap->pflags & ATA_PFLAG_FROZEN)
2821                 ata_port_schedule_eh(ap);
2822
2823         if (ap->pm_result) {
2824                 *ap->pm_result = rc;
2825                 ap->pm_result = NULL;
2826         }
2827
2828         spin_unlock_irqrestore(ap->lock, flags);
2829
2830         return;
2831 }
2832
2833 /**
2834  *      ata_eh_handle_port_resume - perform port resume operation
2835  *      @ap: port to resume
2836  *
2837  *      Resume @ap.
2838  *
2839  *      LOCKING:
2840  *      Kernel thread context (may sleep).
2841  */
2842 static void ata_eh_handle_port_resume(struct ata_port *ap)
2843 {
2844         unsigned long flags;
2845         int rc = 0;
2846
2847         /* are we resuming? */
2848         spin_lock_irqsave(ap->lock, flags);
2849         if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
2850             ap->pm_mesg.event != PM_EVENT_ON) {
2851                 spin_unlock_irqrestore(ap->lock, flags);
2852                 return;
2853         }
2854         spin_unlock_irqrestore(ap->lock, flags);
2855
2856         WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
2857
2858         if (ap->ops->port_resume)
2859                 rc = ap->ops->port_resume(ap);
2860
2861         /* tell ACPI that we're resuming */
2862         ata_acpi_on_resume(ap);
2863
2864         /* report result */
2865         spin_lock_irqsave(ap->lock, flags);
2866         ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
2867         if (ap->pm_result) {
2868                 *ap->pm_result = rc;
2869                 ap->pm_result = NULL;
2870         }
2871         spin_unlock_irqrestore(ap->lock, flags);
2872 }
2873 #endif /* CONFIG_PM */