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