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