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