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