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