libata-eh: ata_eh_followup_srst_needed() does not need 'classes' parameter
[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_err(ap,
786                                      "EH pending after %d tries, giving up\n",
787                                      ATA_EH_MAX_TRIES);
788                         ap->pflags &= ~ATA_PFLAG_EH_PENDING;
789                 }
790
791                 /* this run is complete, make sure EH info is clear */
792                 ata_for_each_link(link, ap, HOST_FIRST)
793                         memset(&link->eh_info, 0, sizeof(link->eh_info));
794
795                 /* Clear host_eh_scheduled while holding ap->lock such
796                  * that if exception occurs after this point but
797                  * before EH completion, SCSI midlayer will
798                  * re-initiate EH.
799                  */
800                 host->host_eh_scheduled = 0;
801
802                 spin_unlock_irqrestore(ap->lock, flags);
803                 ata_eh_release(ap);
804         } else {
805                 WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
806                 ap->ops->eng_timeout(ap);
807         }
808
809         scsi_eh_flush_done_q(&ap->eh_done_q);
810
811         /* clean up */
812         spin_lock_irqsave(ap->lock, flags);
813
814         if (ap->pflags & ATA_PFLAG_LOADING)
815                 ap->pflags &= ~ATA_PFLAG_LOADING;
816         else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
817                 schedule_delayed_work(&ap->hotplug_task, 0);
818
819         if (ap->pflags & ATA_PFLAG_RECOVERED)
820                 ata_port_info(ap, "EH complete\n");
821
822         ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
823
824         /* tell wait_eh that we're done */
825         ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
826         wake_up_all(&ap->eh_wait_q);
827
828         spin_unlock_irqrestore(ap->lock, flags);
829 }
830 EXPORT_SYMBOL_GPL(ata_scsi_port_error_handler);
831
832 /**
833  *      ata_port_wait_eh - Wait for the currently pending EH to complete
834  *      @ap: Port to wait EH for
835  *
836  *      Wait until the currently pending EH is complete.
837  *
838  *      LOCKING:
839  *      Kernel thread context (may sleep).
840  */
841 void ata_port_wait_eh(struct ata_port *ap)
842 {
843         unsigned long flags;
844         DEFINE_WAIT(wait);
845
846  retry:
847         spin_lock_irqsave(ap->lock, flags);
848
849         while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
850                 prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
851                 spin_unlock_irqrestore(ap->lock, flags);
852                 schedule();
853                 spin_lock_irqsave(ap->lock, flags);
854         }
855         finish_wait(&ap->eh_wait_q, &wait);
856
857         spin_unlock_irqrestore(ap->lock, flags);
858
859         /* make sure SCSI EH is complete */
860         if (scsi_host_in_recovery(ap->scsi_host)) {
861                 ata_msleep(ap, 10);
862                 goto retry;
863         }
864 }
865
866 static int ata_eh_nr_in_flight(struct ata_port *ap)
867 {
868         unsigned int tag;
869         int nr = 0;
870
871         /* count only non-internal commands */
872         for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
873                 if (ata_qc_from_tag(ap, tag))
874                         nr++;
875
876         return nr;
877 }
878
879 void ata_eh_fastdrain_timerfn(unsigned long arg)
880 {
881         struct ata_port *ap = (void *)arg;
882         unsigned long flags;
883         int cnt;
884
885         spin_lock_irqsave(ap->lock, flags);
886
887         cnt = ata_eh_nr_in_flight(ap);
888
889         /* are we done? */
890         if (!cnt)
891                 goto out_unlock;
892
893         if (cnt == ap->fastdrain_cnt) {
894                 unsigned int tag;
895
896                 /* No progress during the last interval, tag all
897                  * in-flight qcs as timed out and freeze the port.
898                  */
899                 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
900                         struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
901                         if (qc)
902                                 qc->err_mask |= AC_ERR_TIMEOUT;
903                 }
904
905                 ata_port_freeze(ap);
906         } else {
907                 /* some qcs have finished, give it another chance */
908                 ap->fastdrain_cnt = cnt;
909                 ap->fastdrain_timer.expires =
910                         ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
911                 add_timer(&ap->fastdrain_timer);
912         }
913
914  out_unlock:
915         spin_unlock_irqrestore(ap->lock, flags);
916 }
917
918 /**
919  *      ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
920  *      @ap: target ATA port
921  *      @fastdrain: activate fast drain
922  *
923  *      Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
924  *      is non-zero and EH wasn't pending before.  Fast drain ensures
925  *      that EH kicks in in timely manner.
926  *
927  *      LOCKING:
928  *      spin_lock_irqsave(host lock)
929  */
930 static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
931 {
932         int cnt;
933
934         /* already scheduled? */
935         if (ap->pflags & ATA_PFLAG_EH_PENDING)
936                 return;
937
938         ap->pflags |= ATA_PFLAG_EH_PENDING;
939
940         if (!fastdrain)
941                 return;
942
943         /* do we have in-flight qcs? */
944         cnt = ata_eh_nr_in_flight(ap);
945         if (!cnt)
946                 return;
947
948         /* activate fast drain */
949         ap->fastdrain_cnt = cnt;
950         ap->fastdrain_timer.expires =
951                 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
952         add_timer(&ap->fastdrain_timer);
953 }
954
955 /**
956  *      ata_qc_schedule_eh - schedule qc for error handling
957  *      @qc: command to schedule error handling for
958  *
959  *      Schedule error handling for @qc.  EH will kick in as soon as
960  *      other commands are drained.
961  *
962  *      LOCKING:
963  *      spin_lock_irqsave(host lock)
964  */
965 void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
966 {
967         struct ata_port *ap = qc->ap;
968         struct request_queue *q = qc->scsicmd->device->request_queue;
969         unsigned long flags;
970
971         WARN_ON(!ap->ops->error_handler);
972
973         qc->flags |= ATA_QCFLAG_FAILED;
974         ata_eh_set_pending(ap, 1);
975
976         /* The following will fail if timeout has already expired.
977          * ata_scsi_error() takes care of such scmds on EH entry.
978          * Note that ATA_QCFLAG_FAILED is unconditionally set after
979          * this function completes.
980          */
981         spin_lock_irqsave(q->queue_lock, flags);
982         blk_abort_request(qc->scsicmd->request);
983         spin_unlock_irqrestore(q->queue_lock, flags);
984 }
985
986 /**
987  *      ata_port_schedule_eh - schedule error handling without a qc
988  *      @ap: ATA port to schedule EH for
989  *
990  *      Schedule error handling for @ap.  EH will kick in as soon as
991  *      all commands are drained.
992  *
993  *      LOCKING:
994  *      spin_lock_irqsave(host lock)
995  */
996 void ata_port_schedule_eh(struct ata_port *ap)
997 {
998         WARN_ON(!ap->ops->error_handler);
999
1000         if (ap->pflags & ATA_PFLAG_INITIALIZING)
1001                 return;
1002
1003         ata_eh_set_pending(ap, 1);
1004         scsi_schedule_eh(ap->scsi_host);
1005
1006         DPRINTK("port EH scheduled\n");
1007 }
1008
1009 static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
1010 {
1011         int tag, nr_aborted = 0;
1012
1013         WARN_ON(!ap->ops->error_handler);
1014
1015         /* we're gonna abort all commands, no need for fast drain */
1016         ata_eh_set_pending(ap, 0);
1017
1018         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1019                 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
1020
1021                 if (qc && (!link || qc->dev->link == link)) {
1022                         qc->flags |= ATA_QCFLAG_FAILED;
1023                         ata_qc_complete(qc);
1024                         nr_aborted++;
1025                 }
1026         }
1027
1028         if (!nr_aborted)
1029                 ata_port_schedule_eh(ap);
1030
1031         return nr_aborted;
1032 }
1033
1034 /**
1035  *      ata_link_abort - abort all qc's on the link
1036  *      @link: ATA link to abort qc's for
1037  *
1038  *      Abort all active qc's active on @link and schedule EH.
1039  *
1040  *      LOCKING:
1041  *      spin_lock_irqsave(host lock)
1042  *
1043  *      RETURNS:
1044  *      Number of aborted qc's.
1045  */
1046 int ata_link_abort(struct ata_link *link)
1047 {
1048         return ata_do_link_abort(link->ap, link);
1049 }
1050
1051 /**
1052  *      ata_port_abort - abort all qc's on the port
1053  *      @ap: ATA port to abort qc's for
1054  *
1055  *      Abort all active qc's of @ap and schedule EH.
1056  *
1057  *      LOCKING:
1058  *      spin_lock_irqsave(host_set lock)
1059  *
1060  *      RETURNS:
1061  *      Number of aborted qc's.
1062  */
1063 int ata_port_abort(struct ata_port *ap)
1064 {
1065         return ata_do_link_abort(ap, NULL);
1066 }
1067
1068 /**
1069  *      __ata_port_freeze - freeze port
1070  *      @ap: ATA port to freeze
1071  *
1072  *      This function is called when HSM violation or some other
1073  *      condition disrupts normal operation of the port.  Frozen port
1074  *      is not allowed to perform any operation until the port is
1075  *      thawed, which usually follows a successful reset.
1076  *
1077  *      ap->ops->freeze() callback can be used for freezing the port
1078  *      hardware-wise (e.g. mask interrupt and stop DMA engine).  If a
1079  *      port cannot be frozen hardware-wise, the interrupt handler
1080  *      must ack and clear interrupts unconditionally while the port
1081  *      is frozen.
1082  *
1083  *      LOCKING:
1084  *      spin_lock_irqsave(host lock)
1085  */
1086 static void __ata_port_freeze(struct ata_port *ap)
1087 {
1088         WARN_ON(!ap->ops->error_handler);
1089
1090         if (ap->ops->freeze)
1091                 ap->ops->freeze(ap);
1092
1093         ap->pflags |= ATA_PFLAG_FROZEN;
1094
1095         DPRINTK("ata%u port frozen\n", ap->print_id);
1096 }
1097
1098 /**
1099  *      ata_port_freeze - abort & freeze port
1100  *      @ap: ATA port to freeze
1101  *
1102  *      Abort and freeze @ap.  The freeze operation must be called
1103  *      first, because some hardware requires special operations
1104  *      before the taskfile registers are accessible.
1105  *
1106  *      LOCKING:
1107  *      spin_lock_irqsave(host lock)
1108  *
1109  *      RETURNS:
1110  *      Number of aborted commands.
1111  */
1112 int ata_port_freeze(struct ata_port *ap)
1113 {
1114         int nr_aborted;
1115
1116         WARN_ON(!ap->ops->error_handler);
1117
1118         __ata_port_freeze(ap);
1119         nr_aborted = ata_port_abort(ap);
1120
1121         return nr_aborted;
1122 }
1123
1124 /**
1125  *      sata_async_notification - SATA async notification handler
1126  *      @ap: ATA port where async notification is received
1127  *
1128  *      Handler to be called when async notification via SDB FIS is
1129  *      received.  This function schedules EH if necessary.
1130  *
1131  *      LOCKING:
1132  *      spin_lock_irqsave(host lock)
1133  *
1134  *      RETURNS:
1135  *      1 if EH is scheduled, 0 otherwise.
1136  */
1137 int sata_async_notification(struct ata_port *ap)
1138 {
1139         u32 sntf;
1140         int rc;
1141
1142         if (!(ap->flags & ATA_FLAG_AN))
1143                 return 0;
1144
1145         rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1146         if (rc == 0)
1147                 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1148
1149         if (!sata_pmp_attached(ap) || rc) {
1150                 /* PMP is not attached or SNTF is not available */
1151                 if (!sata_pmp_attached(ap)) {
1152                         /* PMP is not attached.  Check whether ATAPI
1153                          * AN is configured.  If so, notify media
1154                          * change.
1155                          */
1156                         struct ata_device *dev = ap->link.device;
1157
1158                         if ((dev->class == ATA_DEV_ATAPI) &&
1159                             (dev->flags & ATA_DFLAG_AN))
1160                                 ata_scsi_media_change_notify(dev);
1161                         return 0;
1162                 } else {
1163                         /* PMP is attached but SNTF is not available.
1164                          * ATAPI async media change notification is
1165                          * not used.  The PMP must be reporting PHY
1166                          * status change, schedule EH.
1167                          */
1168                         ata_port_schedule_eh(ap);
1169                         return 1;
1170                 }
1171         } else {
1172                 /* PMP is attached and SNTF is available */
1173                 struct ata_link *link;
1174
1175                 /* check and notify ATAPI AN */
1176                 ata_for_each_link(link, ap, EDGE) {
1177                         if (!(sntf & (1 << link->pmp)))
1178                                 continue;
1179
1180                         if ((link->device->class == ATA_DEV_ATAPI) &&
1181                             (link->device->flags & ATA_DFLAG_AN))
1182                                 ata_scsi_media_change_notify(link->device);
1183                 }
1184
1185                 /* If PMP is reporting that PHY status of some
1186                  * downstream ports has changed, schedule EH.
1187                  */
1188                 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
1189                         ata_port_schedule_eh(ap);
1190                         return 1;
1191                 }
1192
1193                 return 0;
1194         }
1195 }
1196
1197 /**
1198  *      ata_eh_freeze_port - EH helper to freeze port
1199  *      @ap: ATA port to freeze
1200  *
1201  *      Freeze @ap.
1202  *
1203  *      LOCKING:
1204  *      None.
1205  */
1206 void ata_eh_freeze_port(struct ata_port *ap)
1207 {
1208         unsigned long flags;
1209
1210         if (!ap->ops->error_handler)
1211                 return;
1212
1213         spin_lock_irqsave(ap->lock, flags);
1214         __ata_port_freeze(ap);
1215         spin_unlock_irqrestore(ap->lock, flags);
1216 }
1217
1218 /**
1219  *      ata_port_thaw_port - EH helper to thaw port
1220  *      @ap: ATA port to thaw
1221  *
1222  *      Thaw frozen port @ap.
1223  *
1224  *      LOCKING:
1225  *      None.
1226  */
1227 void ata_eh_thaw_port(struct ata_port *ap)
1228 {
1229         unsigned long flags;
1230
1231         if (!ap->ops->error_handler)
1232                 return;
1233
1234         spin_lock_irqsave(ap->lock, flags);
1235
1236         ap->pflags &= ~ATA_PFLAG_FROZEN;
1237
1238         if (ap->ops->thaw)
1239                 ap->ops->thaw(ap);
1240
1241         spin_unlock_irqrestore(ap->lock, flags);
1242
1243         DPRINTK("ata%u port thawed\n", ap->print_id);
1244 }
1245
1246 static void ata_eh_scsidone(struct scsi_cmnd *scmd)
1247 {
1248         /* nada */
1249 }
1250
1251 static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
1252 {
1253         struct ata_port *ap = qc->ap;
1254         struct scsi_cmnd *scmd = qc->scsicmd;
1255         unsigned long flags;
1256
1257         spin_lock_irqsave(ap->lock, flags);
1258         qc->scsidone = ata_eh_scsidone;
1259         __ata_qc_complete(qc);
1260         WARN_ON(ata_tag_valid(qc->tag));
1261         spin_unlock_irqrestore(ap->lock, flags);
1262
1263         scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
1264 }
1265
1266 /**
1267  *      ata_eh_qc_complete - Complete an active ATA command from EH
1268  *      @qc: Command to complete
1269  *
1270  *      Indicate to the mid and upper layers that an ATA command has
1271  *      completed.  To be used from EH.
1272  */
1273 void ata_eh_qc_complete(struct ata_queued_cmd *qc)
1274 {
1275         struct scsi_cmnd *scmd = qc->scsicmd;
1276         scmd->retries = scmd->allowed;
1277         __ata_eh_qc_complete(qc);
1278 }
1279
1280 /**
1281  *      ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
1282  *      @qc: Command to retry
1283  *
1284  *      Indicate to the mid and upper layers that an ATA command
1285  *      should be retried.  To be used from EH.
1286  *
1287  *      SCSI midlayer limits the number of retries to scmd->allowed.
1288  *      scmd->retries is decremented for commands which get retried
1289  *      due to unrelated failures (qc->err_mask is zero).
1290  */
1291 void ata_eh_qc_retry(struct ata_queued_cmd *qc)
1292 {
1293         struct scsi_cmnd *scmd = qc->scsicmd;
1294         if (!qc->err_mask && scmd->retries)
1295                 scmd->retries--;
1296         __ata_eh_qc_complete(qc);
1297 }
1298
1299 /**
1300  *      ata_dev_disable - disable ATA device
1301  *      @dev: ATA device to disable
1302  *
1303  *      Disable @dev.
1304  *
1305  *      Locking:
1306  *      EH context.
1307  */
1308 void ata_dev_disable(struct ata_device *dev)
1309 {
1310         if (!ata_dev_enabled(dev))
1311                 return;
1312
1313         if (ata_msg_drv(dev->link->ap))
1314                 ata_dev_warn(dev, "disabled\n");
1315         ata_acpi_on_disable(dev);
1316         ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET);
1317         dev->class++;
1318
1319         /* From now till the next successful probe, ering is used to
1320          * track probe failures.  Clear accumulated device error info.
1321          */
1322         ata_ering_clear(&dev->ering);
1323 }
1324
1325 /**
1326  *      ata_eh_detach_dev - detach ATA device
1327  *      @dev: ATA device to detach
1328  *
1329  *      Detach @dev.
1330  *
1331  *      LOCKING:
1332  *      None.
1333  */
1334 void ata_eh_detach_dev(struct ata_device *dev)
1335 {
1336         struct ata_link *link = dev->link;
1337         struct ata_port *ap = link->ap;
1338         struct ata_eh_context *ehc = &link->eh_context;
1339         unsigned long flags;
1340
1341         ata_dev_disable(dev);
1342
1343         spin_lock_irqsave(ap->lock, flags);
1344
1345         dev->flags &= ~ATA_DFLAG_DETACH;
1346
1347         if (ata_scsi_offline_dev(dev)) {
1348                 dev->flags |= ATA_DFLAG_DETACHED;
1349                 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
1350         }
1351
1352         /* clear per-dev EH info */
1353         ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
1354         ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
1355         ehc->saved_xfer_mode[dev->devno] = 0;
1356         ehc->saved_ncq_enabled &= ~(1 << dev->devno);
1357
1358         spin_unlock_irqrestore(ap->lock, flags);
1359 }
1360
1361 /**
1362  *      ata_eh_about_to_do - about to perform eh_action
1363  *      @link: target ATA link
1364  *      @dev: target ATA dev for per-dev action (can be NULL)
1365  *      @action: action about to be performed
1366  *
1367  *      Called just before performing EH actions to clear related bits
1368  *      in @link->eh_info such that eh actions are not unnecessarily
1369  *      repeated.
1370  *
1371  *      LOCKING:
1372  *      None.
1373  */
1374 void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
1375                         unsigned int action)
1376 {
1377         struct ata_port *ap = link->ap;
1378         struct ata_eh_info *ehi = &link->eh_info;
1379         struct ata_eh_context *ehc = &link->eh_context;
1380         unsigned long flags;
1381
1382         spin_lock_irqsave(ap->lock, flags);
1383
1384         ata_eh_clear_action(link, dev, ehi, action);
1385
1386         /* About to take EH action, set RECOVERED.  Ignore actions on
1387          * slave links as master will do them again.
1388          */
1389         if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link)
1390                 ap->pflags |= ATA_PFLAG_RECOVERED;
1391
1392         spin_unlock_irqrestore(ap->lock, flags);
1393 }
1394
1395 /**
1396  *      ata_eh_done - EH action complete
1397 *       @ap: target ATA port
1398  *      @dev: target ATA dev for per-dev action (can be NULL)
1399  *      @action: action just completed
1400  *
1401  *      Called right after performing EH actions to clear related bits
1402  *      in @link->eh_context.
1403  *
1404  *      LOCKING:
1405  *      None.
1406  */
1407 void ata_eh_done(struct ata_link *link, struct ata_device *dev,
1408                  unsigned int action)
1409 {
1410         struct ata_eh_context *ehc = &link->eh_context;
1411
1412         ata_eh_clear_action(link, dev, &ehc->i, action);
1413 }
1414
1415 /**
1416  *      ata_err_string - convert err_mask to descriptive string
1417  *      @err_mask: error mask to convert to string
1418  *
1419  *      Convert @err_mask to descriptive string.  Errors are
1420  *      prioritized according to severity and only the most severe
1421  *      error is reported.
1422  *
1423  *      LOCKING:
1424  *      None.
1425  *
1426  *      RETURNS:
1427  *      Descriptive string for @err_mask
1428  */
1429 static const char *ata_err_string(unsigned int err_mask)
1430 {
1431         if (err_mask & AC_ERR_HOST_BUS)
1432                 return "host bus error";
1433         if (err_mask & AC_ERR_ATA_BUS)
1434                 return "ATA bus error";
1435         if (err_mask & AC_ERR_TIMEOUT)
1436                 return "timeout";
1437         if (err_mask & AC_ERR_HSM)
1438                 return "HSM violation";
1439         if (err_mask & AC_ERR_SYSTEM)
1440                 return "internal error";
1441         if (err_mask & AC_ERR_MEDIA)
1442                 return "media error";
1443         if (err_mask & AC_ERR_INVALID)
1444                 return "invalid argument";
1445         if (err_mask & AC_ERR_DEV)
1446                 return "device error";
1447         return "unknown error";
1448 }
1449
1450 /**
1451  *      ata_read_log_page - read a specific log page
1452  *      @dev: target device
1453  *      @page: page to read
1454  *      @buf: buffer to store read page
1455  *      @sectors: number of sectors to read
1456  *
1457  *      Read log page using READ_LOG_EXT command.
1458  *
1459  *      LOCKING:
1460  *      Kernel thread context (may sleep).
1461  *
1462  *      RETURNS:
1463  *      0 on success, AC_ERR_* mask otherwise.
1464  */
1465 static unsigned int ata_read_log_page(struct ata_device *dev,
1466                                       u8 page, void *buf, unsigned int sectors)
1467 {
1468         struct ata_taskfile tf;
1469         unsigned int err_mask;
1470
1471         DPRINTK("read log page - page %d\n", page);
1472
1473         ata_tf_init(dev, &tf);
1474         tf.command = ATA_CMD_READ_LOG_EXT;
1475         tf.lbal = page;
1476         tf.nsect = sectors;
1477         tf.hob_nsect = sectors >> 8;
1478         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
1479         tf.protocol = ATA_PROT_PIO;
1480
1481         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
1482                                      buf, sectors * ATA_SECT_SIZE, 0);
1483
1484         DPRINTK("EXIT, err_mask=%x\n", err_mask);
1485         return err_mask;
1486 }
1487
1488 /**
1489  *      ata_eh_read_log_10h - Read log page 10h for NCQ error details
1490  *      @dev: Device to read log page 10h from
1491  *      @tag: Resulting tag of the failed command
1492  *      @tf: Resulting taskfile registers of the failed command
1493  *
1494  *      Read log page 10h to obtain NCQ error details and clear error
1495  *      condition.
1496  *
1497  *      LOCKING:
1498  *      Kernel thread context (may sleep).
1499  *
1500  *      RETURNS:
1501  *      0 on success, -errno otherwise.
1502  */
1503 static int ata_eh_read_log_10h(struct ata_device *dev,
1504                                int *tag, struct ata_taskfile *tf)
1505 {
1506         u8 *buf = dev->link->ap->sector_buf;
1507         unsigned int err_mask;
1508         u8 csum;
1509         int i;
1510
1511         err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1);
1512         if (err_mask)
1513                 return -EIO;
1514
1515         csum = 0;
1516         for (i = 0; i < ATA_SECT_SIZE; i++)
1517                 csum += buf[i];
1518         if (csum)
1519                 ata_dev_warn(dev, "invalid checksum 0x%x on log page 10h\n",
1520                              csum);
1521
1522         if (buf[0] & 0x80)
1523                 return -ENOENT;
1524
1525         *tag = buf[0] & 0x1f;
1526
1527         tf->command = buf[2];
1528         tf->feature = buf[3];
1529         tf->lbal = buf[4];
1530         tf->lbam = buf[5];
1531         tf->lbah = buf[6];
1532         tf->device = buf[7];
1533         tf->hob_lbal = buf[8];
1534         tf->hob_lbam = buf[9];
1535         tf->hob_lbah = buf[10];
1536         tf->nsect = buf[12];
1537         tf->hob_nsect = buf[13];
1538
1539         return 0;
1540 }
1541
1542 /**
1543  *      atapi_eh_tur - perform ATAPI TEST_UNIT_READY
1544  *      @dev: target ATAPI device
1545  *      @r_sense_key: out parameter for sense_key
1546  *
1547  *      Perform ATAPI TEST_UNIT_READY.
1548  *
1549  *      LOCKING:
1550  *      EH context (may sleep).
1551  *
1552  *      RETURNS:
1553  *      0 on success, AC_ERR_* mask on failure.
1554  */
1555 static unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
1556 {
1557         u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 };
1558         struct ata_taskfile tf;
1559         unsigned int err_mask;
1560
1561         ata_tf_init(dev, &tf);
1562
1563         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1564         tf.command = ATA_CMD_PACKET;
1565         tf.protocol = ATAPI_PROT_NODATA;
1566
1567         err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
1568         if (err_mask == AC_ERR_DEV)
1569                 *r_sense_key = tf.feature >> 4;
1570         return err_mask;
1571 }
1572
1573 /**
1574  *      atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
1575  *      @dev: device to perform REQUEST_SENSE to
1576  *      @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
1577  *      @dfl_sense_key: default sense key to use
1578  *
1579  *      Perform ATAPI REQUEST_SENSE after the device reported CHECK
1580  *      SENSE.  This function is EH helper.
1581  *
1582  *      LOCKING:
1583  *      Kernel thread context (may sleep).
1584  *
1585  *      RETURNS:
1586  *      0 on success, AC_ERR_* mask on failure
1587  */
1588 static unsigned int atapi_eh_request_sense(struct ata_device *dev,
1589                                            u8 *sense_buf, u8 dfl_sense_key)
1590 {
1591         u8 cdb[ATAPI_CDB_LEN] =
1592                 { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 };
1593         struct ata_port *ap = dev->link->ap;
1594         struct ata_taskfile tf;
1595
1596         DPRINTK("ATAPI request sense\n");
1597
1598         /* FIXME: is this needed? */
1599         memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
1600
1601         /* initialize sense_buf with the error register,
1602          * for the case where they are -not- overwritten
1603          */
1604         sense_buf[0] = 0x70;
1605         sense_buf[2] = dfl_sense_key;
1606
1607         /* some devices time out if garbage left in tf */
1608         ata_tf_init(dev, &tf);
1609
1610         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1611         tf.command = ATA_CMD_PACKET;
1612
1613         /* is it pointless to prefer PIO for "safety reasons"? */
1614         if (ap->flags & ATA_FLAG_PIO_DMA) {
1615                 tf.protocol = ATAPI_PROT_DMA;
1616                 tf.feature |= ATAPI_PKT_DMA;
1617         } else {
1618                 tf.protocol = ATAPI_PROT_PIO;
1619                 tf.lbam = SCSI_SENSE_BUFFERSIZE;
1620                 tf.lbah = 0;
1621         }
1622
1623         return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
1624                                  sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
1625 }
1626
1627 /**
1628  *      ata_eh_analyze_serror - analyze SError for a failed port
1629  *      @link: ATA link to analyze SError for
1630  *
1631  *      Analyze SError if available and further determine cause of
1632  *      failure.
1633  *
1634  *      LOCKING:
1635  *      None.
1636  */
1637 static void ata_eh_analyze_serror(struct ata_link *link)
1638 {
1639         struct ata_eh_context *ehc = &link->eh_context;
1640         u32 serror = ehc->i.serror;
1641         unsigned int err_mask = 0, action = 0;
1642         u32 hotplug_mask;
1643
1644         if (serror & (SERR_PERSISTENT | SERR_DATA)) {
1645                 err_mask |= AC_ERR_ATA_BUS;
1646                 action |= ATA_EH_RESET;
1647         }
1648         if (serror & SERR_PROTOCOL) {
1649                 err_mask |= AC_ERR_HSM;
1650                 action |= ATA_EH_RESET;
1651         }
1652         if (serror & SERR_INTERNAL) {
1653                 err_mask |= AC_ERR_SYSTEM;
1654                 action |= ATA_EH_RESET;
1655         }
1656
1657         /* Determine whether a hotplug event has occurred.  Both
1658          * SError.N/X are considered hotplug events for enabled or
1659          * host links.  For disabled PMP links, only N bit is
1660          * considered as X bit is left at 1 for link plugging.
1661          */
1662         if (link->lpm_policy > ATA_LPM_MAX_POWER)
1663                 hotplug_mask = 0;       /* hotplug doesn't work w/ LPM */
1664         else if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
1665                 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
1666         else
1667                 hotplug_mask = SERR_PHYRDY_CHG;
1668
1669         if (serror & hotplug_mask)
1670                 ata_ehi_hotplugged(&ehc->i);
1671
1672         ehc->i.err_mask |= err_mask;
1673         ehc->i.action |= action;
1674 }
1675
1676 /**
1677  *      ata_eh_analyze_ncq_error - analyze NCQ error
1678  *      @link: ATA link to analyze NCQ error for
1679  *
1680  *      Read log page 10h, determine the offending qc and acquire
1681  *      error status TF.  For NCQ device errors, all LLDDs have to do
1682  *      is setting AC_ERR_DEV in ehi->err_mask.  This function takes
1683  *      care of the rest.
1684  *
1685  *      LOCKING:
1686  *      Kernel thread context (may sleep).
1687  */
1688 void ata_eh_analyze_ncq_error(struct ata_link *link)
1689 {
1690         struct ata_port *ap = link->ap;
1691         struct ata_eh_context *ehc = &link->eh_context;
1692         struct ata_device *dev = link->device;
1693         struct ata_queued_cmd *qc;
1694         struct ata_taskfile tf;
1695         int tag, rc;
1696
1697         /* if frozen, we can't do much */
1698         if (ap->pflags & ATA_PFLAG_FROZEN)
1699                 return;
1700
1701         /* is it NCQ device error? */
1702         if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
1703                 return;
1704
1705         /* has LLDD analyzed already? */
1706         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1707                 qc = __ata_qc_from_tag(ap, tag);
1708
1709                 if (!(qc->flags & ATA_QCFLAG_FAILED))
1710                         continue;
1711
1712                 if (qc->err_mask)
1713                         return;
1714         }
1715
1716         /* okay, this error is ours */
1717         memset(&tf, 0, sizeof(tf));
1718         rc = ata_eh_read_log_10h(dev, &tag, &tf);
1719         if (rc) {
1720                 ata_link_err(link, "failed to read log page 10h (errno=%d)\n",
1721                              rc);
1722                 return;
1723         }
1724
1725         if (!(link->sactive & (1 << tag))) {
1726                 ata_link_err(link, "log page 10h reported inactive tag %d\n",
1727                              tag);
1728                 return;
1729         }
1730
1731         /* we've got the perpetrator, condemn it */
1732         qc = __ata_qc_from_tag(ap, tag);
1733         memcpy(&qc->result_tf, &tf, sizeof(tf));
1734         qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
1735         qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
1736         ehc->i.err_mask &= ~AC_ERR_DEV;
1737 }
1738
1739 /**
1740  *      ata_eh_analyze_tf - analyze taskfile of a failed qc
1741  *      @qc: qc to analyze
1742  *      @tf: Taskfile registers to analyze
1743  *
1744  *      Analyze taskfile of @qc and further determine cause of
1745  *      failure.  This function also requests ATAPI sense data if
1746  *      available.
1747  *
1748  *      LOCKING:
1749  *      Kernel thread context (may sleep).
1750  *
1751  *      RETURNS:
1752  *      Determined recovery action
1753  */
1754 static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
1755                                       const struct ata_taskfile *tf)
1756 {
1757         unsigned int tmp, action = 0;
1758         u8 stat = tf->command, err = tf->feature;
1759
1760         if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
1761                 qc->err_mask |= AC_ERR_HSM;
1762                 return ATA_EH_RESET;
1763         }
1764
1765         if (stat & (ATA_ERR | ATA_DF))
1766                 qc->err_mask |= AC_ERR_DEV;
1767         else
1768                 return 0;
1769
1770         switch (qc->dev->class) {
1771         case ATA_DEV_ATA:
1772                 if (err & ATA_ICRC)
1773                         qc->err_mask |= AC_ERR_ATA_BUS;
1774                 if (err & ATA_UNC)
1775                         qc->err_mask |= AC_ERR_MEDIA;
1776                 if (err & ATA_IDNF)
1777                         qc->err_mask |= AC_ERR_INVALID;
1778                 break;
1779
1780         case ATA_DEV_ATAPI:
1781                 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
1782                         tmp = atapi_eh_request_sense(qc->dev,
1783                                                 qc->scsicmd->sense_buffer,
1784                                                 qc->result_tf.feature >> 4);
1785                         if (!tmp) {
1786                                 /* ATA_QCFLAG_SENSE_VALID is used to
1787                                  * tell atapi_qc_complete() that sense
1788                                  * data is already valid.
1789                                  *
1790                                  * TODO: interpret sense data and set
1791                                  * appropriate err_mask.
1792                                  */
1793                                 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1794                         } else
1795                                 qc->err_mask |= tmp;
1796                 }
1797         }
1798
1799         if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
1800                 action |= ATA_EH_RESET;
1801
1802         return action;
1803 }
1804
1805 static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
1806                                    int *xfer_ok)
1807 {
1808         int base = 0;
1809
1810         if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
1811                 *xfer_ok = 1;
1812
1813         if (!*xfer_ok)
1814                 base = ATA_ECAT_DUBIOUS_NONE;
1815
1816         if (err_mask & AC_ERR_ATA_BUS)
1817                 return base + ATA_ECAT_ATA_BUS;
1818
1819         if (err_mask & AC_ERR_TIMEOUT)
1820                 return base + ATA_ECAT_TOUT_HSM;
1821
1822         if (eflags & ATA_EFLAG_IS_IO) {
1823                 if (err_mask & AC_ERR_HSM)
1824                         return base + ATA_ECAT_TOUT_HSM;
1825                 if ((err_mask &
1826                      (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
1827                         return base + ATA_ECAT_UNK_DEV;
1828         }
1829
1830         return 0;
1831 }
1832
1833 struct speed_down_verdict_arg {
1834         u64 since;
1835         int xfer_ok;
1836         int nr_errors[ATA_ECAT_NR];
1837 };
1838
1839 static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
1840 {
1841         struct speed_down_verdict_arg *arg = void_arg;
1842         int cat;
1843
1844         if ((ent->eflags & ATA_EFLAG_OLD_ER) || (ent->timestamp < arg->since))
1845                 return -1;
1846
1847         cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
1848                                       &arg->xfer_ok);
1849         arg->nr_errors[cat]++;
1850
1851         return 0;
1852 }
1853
1854 /**
1855  *      ata_eh_speed_down_verdict - Determine speed down verdict
1856  *      @dev: Device of interest
1857  *
1858  *      This function examines error ring of @dev and determines
1859  *      whether NCQ needs to be turned off, transfer speed should be
1860  *      stepped down, or falling back to PIO is necessary.
1861  *
1862  *      ECAT_ATA_BUS    : ATA_BUS error for any command
1863  *
1864  *      ECAT_TOUT_HSM   : TIMEOUT for any command or HSM violation for
1865  *                        IO commands
1866  *
1867  *      ECAT_UNK_DEV    : Unknown DEV error for IO commands
1868  *
1869  *      ECAT_DUBIOUS_*  : Identical to above three but occurred while
1870  *                        data transfer hasn't been verified.
1871  *
1872  *      Verdicts are
1873  *
1874  *      NCQ_OFF         : Turn off NCQ.
1875  *
1876  *      SPEED_DOWN      : Speed down transfer speed but don't fall back
1877  *                        to PIO.
1878  *
1879  *      FALLBACK_TO_PIO : Fall back to PIO.
1880  *
1881  *      Even if multiple verdicts are returned, only one action is
1882  *      taken per error.  An action triggered by non-DUBIOUS errors
1883  *      clears ering, while one triggered by DUBIOUS_* errors doesn't.
1884  *      This is to expedite speed down decisions right after device is
1885  *      initially configured.
1886  *
1887  *      The followings are speed down rules.  #1 and #2 deal with
1888  *      DUBIOUS errors.
1889  *
1890  *      1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors
1891  *         occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO.
1892  *
1893  *      2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors
1894  *         occurred during last 5 mins, NCQ_OFF.
1895  *
1896  *      3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
1897  *         occurred during last 5 mins, FALLBACK_TO_PIO
1898  *
1899  *      4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
1900  *         during last 10 mins, NCQ_OFF.
1901  *
1902  *      5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6
1903  *         UNK_DEV errors occurred during last 10 mins, SPEED_DOWN.
1904  *
1905  *      LOCKING:
1906  *      Inherited from caller.
1907  *
1908  *      RETURNS:
1909  *      OR of ATA_EH_SPDN_* flags.
1910  */
1911 static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
1912 {
1913         const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
1914         u64 j64 = get_jiffies_64();
1915         struct speed_down_verdict_arg arg;
1916         unsigned int verdict = 0;
1917
1918         /* scan past 5 mins of error history */
1919         memset(&arg, 0, sizeof(arg));
1920         arg.since = j64 - min(j64, j5mins);
1921         ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1922
1923         if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
1924             arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
1925                 verdict |= ATA_EH_SPDN_SPEED_DOWN |
1926                         ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
1927
1928         if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
1929             arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
1930                 verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
1931
1932         if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1933             arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1934             arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
1935                 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
1936
1937         /* scan past 10 mins of error history */
1938         memset(&arg, 0, sizeof(arg));
1939         arg.since = j64 - min(j64, j10mins);
1940         ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1941
1942         if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1943             arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
1944                 verdict |= ATA_EH_SPDN_NCQ_OFF;
1945
1946         if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1947             arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
1948             arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
1949                 verdict |= ATA_EH_SPDN_SPEED_DOWN;
1950
1951         return verdict;
1952 }
1953
1954 /**
1955  *      ata_eh_speed_down - record error and speed down if necessary
1956  *      @dev: Failed device
1957  *      @eflags: mask of ATA_EFLAG_* flags
1958  *      @err_mask: err_mask of the error
1959  *
1960  *      Record error and examine error history to determine whether
1961  *      adjusting transmission speed is necessary.  It also sets
1962  *      transmission limits appropriately if such adjustment is
1963  *      necessary.
1964  *
1965  *      LOCKING:
1966  *      Kernel thread context (may sleep).
1967  *
1968  *      RETURNS:
1969  *      Determined recovery action.
1970  */
1971 static unsigned int ata_eh_speed_down(struct ata_device *dev,
1972                                 unsigned int eflags, unsigned int err_mask)
1973 {
1974         struct ata_link *link = ata_dev_phys_link(dev);
1975         int xfer_ok = 0;
1976         unsigned int verdict;
1977         unsigned int action = 0;
1978
1979         /* don't bother if Cat-0 error */
1980         if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
1981                 return 0;
1982
1983         /* record error and determine whether speed down is necessary */
1984         ata_ering_record(&dev->ering, eflags, err_mask);
1985         verdict = ata_eh_speed_down_verdict(dev);
1986
1987         /* turn off NCQ? */
1988         if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
1989             (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
1990                            ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
1991                 dev->flags |= ATA_DFLAG_NCQ_OFF;
1992                 ata_dev_warn(dev, "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_err(ehc->i.dev, "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_err(ehc->i.dev, "%s\n", desc);
2383         } else {
2384                 ata_link_err(link, "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_err(link, "%s\n", desc);
2390         }
2391
2392 #ifdef CONFIG_ATA_VERBOSE_ERROR
2393         if (ehc->i.serror)
2394                 ata_link_err(link,
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_err(qc->dev, "failed command: %s\n",
2460                                             descr);
2461                 }
2462
2463                 ata_dev_err(qc->dev,
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_err(qc->dev, "status: { Busy }\n");
2485                         else
2486                                 ata_dev_err(qc->dev, "status: { %s%s%s%s}\n",
2487                                   res->command & ATA_DRDY ? "DRDY " : "",
2488                                   res->command & ATA_DF ? "DF " : "",
2489                                   res->command & ATA_DRQ ? "DRQ " : "",
2490                                   res->command & ATA_ERR ? "ERR " : "");
2491                 }
2492
2493                 if (cmd->command != ATA_CMD_PACKET &&
2494                     (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
2495                                      ATA_ABORTED)))
2496                         ata_dev_err(qc->dev, "error: { %s%s%s%s}\n",
2497                           res->feature & ATA_ICRC ? "ICRC " : "",
2498                           res->feature & ATA_UNC ? "UNC " : "",
2499                           res->feature & ATA_IDNF ? "IDNF " : "",
2500                           res->feature & ATA_ABORTED ? "ABRT " : "");
2501 #endif
2502         }
2503 }
2504
2505 /**
2506  *      ata_eh_report - report error handling to user
2507  *      @ap: ATA port to report EH about
2508  *
2509  *      Report EH to user.
2510  *
2511  *      LOCKING:
2512  *      None.
2513  */
2514 void ata_eh_report(struct ata_port *ap)
2515 {
2516         struct ata_link *link;
2517
2518         ata_for_each_link(link, ap, HOST_FIRST)
2519                 ata_eh_link_report(link);
2520 }
2521
2522 static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
2523                         unsigned int *classes, unsigned long deadline,
2524                         bool clear_classes)
2525 {
2526         struct ata_device *dev;
2527
2528         if (clear_classes)
2529                 ata_for_each_dev(dev, link, ALL)
2530                         classes[dev->devno] = ATA_DEV_UNKNOWN;
2531
2532         return reset(link, classes, deadline);
2533 }
2534
2535 static int ata_eh_followup_srst_needed(struct ata_link *link, int rc)
2536 {
2537         if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link))
2538                 return 0;
2539         if (rc == -EAGAIN)
2540                 return 1;
2541         if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
2542                 return 1;
2543         return 0;
2544 }
2545
2546 int ata_eh_reset(struct ata_link *link, int classify,
2547                  ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
2548                  ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
2549 {
2550         struct ata_port *ap = link->ap;
2551         struct ata_link *slave = ap->slave_link;
2552         struct ata_eh_context *ehc = &link->eh_context;
2553         struct ata_eh_context *sehc = slave ? &slave->eh_context : NULL;
2554         unsigned int *classes = ehc->classes;
2555         unsigned int lflags = link->flags;
2556         int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
2557         int max_tries = 0, try = 0;
2558         struct ata_link *failed_link;
2559         struct ata_device *dev;
2560         unsigned long deadline, now;
2561         ata_reset_fn_t reset;
2562         unsigned long flags;
2563         u32 sstatus;
2564         int nr_unknown, rc;
2565
2566         /*
2567          * Prepare to reset
2568          */
2569         while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX)
2570                 max_tries++;
2571         if (link->flags & ATA_LFLAG_NO_HRST)
2572                 hardreset = NULL;
2573         if (link->flags & ATA_LFLAG_NO_SRST)
2574                 softreset = NULL;
2575
2576         /* make sure each reset attempt is at least COOL_DOWN apart */
2577         if (ehc->i.flags & ATA_EHI_DID_RESET) {
2578                 now = jiffies;
2579                 WARN_ON(time_after(ehc->last_reset, now));
2580                 deadline = ata_deadline(ehc->last_reset,
2581                                         ATA_EH_RESET_COOL_DOWN);
2582                 if (time_before(now, deadline))
2583                         schedule_timeout_uninterruptible(deadline - now);
2584         }
2585
2586         spin_lock_irqsave(ap->lock, flags);
2587         ap->pflags |= ATA_PFLAG_RESETTING;
2588         spin_unlock_irqrestore(ap->lock, flags);
2589
2590         ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
2591
2592         ata_for_each_dev(dev, link, ALL) {
2593                 /* If we issue an SRST then an ATA drive (not ATAPI)
2594                  * may change configuration and be in PIO0 timing. If
2595                  * we do a hard reset (or are coming from power on)
2596                  * this is true for ATA or ATAPI. Until we've set a
2597                  * suitable controller mode we should not touch the
2598                  * bus as we may be talking too fast.
2599                  */
2600                 dev->pio_mode = XFER_PIO_0;
2601
2602                 /* If the controller has a pio mode setup function
2603                  * then use it to set the chipset to rights. Don't
2604                  * touch the DMA setup as that will be dealt with when
2605                  * configuring devices.
2606                  */
2607                 if (ap->ops->set_piomode)
2608                         ap->ops->set_piomode(ap, dev);
2609         }
2610
2611         /* prefer hardreset */
2612         reset = NULL;
2613         ehc->i.action &= ~ATA_EH_RESET;
2614         if (hardreset) {
2615                 reset = hardreset;
2616                 ehc->i.action |= ATA_EH_HARDRESET;
2617         } else if (softreset) {
2618                 reset = softreset;
2619                 ehc->i.action |= ATA_EH_SOFTRESET;
2620         }
2621
2622         if (prereset) {
2623                 unsigned long deadline = ata_deadline(jiffies,
2624                                                       ATA_EH_PRERESET_TIMEOUT);
2625
2626                 if (slave) {
2627                         sehc->i.action &= ~ATA_EH_RESET;
2628                         sehc->i.action |= ehc->i.action;
2629                 }
2630
2631                 rc = prereset(link, deadline);
2632
2633                 /* If present, do prereset on slave link too.  Reset
2634                  * is skipped iff both master and slave links report
2635                  * -ENOENT or clear ATA_EH_RESET.
2636                  */
2637                 if (slave && (rc == 0 || rc == -ENOENT)) {
2638                         int tmp;
2639
2640                         tmp = prereset(slave, deadline);
2641                         if (tmp != -ENOENT)
2642                                 rc = tmp;
2643
2644                         ehc->i.action |= sehc->i.action;
2645                 }
2646
2647                 if (rc) {
2648                         if (rc == -ENOENT) {
2649                                 ata_link_dbg(link, "port disabled--ignoring\n");
2650                                 ehc->i.action &= ~ATA_EH_RESET;
2651
2652                                 ata_for_each_dev(dev, link, ALL)
2653                                         classes[dev->devno] = ATA_DEV_NONE;
2654
2655                                 rc = 0;
2656                         } else
2657                                 ata_link_err(link,
2658                                              "prereset failed (errno=%d)\n",
2659                                              rc);
2660                         goto out;
2661                 }
2662
2663                 /* prereset() might have cleared ATA_EH_RESET.  If so,
2664                  * bang classes, thaw and return.
2665                  */
2666                 if (reset && !(ehc->i.action & ATA_EH_RESET)) {
2667                         ata_for_each_dev(dev, link, ALL)
2668                                 classes[dev->devno] = ATA_DEV_NONE;
2669                         if ((ap->pflags & ATA_PFLAG_FROZEN) &&
2670                             ata_is_host_link(link))
2671                                 ata_eh_thaw_port(ap);
2672                         rc = 0;
2673                         goto out;
2674                 }
2675         }
2676
2677  retry:
2678         /*
2679          * Perform reset
2680          */
2681         if (ata_is_host_link(link))
2682                 ata_eh_freeze_port(ap);
2683
2684         deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]);
2685
2686         if (reset) {
2687                 if (verbose)
2688                         ata_link_info(link, "%s resetting link\n",
2689                                       reset == softreset ? "soft" : "hard");
2690
2691                 /* mark that this EH session started with reset */
2692                 ehc->last_reset = jiffies;
2693                 if (reset == hardreset)
2694                         ehc->i.flags |= ATA_EHI_DID_HARDRESET;
2695                 else
2696                         ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
2697
2698                 rc = ata_do_reset(link, reset, classes, deadline, true);
2699                 if (rc && rc != -EAGAIN) {
2700                         failed_link = link;
2701                         goto fail;
2702                 }
2703
2704                 /* hardreset slave link if existent */
2705                 if (slave && reset == hardreset) {
2706                         int tmp;
2707
2708                         if (verbose)
2709                                 ata_link_info(slave, "hard resetting link\n");
2710
2711                         ata_eh_about_to_do(slave, NULL, ATA_EH_RESET);
2712                         tmp = ata_do_reset(slave, reset, classes, deadline,
2713                                            false);
2714                         switch (tmp) {
2715                         case -EAGAIN:
2716                                 rc = -EAGAIN;
2717                         case 0:
2718                                 break;
2719                         default:
2720                                 failed_link = slave;
2721                                 rc = tmp;
2722                                 goto fail;
2723                         }
2724                 }
2725
2726                 /* perform follow-up SRST if necessary */
2727                 if (reset == hardreset &&
2728                     ata_eh_followup_srst_needed(link, rc)) {
2729                         reset = softreset;
2730
2731                         if (!reset) {
2732                                 ata_link_err(link,
2733              "follow-up softreset required but no softreset available\n");
2734                                 failed_link = link;
2735                                 rc = -EINVAL;
2736                                 goto fail;
2737                         }
2738
2739                         ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
2740                         rc = ata_do_reset(link, reset, classes, deadline, true);
2741                         if (rc) {
2742                                 failed_link = link;
2743                                 goto fail;
2744                         }
2745                 }
2746         } else {
2747                 if (verbose)
2748                         ata_link_info(link,
2749         "no reset method available, skipping reset\n");
2750                 if (!(lflags & ATA_LFLAG_ASSUME_CLASS))
2751                         lflags |= ATA_LFLAG_ASSUME_ATA;
2752         }
2753
2754         /*
2755          * Post-reset processing
2756          */
2757         ata_for_each_dev(dev, link, ALL) {
2758                 /* After the reset, the device state is PIO 0 and the
2759                  * controller state is undefined.  Reset also wakes up
2760                  * drives from sleeping mode.
2761                  */
2762                 dev->pio_mode = XFER_PIO_0;
2763                 dev->flags &= ~ATA_DFLAG_SLEEPING;
2764
2765                 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
2766                         continue;
2767
2768                 /* apply class override */
2769                 if (lflags & ATA_LFLAG_ASSUME_ATA)
2770                         classes[dev->devno] = ATA_DEV_ATA;
2771                 else if (lflags & ATA_LFLAG_ASSUME_SEMB)
2772                         classes[dev->devno] = ATA_DEV_SEMB_UNSUP;
2773         }
2774
2775         /* record current link speed */
2776         if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
2777                 link->sata_spd = (sstatus >> 4) & 0xf;
2778         if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0)
2779                 slave->sata_spd = (sstatus >> 4) & 0xf;
2780
2781         /* thaw the port */
2782         if (ata_is_host_link(link))
2783                 ata_eh_thaw_port(ap);
2784
2785         /* postreset() should clear hardware SError.  Although SError
2786          * is cleared during link resume, clearing SError here is
2787          * necessary as some PHYs raise hotplug events after SRST.
2788          * This introduces race condition where hotplug occurs between
2789          * reset and here.  This race is mediated by cross checking
2790          * link onlineness and classification result later.
2791          */
2792         if (postreset) {
2793                 postreset(link, classes);
2794                 if (slave)
2795                         postreset(slave, classes);
2796         }
2797
2798         /*
2799          * Some controllers can't be frozen very well and may set spurious
2800          * error conditions during reset.  Clear accumulated error
2801          * information and re-thaw the port if frozen.  As reset is the
2802          * final recovery action and we cross check link onlineness against
2803          * device classification later, no hotplug event is lost by this.
2804          */
2805         spin_lock_irqsave(link->ap->lock, flags);
2806         memset(&link->eh_info, 0, sizeof(link->eh_info));
2807         if (slave)
2808                 memset(&slave->eh_info, 0, sizeof(link->eh_info));
2809         ap->pflags &= ~ATA_PFLAG_EH_PENDING;
2810         spin_unlock_irqrestore(link->ap->lock, flags);
2811
2812         if (ap->pflags & ATA_PFLAG_FROZEN)
2813                 ata_eh_thaw_port(ap);
2814
2815         /*
2816          * Make sure onlineness and classification result correspond.
2817          * Hotplug could have happened during reset and some
2818          * controllers fail to wait while a drive is spinning up after
2819          * being hotplugged causing misdetection.  By cross checking
2820          * link on/offlineness and classification result, those
2821          * conditions can be reliably detected and retried.
2822          */
2823         nr_unknown = 0;
2824         ata_for_each_dev(dev, link, ALL) {
2825                 if (ata_phys_link_online(ata_dev_phys_link(dev))) {
2826                         if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
2827                                 ata_dev_dbg(dev, "link online but device misclassified\n");
2828                                 classes[dev->devno] = ATA_DEV_NONE;
2829                                 nr_unknown++;
2830                         }
2831                 } else if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
2832                         if (ata_class_enabled(classes[dev->devno]))
2833                                 ata_dev_dbg(dev,
2834                                             "link offline, clearing class %d to NONE\n",
2835                                             classes[dev->devno]);
2836                         classes[dev->devno] = ATA_DEV_NONE;
2837                 } else if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
2838                         ata_dev_dbg(dev,
2839                                     "link status unknown, clearing UNKNOWN to NONE\n");
2840                         classes[dev->devno] = ATA_DEV_NONE;
2841                 }
2842         }
2843
2844         if (classify && nr_unknown) {
2845                 if (try < max_tries) {
2846                         ata_link_warn(link,
2847                                       "link online but %d devices misclassified, retrying\n",
2848                                       nr_unknown);
2849                         failed_link = link;
2850                         rc = -EAGAIN;
2851                         goto fail;
2852                 }
2853                 ata_link_warn(link,
2854                               "link online but %d devices misclassified, "
2855                               "device detection might fail\n", nr_unknown);
2856         }
2857
2858         /* reset successful, schedule revalidation */
2859         ata_eh_done(link, NULL, ATA_EH_RESET);
2860         if (slave)
2861                 ata_eh_done(slave, NULL, ATA_EH_RESET);
2862         ehc->last_reset = jiffies;              /* update to completion time */
2863         ehc->i.action |= ATA_EH_REVALIDATE;
2864         link->lpm_policy = ATA_LPM_UNKNOWN;     /* reset LPM state */
2865
2866         rc = 0;
2867  out:
2868         /* clear hotplug flag */
2869         ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
2870         if (slave)
2871                 sehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
2872
2873         spin_lock_irqsave(ap->lock, flags);
2874         ap->pflags &= ~ATA_PFLAG_RESETTING;
2875         spin_unlock_irqrestore(ap->lock, flags);
2876
2877         return rc;
2878
2879  fail:
2880         /* if SCR isn't accessible on a fan-out port, PMP needs to be reset */
2881         if (!ata_is_host_link(link) &&
2882             sata_scr_read(link, SCR_STATUS, &sstatus))
2883                 rc = -ERESTART;
2884
2885         if (rc == -ERESTART || try >= max_tries) {
2886                 /*
2887                  * Thaw host port even if reset failed, so that the port
2888                  * can be retried on the next phy event.  This risks
2889                  * repeated EH runs but seems to be a better tradeoff than
2890                  * shutting down a port after a botched hotplug attempt.
2891                  */
2892                 if (ata_is_host_link(link))
2893                         ata_eh_thaw_port(ap);
2894                 goto out;
2895         }
2896
2897         now = jiffies;
2898         if (time_before(now, deadline)) {
2899                 unsigned long delta = deadline - now;
2900
2901                 ata_link_warn(failed_link,
2902                         "reset failed (errno=%d), retrying in %u secs\n",
2903                         rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));
2904
2905                 ata_eh_release(ap);
2906                 while (delta)
2907                         delta = schedule_timeout_uninterruptible(delta);
2908                 ata_eh_acquire(ap);
2909         }
2910
2911         if (try == max_tries - 1) {
2912                 sata_down_spd_limit(link, 0);
2913                 if (slave)
2914                         sata_down_spd_limit(slave, 0);
2915         } else if (rc == -EPIPE)
2916                 sata_down_spd_limit(failed_link, 0);
2917
2918         if (hardreset)
2919                 reset = hardreset;
2920         goto retry;
2921 }
2922
2923 static inline void ata_eh_pull_park_action(struct ata_port *ap)
2924 {
2925         struct ata_link *link;
2926         struct ata_device *dev;
2927         unsigned long flags;
2928
2929         /*
2930          * This function can be thought of as an extended version of
2931          * ata_eh_about_to_do() specially crafted to accommodate the
2932          * requirements of ATA_EH_PARK handling. Since the EH thread
2933          * does not leave the do {} while () loop in ata_eh_recover as
2934          * long as the timeout for a park request to *one* device on
2935          * the port has not expired, and since we still want to pick
2936          * up park requests to other devices on the same port or
2937          * timeout updates for the same device, we have to pull
2938          * ATA_EH_PARK actions from eh_info into eh_context.i
2939          * ourselves at the beginning of each pass over the loop.
2940          *
2941          * Additionally, all write accesses to &ap->park_req_pending
2942          * through INIT_COMPLETION() (see below) or complete_all()
2943          * (see ata_scsi_park_store()) are protected by the host lock.
2944          * As a result we have that park_req_pending.done is zero on
2945          * exit from this function, i.e. when ATA_EH_PARK actions for
2946          * *all* devices on port ap have been pulled into the
2947          * respective eh_context structs. If, and only if,
2948          * park_req_pending.done is non-zero by the time we reach
2949          * wait_for_completion_timeout(), another ATA_EH_PARK action
2950          * has been scheduled for at least one of the devices on port
2951          * ap and we have to cycle over the do {} while () loop in
2952          * ata_eh_recover() again.
2953          */
2954
2955         spin_lock_irqsave(ap->lock, flags);
2956         INIT_COMPLETION(ap->park_req_pending);
2957         ata_for_each_link(link, ap, EDGE) {
2958                 ata_for_each_dev(dev, link, ALL) {
2959                         struct ata_eh_info *ehi = &link->eh_info;
2960
2961                         link->eh_context.i.dev_action[dev->devno] |=
2962                                 ehi->dev_action[dev->devno] & ATA_EH_PARK;
2963                         ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK);
2964                 }
2965         }
2966         spin_unlock_irqrestore(ap->lock, flags);
2967 }
2968
2969 static void ata_eh_park_issue_cmd(struct ata_device *dev, int park)
2970 {
2971         struct ata_eh_context *ehc = &dev->link->eh_context;
2972         struct ata_taskfile tf;
2973         unsigned int err_mask;
2974
2975         ata_tf_init(dev, &tf);
2976         if (park) {
2977                 ehc->unloaded_mask |= 1 << dev->devno;
2978                 tf.command = ATA_CMD_IDLEIMMEDIATE;
2979                 tf.feature = 0x44;
2980                 tf.lbal = 0x4c;
2981                 tf.lbam = 0x4e;
2982                 tf.lbah = 0x55;
2983         } else {
2984                 ehc->unloaded_mask &= ~(1 << dev->devno);
2985                 tf.command = ATA_CMD_CHK_POWER;
2986         }
2987
2988         tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
2989         tf.protocol |= ATA_PROT_NODATA;
2990         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
2991         if (park && (err_mask || tf.lbal != 0xc4)) {
2992                 ata_dev_err(dev, "head unload failed!\n");
2993                 ehc->unloaded_mask &= ~(1 << dev->devno);
2994         }
2995 }
2996
2997 static int ata_eh_revalidate_and_attach(struct ata_link *link,
2998                                         struct ata_device **r_failed_dev)
2999 {
3000         struct ata_port *ap = link->ap;
3001         struct ata_eh_context *ehc = &link->eh_context;
3002         struct ata_device *dev;
3003         unsigned int new_mask = 0;
3004         unsigned long flags;
3005         int rc = 0;
3006
3007         DPRINTK("ENTER\n");
3008
3009         /* For PATA drive side cable detection to work, IDENTIFY must
3010          * be done backwards such that PDIAG- is released by the slave
3011          * device before the master device is identified.
3012          */
3013         ata_for_each_dev(dev, link, ALL_REVERSE) {
3014                 unsigned int action = ata_eh_dev_action(dev);
3015                 unsigned int readid_flags = 0;
3016
3017                 if (ehc->i.flags & ATA_EHI_DID_RESET)
3018                         readid_flags |= ATA_READID_POSTRESET;
3019
3020                 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
3021                         WARN_ON(dev->class == ATA_DEV_PMP);
3022
3023                         if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
3024                                 rc = -EIO;
3025                                 goto err;
3026                         }
3027
3028                         ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
3029                         rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
3030                                                 readid_flags);
3031                         if (rc)
3032                                 goto err;
3033
3034                         ata_eh_done(link, dev, ATA_EH_REVALIDATE);
3035
3036                         /* Configuration may have changed, reconfigure
3037                          * transfer mode.
3038                          */
3039                         ehc->i.flags |= ATA_EHI_SETMODE;
3040
3041                         /* schedule the scsi_rescan_device() here */
3042                         schedule_work(&(ap->scsi_rescan_task));
3043                 } else if (dev->class == ATA_DEV_UNKNOWN &&
3044                            ehc->tries[dev->devno] &&
3045                            ata_class_enabled(ehc->classes[dev->devno])) {
3046                         /* Temporarily set dev->class, it will be
3047                          * permanently set once all configurations are
3048                          * complete.  This is necessary because new
3049                          * device configuration is done in two
3050                          * separate loops.
3051                          */
3052                         dev->class = ehc->classes[dev->devno];
3053
3054                         if (dev->class == ATA_DEV_PMP)
3055                                 rc = sata_pmp_attach(dev);
3056                         else
3057                                 rc = ata_dev_read_id(dev, &dev->class,
3058                                                      readid_flags, dev->id);
3059
3060                         /* read_id might have changed class, store and reset */
3061                         ehc->classes[dev->devno] = dev->class;
3062                         dev->class = ATA_DEV_UNKNOWN;
3063
3064                         switch (rc) {
3065                         case 0:
3066                                 /* clear error info accumulated during probe */
3067                                 ata_ering_clear(&dev->ering);
3068                                 new_mask |= 1 << dev->devno;
3069                                 break;
3070                         case -ENOENT:
3071                                 /* IDENTIFY was issued to non-existent
3072                                  * device.  No need to reset.  Just
3073                                  * thaw and ignore the device.
3074                                  */
3075                                 ata_eh_thaw_port(ap);
3076                                 break;
3077                         default:
3078                                 goto err;
3079                         }
3080                 }
3081         }
3082
3083         /* PDIAG- should have been released, ask cable type if post-reset */
3084         if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) {
3085                 if (ap->ops->cable_detect)
3086                         ap->cbl = ap->ops->cable_detect(ap);
3087                 ata_force_cbl(ap);
3088         }
3089
3090         /* Configure new devices forward such that user doesn't see
3091          * device detection messages backwards.
3092          */
3093         ata_for_each_dev(dev, link, ALL) {
3094                 if (!(new_mask & (1 << dev->devno)))
3095                         continue;
3096
3097                 dev->class = ehc->classes[dev->devno];
3098
3099                 if (dev->class == ATA_DEV_PMP)
3100                         continue;
3101
3102                 ehc->i.flags |= ATA_EHI_PRINTINFO;
3103                 rc = ata_dev_configure(dev);
3104                 ehc->i.flags &= ~ATA_EHI_PRINTINFO;
3105                 if (rc) {
3106                         dev->class = ATA_DEV_UNKNOWN;
3107                         goto err;
3108                 }
3109
3110                 spin_lock_irqsave(ap->lock, flags);
3111                 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
3112                 spin_unlock_irqrestore(ap->lock, flags);
3113
3114                 /* new device discovered, configure xfermode */
3115                 ehc->i.flags |= ATA_EHI_SETMODE;
3116         }
3117
3118         return 0;
3119
3120  err:
3121         *r_failed_dev = dev;
3122         DPRINTK("EXIT rc=%d\n", rc);
3123         return rc;
3124 }
3125
3126 /**
3127  *      ata_set_mode - Program timings and issue SET FEATURES - XFER
3128  *      @link: link on which timings will be programmed
3129  *      @r_failed_dev: out parameter for failed device
3130  *
3131  *      Set ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
3132  *      ata_set_mode() fails, pointer to the failing device is
3133  *      returned in @r_failed_dev.
3134  *
3135  *      LOCKING:
3136  *      PCI/etc. bus probe sem.
3137  *
3138  *      RETURNS:
3139  *      0 on success, negative errno otherwise
3140  */
3141 int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3142 {
3143         struct ata_port *ap = link->ap;
3144         struct ata_device *dev;
3145         int rc;
3146
3147         /* if data transfer is verified, clear DUBIOUS_XFER on ering top */
3148         ata_for_each_dev(dev, link, ENABLED) {
3149                 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) {
3150                         struct ata_ering_entry *ent;
3151
3152                         ent = ata_ering_top(&dev->ering);
3153                         if (ent)
3154                                 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER;
3155                 }
3156         }
3157
3158         /* has private set_mode? */
3159         if (ap->ops->set_mode)
3160                 rc = ap->ops->set_mode(link, r_failed_dev);
3161         else
3162                 rc = ata_do_set_mode(link, r_failed_dev);
3163
3164         /* if transfer mode has changed, set DUBIOUS_XFER on device */
3165         ata_for_each_dev(dev, link, ENABLED) {
3166                 struct ata_eh_context *ehc = &link->eh_context;
3167                 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno];
3168                 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno));
3169
3170                 if (dev->xfer_mode != saved_xfer_mode ||
3171                     ata_ncq_enabled(dev) != saved_ncq)
3172                         dev->flags |= ATA_DFLAG_DUBIOUS_XFER;
3173         }
3174
3175         return rc;
3176 }
3177
3178 /**
3179  *      atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset
3180  *      @dev: ATAPI device to clear UA for
3181  *
3182  *      Resets and other operations can make an ATAPI device raise
3183  *      UNIT ATTENTION which causes the next operation to fail.  This
3184  *      function clears UA.
3185  *
3186  *      LOCKING:
3187  *      EH context (may sleep).
3188  *
3189  *      RETURNS:
3190  *      0 on success, -errno on failure.
3191  */
3192 static int atapi_eh_clear_ua(struct ata_device *dev)
3193 {
3194         int i;
3195
3196         for (i = 0; i < ATA_EH_UA_TRIES; i++) {
3197                 u8 *sense_buffer = dev->link->ap->sector_buf;
3198                 u8 sense_key = 0;
3199                 unsigned int err_mask;
3200
3201                 err_mask = atapi_eh_tur(dev, &sense_key);
3202                 if (err_mask != 0 && err_mask != AC_ERR_DEV) {
3203                         ata_dev_warn(dev,
3204                                      "TEST_UNIT_READY failed (err_mask=0x%x)\n",
3205                                      err_mask);
3206                         return -EIO;
3207                 }
3208
3209                 if (!err_mask || sense_key != UNIT_ATTENTION)
3210                         return 0;
3211
3212                 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key);
3213                 if (err_mask) {
3214                         ata_dev_warn(dev, "failed to clear "
3215                                 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask);
3216                         return -EIO;
3217                 }
3218         }
3219
3220         ata_dev_warn(dev, "UNIT ATTENTION persists after %d tries\n",
3221                      ATA_EH_UA_TRIES);
3222
3223         return 0;
3224 }
3225
3226 /**
3227  *      ata_eh_maybe_retry_flush - Retry FLUSH if necessary
3228  *      @dev: ATA device which may need FLUSH retry
3229  *
3230  *      If @dev failed FLUSH, it needs to be reported upper layer
3231  *      immediately as it means that @dev failed to remap and already
3232  *      lost at least a sector and further FLUSH retrials won't make
3233  *      any difference to the lost sector.  However, if FLUSH failed
3234  *      for other reasons, for example transmission error, FLUSH needs
3235  *      to be retried.
3236  *
3237  *      This function determines whether FLUSH failure retry is
3238  *      necessary and performs it if so.
3239  *
3240  *      RETURNS:
3241  *      0 if EH can continue, -errno if EH needs to be repeated.
3242  */
3243 static int ata_eh_maybe_retry_flush(struct ata_device *dev)
3244 {
3245         struct ata_link *link = dev->link;
3246         struct ata_port *ap = link->ap;
3247         struct ata_queued_cmd *qc;
3248         struct ata_taskfile tf;
3249         unsigned int err_mask;
3250         int rc = 0;
3251
3252         /* did flush fail for this device? */
3253         if (!ata_tag_valid(link->active_tag))
3254                 return 0;
3255
3256         qc = __ata_qc_from_tag(ap, link->active_tag);
3257         if (qc->dev != dev || (qc->tf.command != ATA_CMD_FLUSH_EXT &&
3258                                qc->tf.command != ATA_CMD_FLUSH))
3259                 return 0;
3260
3261         /* if the device failed it, it should be reported to upper layers */
3262         if (qc->err_mask & AC_ERR_DEV)
3263                 return 0;
3264
3265         /* flush failed for some other reason, give it another shot */
3266         ata_tf_init(dev, &tf);
3267
3268         tf.command = qc->tf.command;
3269         tf.flags |= ATA_TFLAG_DEVICE;
3270         tf.protocol = ATA_PROT_NODATA;
3271
3272         ata_dev_warn(dev, "retrying FLUSH 0x%x Emask 0x%x\n",
3273                        tf.command, qc->err_mask);
3274
3275         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
3276         if (!err_mask) {
3277                 /*
3278                  * FLUSH is complete but there's no way to
3279                  * successfully complete a failed command from EH.
3280                  * Making sure retry is allowed at least once and
3281                  * retrying it should do the trick - whatever was in
3282                  * the cache is already on the platter and this won't
3283                  * cause infinite loop.
3284                  */
3285                 qc->scsicmd->allowed = max(qc->scsicmd->allowed, 1);
3286         } else {
3287                 ata_dev_warn(dev, "FLUSH failed Emask 0x%x\n",
3288                                err_mask);
3289                 rc = -EIO;
3290
3291                 /* if device failed it, report it to upper layers */
3292                 if (err_mask & AC_ERR_DEV) {
3293                         qc->err_mask |= AC_ERR_DEV;
3294                         qc->result_tf = tf;
3295                         if (!(ap->pflags & ATA_PFLAG_FROZEN))
3296                                 rc = 0;
3297                 }
3298         }
3299         return rc;
3300 }
3301
3302 /**
3303  *      ata_eh_set_lpm - configure SATA interface power management
3304  *      @link: link to configure power management
3305  *      @policy: the link power management policy
3306  *      @r_failed_dev: out parameter for failed device
3307  *
3308  *      Enable SATA Interface power management.  This will enable
3309  *      Device Interface Power Management (DIPM) for min_power
3310  *      policy, and then call driver specific callbacks for
3311  *      enabling Host Initiated Power management.
3312  *
3313  *      LOCKING:
3314  *      EH context.
3315  *
3316  *      RETURNS:
3317  *      0 on success, -errno on failure.
3318  */
3319 static int ata_eh_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
3320                           struct ata_device **r_failed_dev)
3321 {
3322         struct ata_port *ap = ata_is_host_link(link) ? link->ap : NULL;
3323         struct ata_eh_context *ehc = &link->eh_context;
3324         struct ata_device *dev, *link_dev = NULL, *lpm_dev = NULL;
3325         enum ata_lpm_policy old_policy = link->lpm_policy;
3326         bool no_dipm = link->ap->flags & ATA_FLAG_NO_DIPM;
3327         unsigned int hints = ATA_LPM_EMPTY | ATA_LPM_HIPM;
3328         unsigned int err_mask;
3329         int rc;
3330
3331         /* if the link or host doesn't do LPM, noop */
3332         if ((link->flags & ATA_LFLAG_NO_LPM) || (ap && !ap->ops->set_lpm))
3333                 return 0;
3334
3335         /*
3336          * DIPM is enabled only for MIN_POWER as some devices
3337          * misbehave when the host NACKs transition to SLUMBER.  Order
3338          * device and link configurations such that the host always
3339          * allows DIPM requests.
3340          */
3341         ata_for_each_dev(dev, link, ENABLED) {
3342                 bool hipm = ata_id_has_hipm(dev->id);
3343                 bool dipm = ata_id_has_dipm(dev->id) && !no_dipm;
3344
3345                 /* find the first enabled and LPM enabled devices */
3346                 if (!link_dev)
3347                         link_dev = dev;
3348
3349                 if (!lpm_dev && (hipm || dipm))
3350                         lpm_dev = dev;
3351
3352                 hints &= ~ATA_LPM_EMPTY;
3353                 if (!hipm)
3354                         hints &= ~ATA_LPM_HIPM;
3355
3356                 /* disable DIPM before changing link config */
3357                 if (policy != ATA_LPM_MIN_POWER && dipm) {
3358                         err_mask = ata_dev_set_feature(dev,
3359                                         SETFEATURES_SATA_DISABLE, SATA_DIPM);
3360                         if (err_mask && err_mask != AC_ERR_DEV) {
3361                                 ata_dev_warn(dev,
3362                                              "failed to disable DIPM, Emask 0x%x\n",
3363                                              err_mask);
3364                                 rc = -EIO;
3365                                 goto fail;
3366                         }
3367                 }
3368         }
3369
3370         if (ap) {
3371                 rc = ap->ops->set_lpm(link, policy, hints);
3372                 if (!rc && ap->slave_link)
3373                         rc = ap->ops->set_lpm(ap->slave_link, policy, hints);
3374         } else
3375                 rc = sata_pmp_set_lpm(link, policy, hints);
3376
3377         /*
3378          * Attribute link config failure to the first (LPM) enabled
3379          * device on the link.
3380          */
3381         if (rc) {
3382                 if (rc == -EOPNOTSUPP) {
3383                         link->flags |= ATA_LFLAG_NO_LPM;
3384                         return 0;
3385                 }
3386                 dev = lpm_dev ? lpm_dev : link_dev;
3387                 goto fail;
3388         }
3389
3390         /*
3391          * Low level driver acked the transition.  Issue DIPM command
3392          * with the new policy set.
3393          */
3394         link->lpm_policy = policy;
3395         if (ap && ap->slave_link)
3396                 ap->slave_link->lpm_policy = policy;
3397
3398         /* host config updated, enable DIPM if transitioning to MIN_POWER */
3399         ata_for_each_dev(dev, link, ENABLED) {
3400                 if (policy == ATA_LPM_MIN_POWER && !no_dipm &&
3401                     ata_id_has_dipm(dev->id)) {
3402                         err_mask = ata_dev_set_feature(dev,
3403                                         SETFEATURES_SATA_ENABLE, SATA_DIPM);
3404                         if (err_mask && err_mask != AC_ERR_DEV) {
3405                                 ata_dev_warn(dev,
3406                                         "failed to enable DIPM, Emask 0x%x\n",
3407                                         err_mask);
3408                                 rc = -EIO;
3409                                 goto fail;
3410                         }
3411                 }
3412         }
3413
3414         return 0;
3415
3416 fail:
3417         /* restore the old policy */
3418         link->lpm_policy = old_policy;
3419         if (ap && ap->slave_link)
3420                 ap->slave_link->lpm_policy = old_policy;
3421
3422         /* if no device or only one more chance is left, disable LPM */
3423         if (!dev || ehc->tries[dev->devno] <= 2) {
3424                 ata_link_warn(link, "disabling LPM on the link\n");
3425                 link->flags |= ATA_LFLAG_NO_LPM;
3426         }
3427         if (r_failed_dev)
3428                 *r_failed_dev = dev;
3429         return rc;
3430 }
3431
3432 int ata_link_nr_enabled(struct ata_link *link)
3433 {
3434         struct ata_device *dev;
3435         int cnt = 0;
3436
3437         ata_for_each_dev(dev, link, ENABLED)
3438                 cnt++;
3439         return cnt;
3440 }
3441
3442 static int ata_link_nr_vacant(struct ata_link *link)
3443 {
3444         struct ata_device *dev;
3445         int cnt = 0;
3446
3447         ata_for_each_dev(dev, link, ALL)
3448                 if (dev->class == ATA_DEV_UNKNOWN)
3449                         cnt++;
3450         return cnt;
3451 }
3452
3453 static int ata_eh_skip_recovery(struct ata_link *link)
3454 {
3455         struct ata_port *ap = link->ap;
3456         struct ata_eh_context *ehc = &link->eh_context;
3457         struct ata_device *dev;
3458
3459         /* skip disabled links */
3460         if (link->flags & ATA_LFLAG_DISABLED)
3461                 return 1;
3462
3463         /* skip if explicitly requested */
3464         if (ehc->i.flags & ATA_EHI_NO_RECOVERY)
3465                 return 1;
3466
3467         /* thaw frozen port and recover failed devices */
3468         if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link))
3469                 return 0;
3470
3471         /* reset at least once if reset is requested */
3472         if ((ehc->i.action & ATA_EH_RESET) &&
3473             !(ehc->i.flags & ATA_EHI_DID_RESET))
3474                 return 0;
3475
3476         /* skip if class codes for all vacant slots are ATA_DEV_NONE */
3477         ata_for_each_dev(dev, link, ALL) {
3478                 if (dev->class == ATA_DEV_UNKNOWN &&
3479                     ehc->classes[dev->devno] != ATA_DEV_NONE)
3480                         return 0;
3481         }
3482
3483         return 1;
3484 }
3485
3486 static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg)
3487 {
3488         u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL);
3489         u64 now = get_jiffies_64();
3490         int *trials = void_arg;
3491
3492         if (ent->timestamp < now - min(now, interval))
3493                 return -1;
3494
3495         (*trials)++;
3496         return 0;
3497 }
3498
3499 static int ata_eh_schedule_probe(struct ata_device *dev)
3500 {
3501         struct ata_eh_context *ehc = &dev->link->eh_context;
3502         struct ata_link *link = ata_dev_phys_link(dev);
3503         int trials = 0;
3504
3505         if (!(ehc->i.probe_mask & (1 << dev->devno)) ||
3506             (ehc->did_probe_mask & (1 << dev->devno)))
3507                 return 0;
3508
3509         ata_eh_detach_dev(dev);
3510         ata_dev_init(dev);
3511         ehc->did_probe_mask |= (1 << dev->devno);
3512         ehc->i.action |= ATA_EH_RESET;
3513         ehc->saved_xfer_mode[dev->devno] = 0;
3514         ehc->saved_ncq_enabled &= ~(1 << dev->devno);
3515
3516         /* the link maybe in a deep sleep, wake it up */
3517         if (link->lpm_policy > ATA_LPM_MAX_POWER) {
3518                 if (ata_is_host_link(link))
3519                         link->ap->ops->set_lpm(link, ATA_LPM_MAX_POWER,
3520                                                ATA_LPM_EMPTY);
3521                 else
3522                         sata_pmp_set_lpm(link, ATA_LPM_MAX_POWER,
3523                                          ATA_LPM_EMPTY);
3524         }
3525
3526         /* Record and count probe trials on the ering.  The specific
3527          * error mask used is irrelevant.  Because a successful device
3528          * detection clears the ering, this count accumulates only if
3529          * there are consecutive failed probes.
3530          *
3531          * If the count is equal to or higher than ATA_EH_PROBE_TRIALS
3532          * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is
3533          * forced to 1.5Gbps.
3534          *
3535          * This is to work around cases where failed link speed
3536          * negotiation results in device misdetection leading to
3537          * infinite DEVXCHG or PHRDY CHG events.
3538          */
3539         ata_ering_record(&dev->ering, 0, AC_ERR_OTHER);
3540         ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials);
3541
3542         if (trials > ATA_EH_PROBE_TRIALS)
3543                 sata_down_spd_limit(link, 1);
3544
3545         return 1;
3546 }
3547
3548 static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
3549 {
3550         struct ata_eh_context *ehc = &dev->link->eh_context;
3551
3552         /* -EAGAIN from EH routine indicates retry without prejudice.
3553          * The requester is responsible for ensuring forward progress.
3554          */
3555         if (err != -EAGAIN)
3556                 ehc->tries[dev->devno]--;
3557
3558         switch (err) {
3559         case -ENODEV:
3560                 /* device missing or wrong IDENTIFY data, schedule probing */
3561                 ehc->i.probe_mask |= (1 << dev->devno);
3562         case -EINVAL:
3563                 /* give it just one more chance */
3564                 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
3565         case -EIO:
3566                 if (ehc->tries[dev->devno] == 1) {
3567                         /* This is the last chance, better to slow
3568                          * down than lose it.
3569                          */
3570                         sata_down_spd_limit(ata_dev_phys_link(dev), 0);
3571                         if (dev->pio_mode > XFER_PIO_0)
3572                                 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
3573                 }
3574         }
3575
3576         if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
3577                 /* disable device if it has used up all its chances */
3578                 ata_dev_disable(dev);
3579
3580                 /* detach if offline */
3581                 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
3582                         ata_eh_detach_dev(dev);
3583
3584                 /* schedule probe if necessary */
3585                 if (ata_eh_schedule_probe(dev)) {
3586                         ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
3587                         memset(ehc->cmd_timeout_idx[dev->devno], 0,
3588                                sizeof(ehc->cmd_timeout_idx[dev->devno]));
3589                 }
3590
3591                 return 1;
3592         } else {
3593                 ehc->i.action |= ATA_EH_RESET;
3594                 return 0;
3595         }
3596 }
3597
3598 /**
3599  *      ata_eh_recover - recover host port after error
3600  *      @ap: host port to recover
3601  *      @prereset: prereset method (can be NULL)
3602  *      @softreset: softreset method (can be NULL)
3603  *      @hardreset: hardreset method (can be NULL)
3604  *      @postreset: postreset method (can be NULL)
3605  *      @r_failed_link: out parameter for failed link
3606  *
3607  *      This is the alpha and omega, eum and yang, heart and soul of
3608  *      libata exception handling.  On entry, actions required to
3609  *      recover each link and hotplug requests are recorded in the
3610  *      link's eh_context.  This function executes all the operations
3611  *      with appropriate retrials and fallbacks to resurrect failed
3612  *      devices, detach goners and greet newcomers.
3613  *
3614  *      LOCKING:
3615  *      Kernel thread context (may sleep).
3616  *
3617  *      RETURNS:
3618  *      0 on success, -errno on failure.
3619  */
3620 int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
3621                    ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3622                    ata_postreset_fn_t postreset,
3623                    struct ata_link **r_failed_link)
3624 {
3625         struct ata_link *link;
3626         struct ata_device *dev;
3627         int rc, nr_fails;
3628         unsigned long flags, deadline;
3629
3630         DPRINTK("ENTER\n");
3631
3632         /* prep for recovery */
3633         ata_for_each_link(link, ap, EDGE) {
3634                 struct ata_eh_context *ehc = &link->eh_context;
3635
3636                 /* re-enable link? */
3637                 if (ehc->i.action & ATA_EH_ENABLE_LINK) {
3638                         ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
3639                         spin_lock_irqsave(ap->lock, flags);
3640                         link->flags &= ~ATA_LFLAG_DISABLED;
3641                         spin_unlock_irqrestore(ap->lock, flags);
3642                         ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
3643                 }
3644
3645                 ata_for_each_dev(dev, link, ALL) {
3646                         if (link->flags & ATA_LFLAG_NO_RETRY)
3647                                 ehc->tries[dev->devno] = 1;
3648                         else
3649                                 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
3650
3651                         /* collect port action mask recorded in dev actions */
3652                         ehc->i.action |= ehc->i.dev_action[dev->devno] &
3653                                          ~ATA_EH_PERDEV_MASK;
3654                         ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
3655
3656                         /* process hotplug request */
3657                         if (dev->flags & ATA_DFLAG_DETACH)
3658                                 ata_eh_detach_dev(dev);
3659
3660                         /* schedule probe if necessary */
3661                         if (!ata_dev_enabled(dev))
3662                                 ata_eh_schedule_probe(dev);
3663                 }
3664         }
3665
3666  retry:
3667         rc = 0;
3668
3669         /* if UNLOADING, finish immediately */
3670         if (ap->pflags & ATA_PFLAG_UNLOADING)
3671                 goto out;
3672
3673         /* prep for EH */
3674         ata_for_each_link(link, ap, EDGE) {
3675                 struct ata_eh_context *ehc = &link->eh_context;
3676
3677                 /* skip EH if possible. */
3678                 if (ata_eh_skip_recovery(link))
3679                         ehc->i.action = 0;
3680
3681                 ata_for_each_dev(dev, link, ALL)
3682                         ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
3683         }
3684
3685         /* reset */
3686         ata_for_each_link(link, ap, EDGE) {
3687                 struct ata_eh_context *ehc = &link->eh_context;
3688
3689                 if (!(ehc->i.action & ATA_EH_RESET))
3690                         continue;
3691
3692                 rc = ata_eh_reset(link, ata_link_nr_vacant(link),
3693                                   prereset, softreset, hardreset, postreset);
3694                 if (rc) {
3695                         ata_link_err(link, "reset failed, giving up\n");
3696                         goto out;
3697                 }
3698         }
3699
3700         do {
3701                 unsigned long now;
3702
3703                 /*
3704                  * clears ATA_EH_PARK in eh_info and resets
3705                  * ap->park_req_pending
3706                  */
3707                 ata_eh_pull_park_action(ap);
3708
3709                 deadline = jiffies;
3710                 ata_for_each_link(link, ap, EDGE) {
3711                         ata_for_each_dev(dev, link, ALL) {
3712                                 struct ata_eh_context *ehc = &link->eh_context;
3713                                 unsigned long tmp;
3714
3715                                 if (dev->class != ATA_DEV_ATA)
3716                                         continue;
3717                                 if (!(ehc->i.dev_action[dev->devno] &
3718                                       ATA_EH_PARK))
3719                                         continue;
3720                                 tmp = dev->unpark_deadline;
3721                                 if (time_before(deadline, tmp))
3722                                         deadline = tmp;
3723                                 else if (time_before_eq(tmp, jiffies))
3724                                         continue;
3725                                 if (ehc->unloaded_mask & (1 << dev->devno))
3726                                         continue;
3727
3728                                 ata_eh_park_issue_cmd(dev, 1);
3729                         }
3730                 }
3731
3732                 now = jiffies;
3733                 if (time_before_eq(deadline, now))
3734                         break;
3735
3736                 ata_eh_release(ap);
3737                 deadline = wait_for_completion_timeout(&ap->park_req_pending,
3738                                                        deadline - now);
3739                 ata_eh_acquire(ap);
3740         } while (deadline);
3741         ata_for_each_link(link, ap, EDGE) {
3742                 ata_for_each_dev(dev, link, ALL) {
3743                         if (!(link->eh_context.unloaded_mask &
3744                               (1 << dev->devno)))
3745                                 continue;
3746
3747                         ata_eh_park_issue_cmd(dev, 0);
3748                         ata_eh_done(link, dev, ATA_EH_PARK);
3749                 }
3750         }
3751
3752         /* the rest */
3753         nr_fails = 0;
3754         ata_for_each_link(link, ap, PMP_FIRST) {
3755                 struct ata_eh_context *ehc = &link->eh_context;
3756
3757                 if (sata_pmp_attached(ap) && ata_is_host_link(link))
3758                         goto config_lpm;
3759
3760                 /* revalidate existing devices and attach new ones */
3761                 rc = ata_eh_revalidate_and_attach(link, &dev);
3762                 if (rc)
3763                         goto rest_fail;
3764
3765                 /* if PMP got attached, return, pmp EH will take care of it */
3766                 if (link->device->class == ATA_DEV_PMP) {
3767                         ehc->i.action = 0;
3768                         return 0;
3769                 }
3770
3771                 /* configure transfer mode if necessary */
3772                 if (ehc->i.flags & ATA_EHI_SETMODE) {
3773                         rc = ata_set_mode(link, &dev);
3774                         if (rc)
3775                                 goto rest_fail;
3776                         ehc->i.flags &= ~ATA_EHI_SETMODE;
3777                 }
3778
3779                 /* If reset has been issued, clear UA to avoid
3780                  * disrupting the current users of the device.
3781                  */
3782                 if (ehc->i.flags & ATA_EHI_DID_RESET) {
3783                         ata_for_each_dev(dev, link, ALL) {
3784                                 if (dev->class != ATA_DEV_ATAPI)
3785                                         continue;
3786                                 rc = atapi_eh_clear_ua(dev);
3787                                 if (rc)
3788                                         goto rest_fail;
3789                         }
3790                 }
3791
3792                 /* retry flush if necessary */
3793                 ata_for_each_dev(dev, link, ALL) {
3794                         if (dev->class != ATA_DEV_ATA)
3795                                 continue;
3796                         rc = ata_eh_maybe_retry_flush(dev);
3797                         if (rc)
3798                                 goto rest_fail;
3799                 }
3800
3801         config_lpm:
3802                 /* configure link power saving */
3803                 if (link->lpm_policy != ap->target_lpm_policy) {
3804                         rc = ata_eh_set_lpm(link, ap->target_lpm_policy, &dev);
3805                         if (rc)
3806                                 goto rest_fail;
3807                 }
3808
3809                 /* this link is okay now */
3810                 ehc->i.flags = 0;
3811                 continue;
3812
3813         rest_fail:
3814                 nr_fails++;
3815                 if (dev)
3816                         ata_eh_handle_dev_fail(dev, rc);
3817
3818                 if (ap->pflags & ATA_PFLAG_FROZEN) {
3819                         /* PMP reset requires working host port.
3820                          * Can't retry if it's frozen.
3821                          */
3822                         if (sata_pmp_attached(ap))
3823                                 goto out;
3824                         break;
3825                 }
3826         }
3827
3828         if (nr_fails)
3829                 goto retry;
3830
3831  out:
3832         if (rc && r_failed_link)
3833                 *r_failed_link = link;
3834
3835         DPRINTK("EXIT, rc=%d\n", rc);
3836         return rc;
3837 }
3838
3839 /**
3840  *      ata_eh_finish - finish up EH
3841  *      @ap: host port to finish EH for
3842  *
3843  *      Recovery is complete.  Clean up EH states and retry or finish
3844  *      failed qcs.
3845  *
3846  *      LOCKING:
3847  *      None.
3848  */
3849 void ata_eh_finish(struct ata_port *ap)
3850 {
3851         int tag;
3852
3853         /* retry or finish qcs */
3854         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
3855                 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
3856
3857                 if (!(qc->flags & ATA_QCFLAG_FAILED))
3858                         continue;
3859
3860                 if (qc->err_mask) {
3861                         /* FIXME: Once EH migration is complete,
3862                          * generate sense data in this function,
3863                          * considering both err_mask and tf.
3864                          */
3865                         if (qc->flags & ATA_QCFLAG_RETRY)
3866                                 ata_eh_qc_retry(qc);
3867                         else
3868                                 ata_eh_qc_complete(qc);
3869                 } else {
3870                         if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
3871                                 ata_eh_qc_complete(qc);
3872                         } else {
3873                                 /* feed zero TF to sense generation */
3874                                 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
3875                                 ata_eh_qc_retry(qc);
3876                         }
3877                 }
3878         }
3879
3880         /* make sure nr_active_links is zero after EH */
3881         WARN_ON(ap->nr_active_links);
3882         ap->nr_active_links = 0;
3883 }
3884
3885 /**
3886  *      ata_do_eh - do standard error handling
3887  *      @ap: host port to handle error for
3888  *
3889  *      @prereset: prereset method (can be NULL)
3890  *      @softreset: softreset method (can be NULL)
3891  *      @hardreset: hardreset method (can be NULL)
3892  *      @postreset: postreset method (can be NULL)
3893  *
3894  *      Perform standard error handling sequence.
3895  *
3896  *      LOCKING:
3897  *      Kernel thread context (may sleep).
3898  */
3899 void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
3900                ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3901                ata_postreset_fn_t postreset)
3902 {
3903         struct ata_device *dev;
3904         int rc;
3905
3906         ata_eh_autopsy(ap);
3907         ata_eh_report(ap);
3908
3909         rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
3910                             NULL);
3911         if (rc) {
3912                 ata_for_each_dev(dev, &ap->link, ALL)
3913                         ata_dev_disable(dev);
3914         }
3915
3916         ata_eh_finish(ap);
3917 }
3918
3919 /**
3920  *      ata_std_error_handler - standard error handler
3921  *      @ap: host port to handle error for
3922  *
3923  *      Standard error handler
3924  *
3925  *      LOCKING:
3926  *      Kernel thread context (may sleep).
3927  */
3928 void ata_std_error_handler(struct ata_port *ap)
3929 {
3930         struct ata_port_operations *ops = ap->ops;
3931         ata_reset_fn_t hardreset = ops->hardreset;
3932
3933         /* ignore built-in hardreset if SCR access is not available */
3934         if (hardreset == sata_std_hardreset && !sata_scr_valid(&ap->link))
3935                 hardreset = NULL;
3936
3937         ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);
3938 }
3939
3940 #ifdef CONFIG_PM
3941 /**
3942  *      ata_eh_handle_port_suspend - perform port suspend operation
3943  *      @ap: port to suspend
3944  *
3945  *      Suspend @ap.
3946  *
3947  *      LOCKING:
3948  *      Kernel thread context (may sleep).
3949  */
3950 static void ata_eh_handle_port_suspend(struct ata_port *ap)
3951 {
3952         unsigned long flags;
3953         int rc = 0;
3954
3955         /* are we suspending? */
3956         spin_lock_irqsave(ap->lock, flags);
3957         if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
3958             ap->pm_mesg.event == PM_EVENT_ON) {
3959                 spin_unlock_irqrestore(ap->lock, flags);
3960                 return;
3961         }
3962         spin_unlock_irqrestore(ap->lock, flags);
3963
3964         WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
3965
3966         /* tell ACPI we're suspending */
3967         rc = ata_acpi_on_suspend(ap);
3968         if (rc)
3969                 goto out;
3970
3971         /* suspend */
3972         ata_eh_freeze_port(ap);
3973
3974         if (ap->ops->port_suspend)
3975                 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
3976
3977         ata_acpi_set_state(ap, PMSG_SUSPEND);
3978  out:
3979         /* report result */
3980         spin_lock_irqsave(ap->lock, flags);
3981
3982         ap->pflags &= ~ATA_PFLAG_PM_PENDING;
3983         if (rc == 0)
3984                 ap->pflags |= ATA_PFLAG_SUSPENDED;
3985         else if (ap->pflags & ATA_PFLAG_FROZEN)
3986                 ata_port_schedule_eh(ap);
3987
3988         if (ap->pm_result) {
3989                 *ap->pm_result = rc;
3990                 ap->pm_result = NULL;
3991         }
3992
3993         spin_unlock_irqrestore(ap->lock, flags);
3994
3995         return;
3996 }
3997
3998 /**
3999  *      ata_eh_handle_port_resume - perform port resume operation
4000  *      @ap: port to resume
4001  *
4002  *      Resume @ap.
4003  *
4004  *      LOCKING:
4005  *      Kernel thread context (may sleep).
4006  */
4007 static void ata_eh_handle_port_resume(struct ata_port *ap)
4008 {
4009         struct ata_link *link;
4010         struct ata_device *dev;
4011         unsigned long flags;
4012         int rc = 0;
4013
4014         /* are we resuming? */
4015         spin_lock_irqsave(ap->lock, flags);
4016         if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
4017             ap->pm_mesg.event != PM_EVENT_ON) {
4018                 spin_unlock_irqrestore(ap->lock, flags);
4019                 return;
4020         }
4021         spin_unlock_irqrestore(ap->lock, flags);
4022
4023         WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
4024
4025         /*
4026          * Error timestamps are in jiffies which doesn't run while
4027          * suspended and PHY events during resume isn't too uncommon.
4028          * When the two are combined, it can lead to unnecessary speed
4029          * downs if the machine is suspended and resumed repeatedly.
4030          * Clear error history.
4031          */
4032         ata_for_each_link(link, ap, HOST_FIRST)
4033                 ata_for_each_dev(dev, link, ALL)
4034                         ata_ering_clear(&dev->ering);
4035
4036         ata_acpi_set_state(ap, PMSG_ON);
4037
4038         if (ap->ops->port_resume)
4039                 rc = ap->ops->port_resume(ap);
4040
4041         /* tell ACPI that we're resuming */
4042         ata_acpi_on_resume(ap);
4043
4044         /* report result */
4045         spin_lock_irqsave(ap->lock, flags);
4046         ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
4047         if (ap->pm_result) {
4048                 *ap->pm_result = rc;
4049                 ap->pm_result = NULL;
4050         }
4051         spin_unlock_irqrestore(ap->lock, flags);
4052 }
4053 #endif /* CONFIG_PM */