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