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