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