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