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