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