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