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