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