PageRenderTime 91ms CodeModel.GetById 15ms app.highlight 60ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/ata/libata-eh.c

http://github.com/mirrors/linux
C | 3976 lines | 2313 code | 532 blank | 1131 comment | 500 complexity | a860a0d0ecf0a8a4d070f5c92e87c4d4 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  libata-eh.c - libata error handling
   4 *
   5 *  Copyright 2006 Tejun Heo <htejun@gmail.com>
   6 *
   7 *  libata documentation is available via 'make {ps|pdf}docs',
   8 *  as Documentation/driver-api/libata.rst
   9 *
  10 *  Hardware documentation available from http://www.t13.org/ and
  11 *  http://www.sata-io.org/
  12 */
  13
  14#include <linux/kernel.h>
  15#include <linux/blkdev.h>
  16#include <linux/export.h>
  17#include <linux/pci.h>
  18#include <scsi/scsi.h>
  19#include <scsi/scsi_host.h>
  20#include <scsi/scsi_eh.h>
  21#include <scsi/scsi_device.h>
  22#include <scsi/scsi_cmnd.h>
  23#include <scsi/scsi_dbg.h>
  24#include "../scsi/scsi_transport_api.h"
  25
  26#include <linux/libata.h>
  27
  28#include <trace/events/libata.h>
  29#include "libata.h"
  30
  31enum {
  32	/* speed down verdicts */
  33	ATA_EH_SPDN_NCQ_OFF		= (1 << 0),
  34	ATA_EH_SPDN_SPEED_DOWN		= (1 << 1),
  35	ATA_EH_SPDN_FALLBACK_TO_PIO	= (1 << 2),
  36	ATA_EH_SPDN_KEEP_ERRORS		= (1 << 3),
  37
  38	/* error flags */
  39	ATA_EFLAG_IS_IO			= (1 << 0),
  40	ATA_EFLAG_DUBIOUS_XFER		= (1 << 1),
  41	ATA_EFLAG_OLD_ER                = (1 << 31),
  42
  43	/* error categories */
  44	ATA_ECAT_NONE			= 0,
  45	ATA_ECAT_ATA_BUS		= 1,
  46	ATA_ECAT_TOUT_HSM		= 2,
  47	ATA_ECAT_UNK_DEV		= 3,
  48	ATA_ECAT_DUBIOUS_NONE		= 4,
  49	ATA_ECAT_DUBIOUS_ATA_BUS	= 5,
  50	ATA_ECAT_DUBIOUS_TOUT_HSM	= 6,
  51	ATA_ECAT_DUBIOUS_UNK_DEV	= 7,
  52	ATA_ECAT_NR			= 8,
  53
  54	ATA_EH_CMD_DFL_TIMEOUT		=  5000,
  55
  56	/* always put at least this amount of time between resets */
  57	ATA_EH_RESET_COOL_DOWN		=  5000,
  58
  59	/* Waiting in ->prereset can never be reliable.  It's
  60	 * sometimes nice to wait there but it can't be depended upon;
  61	 * otherwise, we wouldn't be resetting.  Just give it enough
  62	 * time for most drives to spin up.
  63	 */
  64	ATA_EH_PRERESET_TIMEOUT		= 10000,
  65	ATA_EH_FASTDRAIN_INTERVAL	=  3000,
  66
  67	ATA_EH_UA_TRIES			= 5,
  68
  69	/* probe speed down parameters, see ata_eh_schedule_probe() */
  70	ATA_EH_PROBE_TRIAL_INTERVAL	= 60000,	/* 1 min */
  71	ATA_EH_PROBE_TRIALS		= 2,
  72};
  73
  74/* The following table determines how we sequence resets.  Each entry
  75 * represents timeout for that try.  The first try can be soft or
  76 * hardreset.  All others are hardreset if available.  In most cases
  77 * the first reset w/ 10sec timeout should succeed.  Following entries
  78 * are mostly for error handling, hotplug and those outlier devices that
  79 * take an exceptionally long time to recover from reset.
  80 */
  81static const unsigned long ata_eh_reset_timeouts[] = {
  82	10000,	/* most drives spin up by 10sec */
  83	10000,	/* > 99% working drives spin up before 20sec */
  84	35000,	/* give > 30 secs of idleness for outlier devices */
  85	 5000,	/* and sweet one last chance */
  86	ULONG_MAX, /* > 1 min has elapsed, give up */
  87};
  88
  89static const unsigned long ata_eh_identify_timeouts[] = {
  90	 5000,	/* covers > 99% of successes and not too boring on failures */
  91	10000,  /* combined time till here is enough even for media access */
  92	30000,	/* for true idiots */
  93	ULONG_MAX,
  94};
  95
  96static const unsigned long ata_eh_flush_timeouts[] = {
  97	15000,	/* be generous with flush */
  98	15000,  /* ditto */
  99	30000,	/* and even more generous */
 100	ULONG_MAX,
 101};
 102
 103static const unsigned long ata_eh_other_timeouts[] = {
 104	 5000,	/* same rationale as identify timeout */
 105	10000,	/* ditto */
 106	/* but no merciful 30sec for other commands, it just isn't worth it */
 107	ULONG_MAX,
 108};
 109
 110struct ata_eh_cmd_timeout_ent {
 111	const u8		*commands;
 112	const unsigned long	*timeouts;
 113};
 114
 115/* The following table determines timeouts to use for EH internal
 116 * commands.  Each table entry is a command class and matches the
 117 * commands the entry applies to and the timeout table to use.
 118 *
 119 * On the retry after a command timed out, the next timeout value from
 120 * the table is used.  If the table doesn't contain further entries,
 121 * the last value is used.
 122 *
 123 * ehc->cmd_timeout_idx keeps track of which timeout to use per
 124 * command class, so if SET_FEATURES times out on the first try, the
 125 * next try will use the second timeout value only for that class.
 126 */
 127#define CMDS(cmds...)	(const u8 []){ cmds, 0 }
 128static const struct ata_eh_cmd_timeout_ent
 129ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = {
 130	{ .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI),
 131	  .timeouts = ata_eh_identify_timeouts, },
 132	{ .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT),
 133	  .timeouts = ata_eh_other_timeouts, },
 134	{ .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT),
 135	  .timeouts = ata_eh_other_timeouts, },
 136	{ .commands = CMDS(ATA_CMD_SET_FEATURES),
 137	  .timeouts = ata_eh_other_timeouts, },
 138	{ .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS),
 139	  .timeouts = ata_eh_other_timeouts, },
 140	{ .commands = CMDS(ATA_CMD_FLUSH, ATA_CMD_FLUSH_EXT),
 141	  .timeouts = ata_eh_flush_timeouts },
 142};
 143#undef CMDS
 144
 145static void __ata_port_freeze(struct ata_port *ap);
 146#ifdef CONFIG_PM
 147static void ata_eh_handle_port_suspend(struct ata_port *ap);
 148static void ata_eh_handle_port_resume(struct ata_port *ap);
 149#else /* CONFIG_PM */
 150static void ata_eh_handle_port_suspend(struct ata_port *ap)
 151{ }
 152
 153static void ata_eh_handle_port_resume(struct ata_port *ap)
 154{ }
 155#endif /* CONFIG_PM */
 156
 157static __printf(2, 0) void __ata_ehi_pushv_desc(struct ata_eh_info *ehi,
 158				 const char *fmt, va_list args)
 159{
 160	ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
 161				     ATA_EH_DESC_LEN - ehi->desc_len,
 162				     fmt, args);
 163}
 164
 165/**
 166 *	__ata_ehi_push_desc - push error description without adding separator
 167 *	@ehi: target EHI
 168 *	@fmt: printf format string
 169 *
 170 *	Format string according to @fmt and append it to @ehi->desc.
 171 *
 172 *	LOCKING:
 173 *	spin_lock_irqsave(host lock)
 174 */
 175void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
 176{
 177	va_list args;
 178
 179	va_start(args, fmt);
 180	__ata_ehi_pushv_desc(ehi, fmt, args);
 181	va_end(args);
 182}
 183EXPORT_SYMBOL_GPL(__ata_ehi_push_desc);
 184
 185/**
 186 *	ata_ehi_push_desc - push error description with separator
 187 *	@ehi: target EHI
 188 *	@fmt: printf format string
 189 *
 190 *	Format string according to @fmt and append it to @ehi->desc.
 191 *	If @ehi->desc is not empty, ", " is added in-between.
 192 *
 193 *	LOCKING:
 194 *	spin_lock_irqsave(host lock)
 195 */
 196void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
 197{
 198	va_list args;
 199
 200	if (ehi->desc_len)
 201		__ata_ehi_push_desc(ehi, ", ");
 202
 203	va_start(args, fmt);
 204	__ata_ehi_pushv_desc(ehi, fmt, args);
 205	va_end(args);
 206}
 207EXPORT_SYMBOL_GPL(ata_ehi_push_desc);
 208
 209/**
 210 *	ata_ehi_clear_desc - clean error description
 211 *	@ehi: target EHI
 212 *
 213 *	Clear @ehi->desc.
 214 *
 215 *	LOCKING:
 216 *	spin_lock_irqsave(host lock)
 217 */
 218void ata_ehi_clear_desc(struct ata_eh_info *ehi)
 219{
 220	ehi->desc[0] = '\0';
 221	ehi->desc_len = 0;
 222}
 223EXPORT_SYMBOL_GPL(ata_ehi_clear_desc);
 224
 225/**
 226 *	ata_port_desc - append port description
 227 *	@ap: target ATA port
 228 *	@fmt: printf format string
 229 *
 230 *	Format string according to @fmt and append it to port
 231 *	description.  If port description is not empty, " " is added
 232 *	in-between.  This function is to be used while initializing
 233 *	ata_host.  The description is printed on host registration.
 234 *
 235 *	LOCKING:
 236 *	None.
 237 */
 238void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
 239{
 240	va_list args;
 241
 242	WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
 243
 244	if (ap->link.eh_info.desc_len)
 245		__ata_ehi_push_desc(&ap->link.eh_info, " ");
 246
 247	va_start(args, fmt);
 248	__ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
 249	va_end(args);
 250}
 251EXPORT_SYMBOL_GPL(ata_port_desc);
 252
 253#ifdef CONFIG_PCI
 254/**
 255 *	ata_port_pbar_desc - append PCI BAR description
 256 *	@ap: target ATA port
 257 *	@bar: target PCI BAR
 258 *	@offset: offset into PCI BAR
 259 *	@name: name of the area
 260 *
 261 *	If @offset is negative, this function formats a string which
 262 *	contains the name, address, size and type of the BAR and
 263 *	appends it to the port description.  If @offset is zero or
 264 *	positive, only name and offsetted address is appended.
 265 *
 266 *	LOCKING:
 267 *	None.
 268 */
 269void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
 270			const char *name)
 271{
 272	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 273	char *type = "";
 274	unsigned long long start, len;
 275
 276	if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
 277		type = "m";
 278	else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
 279		type = "i";
 280
 281	start = (unsigned long long)pci_resource_start(pdev, bar);
 282	len = (unsigned long long)pci_resource_len(pdev, bar);
 283
 284	if (offset < 0)
 285		ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
 286	else
 287		ata_port_desc(ap, "%s 0x%llx", name,
 288				start + (unsigned long long)offset);
 289}
 290EXPORT_SYMBOL_GPL(ata_port_pbar_desc);
 291#endif /* CONFIG_PCI */
 292
 293static int ata_lookup_timeout_table(u8 cmd)
 294{
 295	int i;
 296
 297	for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) {
 298		const u8 *cur;
 299
 300		for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++)
 301			if (*cur == cmd)
 302				return i;
 303	}
 304
 305	return -1;
 306}
 307
 308/**
 309 *	ata_internal_cmd_timeout - determine timeout for an internal command
 310 *	@dev: target device
 311 *	@cmd: internal command to be issued
 312 *
 313 *	Determine timeout for internal command @cmd for @dev.
 314 *
 315 *	LOCKING:
 316 *	EH context.
 317 *
 318 *	RETURNS:
 319 *	Determined timeout.
 320 */
 321unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd)
 322{
 323	struct ata_eh_context *ehc = &dev->link->eh_context;
 324	int ent = ata_lookup_timeout_table(cmd);
 325	int idx;
 326
 327	if (ent < 0)
 328		return ATA_EH_CMD_DFL_TIMEOUT;
 329
 330	idx = ehc->cmd_timeout_idx[dev->devno][ent];
 331	return ata_eh_cmd_timeout_table[ent].timeouts[idx];
 332}
 333
 334/**
 335 *	ata_internal_cmd_timed_out - notification for internal command timeout
 336 *	@dev: target device
 337 *	@cmd: internal command which timed out
 338 *
 339 *	Notify EH that internal command @cmd for @dev timed out.  This
 340 *	function should be called only for commands whose timeouts are
 341 *	determined using ata_internal_cmd_timeout().
 342 *
 343 *	LOCKING:
 344 *	EH context.
 345 */
 346void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd)
 347{
 348	struct ata_eh_context *ehc = &dev->link->eh_context;
 349	int ent = ata_lookup_timeout_table(cmd);
 350	int idx;
 351
 352	if (ent < 0)
 353		return;
 354
 355	idx = ehc->cmd_timeout_idx[dev->devno][ent];
 356	if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX)
 357		ehc->cmd_timeout_idx[dev->devno][ent]++;
 358}
 359
 360static void ata_ering_record(struct ata_ering *ering, unsigned int eflags,
 361			     unsigned int err_mask)
 362{
 363	struct ata_ering_entry *ent;
 364
 365	WARN_ON(!err_mask);
 366
 367	ering->cursor++;
 368	ering->cursor %= ATA_ERING_SIZE;
 369
 370	ent = &ering->ring[ering->cursor];
 371	ent->eflags = eflags;
 372	ent->err_mask = err_mask;
 373	ent->timestamp = get_jiffies_64();
 374}
 375
 376static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
 377{
 378	struct ata_ering_entry *ent = &ering->ring[ering->cursor];
 379
 380	if (ent->err_mask)
 381		return ent;
 382	return NULL;
 383}
 384
 385int ata_ering_map(struct ata_ering *ering,
 386		  int (*map_fn)(struct ata_ering_entry *, void *),
 387		  void *arg)
 388{
 389	int idx, rc = 0;
 390	struct ata_ering_entry *ent;
 391
 392	idx = ering->cursor;
 393	do {
 394		ent = &ering->ring[idx];
 395		if (!ent->err_mask)
 396			break;
 397		rc = map_fn(ent, arg);
 398		if (rc)
 399			break;
 400		idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
 401	} while (idx != ering->cursor);
 402
 403	return rc;
 404}
 405
 406static int ata_ering_clear_cb(struct ata_ering_entry *ent, void *void_arg)
 407{
 408	ent->eflags |= ATA_EFLAG_OLD_ER;
 409	return 0;
 410}
 411
 412static void ata_ering_clear(struct ata_ering *ering)
 413{
 414	ata_ering_map(ering, ata_ering_clear_cb, NULL);
 415}
 416
 417static unsigned int ata_eh_dev_action(struct ata_device *dev)
 418{
 419	struct ata_eh_context *ehc = &dev->link->eh_context;
 420
 421	return ehc->i.action | ehc->i.dev_action[dev->devno];
 422}
 423
 424static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
 425				struct ata_eh_info *ehi, unsigned int action)
 426{
 427	struct ata_device *tdev;
 428
 429	if (!dev) {
 430		ehi->action &= ~action;
 431		ata_for_each_dev(tdev, link, ALL)
 432			ehi->dev_action[tdev->devno] &= ~action;
 433	} else {
 434		/* doesn't make sense for port-wide EH actions */
 435		WARN_ON(!(action & ATA_EH_PERDEV_MASK));
 436
 437		/* break ehi->action into ehi->dev_action */
 438		if (ehi->action & action) {
 439			ata_for_each_dev(tdev, link, ALL)
 440				ehi->dev_action[tdev->devno] |=
 441					ehi->action & action;
 442			ehi->action &= ~action;
 443		}
 444
 445		/* turn off the specified per-dev action */
 446		ehi->dev_action[dev->devno] &= ~action;
 447	}
 448}
 449
 450/**
 451 *	ata_eh_acquire - acquire EH ownership
 452 *	@ap: ATA port to acquire EH ownership for
 453 *
 454 *	Acquire EH ownership for @ap.  This is the basic exclusion
 455 *	mechanism for ports sharing a host.  Only one port hanging off
 456 *	the same host can claim the ownership of EH.
 457 *
 458 *	LOCKING:
 459 *	EH context.
 460 */
 461void ata_eh_acquire(struct ata_port *ap)
 462{
 463	mutex_lock(&ap->host->eh_mutex);
 464	WARN_ON_ONCE(ap->host->eh_owner);
 465	ap->host->eh_owner = current;
 466}
 467
 468/**
 469 *	ata_eh_release - release EH ownership
 470 *	@ap: ATA port to release EH ownership for
 471 *
 472 *	Release EH ownership for @ap if the caller.  The caller must
 473 *	have acquired EH ownership using ata_eh_acquire() previously.
 474 *
 475 *	LOCKING:
 476 *	EH context.
 477 */
 478void ata_eh_release(struct ata_port *ap)
 479{
 480	WARN_ON_ONCE(ap->host->eh_owner != current);
 481	ap->host->eh_owner = NULL;
 482	mutex_unlock(&ap->host->eh_mutex);
 483}
 484
 485static void ata_eh_unload(struct ata_port *ap)
 486{
 487	struct ata_link *link;
 488	struct ata_device *dev;
 489	unsigned long flags;
 490
 491	/* Restore SControl IPM and SPD for the next driver and
 492	 * disable attached devices.
 493	 */
 494	ata_for_each_link(link, ap, PMP_FIRST) {
 495		sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);
 496		ata_for_each_dev(dev, link, ALL)
 497			ata_dev_disable(dev);
 498	}
 499
 500	/* freeze and set UNLOADED */
 501	spin_lock_irqsave(ap->lock, flags);
 502
 503	ata_port_freeze(ap);			/* won't be thawed */
 504	ap->pflags &= ~ATA_PFLAG_EH_PENDING;	/* clear pending from freeze */
 505	ap->pflags |= ATA_PFLAG_UNLOADED;
 506
 507	spin_unlock_irqrestore(ap->lock, flags);
 508}
 509
 510/**
 511 *	ata_scsi_error - SCSI layer error handler callback
 512 *	@host: SCSI host on which error occurred
 513 *
 514 *	Handles SCSI-layer-thrown error events.
 515 *
 516 *	LOCKING:
 517 *	Inherited from SCSI layer (none, can sleep)
 518 *
 519 *	RETURNS:
 520 *	Zero.
 521 */
 522void ata_scsi_error(struct Scsi_Host *host)
 523{
 524	struct ata_port *ap = ata_shost_to_port(host);
 525	unsigned long flags;
 526	LIST_HEAD(eh_work_q);
 527
 528	DPRINTK("ENTER\n");
 529
 530	spin_lock_irqsave(host->host_lock, flags);
 531	list_splice_init(&host->eh_cmd_q, &eh_work_q);
 532	spin_unlock_irqrestore(host->host_lock, flags);
 533
 534	ata_scsi_cmd_error_handler(host, ap, &eh_work_q);
 535
 536	/* If we timed raced normal completion and there is nothing to
 537	   recover nr_timedout == 0 why exactly are we doing error recovery ? */
 538	ata_scsi_port_error_handler(host, ap);
 539
 540	/* finish or retry handled scmd's and clean up */
 541	WARN_ON(!list_empty(&eh_work_q));
 542
 543	DPRINTK("EXIT\n");
 544}
 545
 546/**
 547 * ata_scsi_cmd_error_handler - error callback for a list of commands
 548 * @host:	scsi host containing the port
 549 * @ap:		ATA port within the host
 550 * @eh_work_q:	list of commands to process
 551 *
 552 * process the given list of commands and return those finished to the
 553 * ap->eh_done_q.  This function is the first part of the libata error
 554 * handler which processes a given list of failed commands.
 555 */
 556void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap,
 557				struct list_head *eh_work_q)
 558{
 559	int i;
 560	unsigned long flags;
 561
 562	/* make sure sff pio task is not running */
 563	ata_sff_flush_pio_task(ap);
 564
 565	/* synchronize with host lock and sort out timeouts */
 566
 567	/* For new EH, all qcs are finished in one of three ways -
 568	 * normal completion, error completion, and SCSI timeout.
 569	 * Both completions can race against SCSI timeout.  When normal
 570	 * completion wins, the qc never reaches EH.  When error
 571	 * completion wins, the qc has ATA_QCFLAG_FAILED set.
 572	 *
 573	 * When SCSI timeout wins, things are a bit more complex.
 574	 * Normal or error completion can occur after the timeout but
 575	 * before this point.  In such cases, both types of
 576	 * completions are honored.  A scmd is determined to have
 577	 * timed out iff its associated qc is active and not failed.
 578	 */
 579	spin_lock_irqsave(ap->lock, flags);
 580	if (ap->ops->error_handler) {
 581		struct scsi_cmnd *scmd, *tmp;
 582		int nr_timedout = 0;
 583
 584		/* This must occur under the ap->lock as we don't want
 585		   a polled recovery to race the real interrupt handler
 586
 587		   The lost_interrupt handler checks for any completed but
 588		   non-notified command and completes much like an IRQ handler.
 589
 590		   We then fall into the error recovery code which will treat
 591		   this as if normal completion won the race */
 592
 593		if (ap->ops->lost_interrupt)
 594			ap->ops->lost_interrupt(ap);
 595
 596		list_for_each_entry_safe(scmd, tmp, eh_work_q, eh_entry) {
 597			struct ata_queued_cmd *qc;
 598
 599			ata_qc_for_each_raw(ap, qc, i) {
 600				if (qc->flags & ATA_QCFLAG_ACTIVE &&
 601				    qc->scsicmd == scmd)
 602					break;
 603			}
 604
 605			if (i < ATA_MAX_QUEUE) {
 606				/* the scmd has an associated qc */
 607				if (!(qc->flags & ATA_QCFLAG_FAILED)) {
 608					/* which hasn't failed yet, timeout */
 609					qc->err_mask |= AC_ERR_TIMEOUT;
 610					qc->flags |= ATA_QCFLAG_FAILED;
 611					nr_timedout++;
 612				}
 613			} else {
 614				/* Normal completion occurred after
 615				 * SCSI timeout but before this point.
 616				 * Successfully complete it.
 617				 */
 618				scmd->retries = scmd->allowed;
 619				scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
 620			}
 621		}
 622
 623		/* If we have timed out qcs.  They belong to EH from
 624		 * this point but the state of the controller is
 625		 * unknown.  Freeze the port to make sure the IRQ
 626		 * handler doesn't diddle with those qcs.  This must
 627		 * be done atomically w.r.t. setting QCFLAG_FAILED.
 628		 */
 629		if (nr_timedout)
 630			__ata_port_freeze(ap);
 631
 632
 633		/* initialize eh_tries */
 634		ap->eh_tries = ATA_EH_MAX_TRIES;
 635	}
 636	spin_unlock_irqrestore(ap->lock, flags);
 637
 638}
 639EXPORT_SYMBOL(ata_scsi_cmd_error_handler);
 640
 641/**
 642 * ata_scsi_port_error_handler - recover the port after the commands
 643 * @host:	SCSI host containing the port
 644 * @ap:		the ATA port
 645 *
 646 * Handle the recovery of the port @ap after all the commands
 647 * have been recovered.
 648 */
 649void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap)
 650{
 651	unsigned long flags;
 652
 653	/* invoke error handler */
 654	if (ap->ops->error_handler) {
 655		struct ata_link *link;
 656
 657		/* acquire EH ownership */
 658		ata_eh_acquire(ap);
 659 repeat:
 660		/* kill fast drain timer */
 661		del_timer_sync(&ap->fastdrain_timer);
 662
 663		/* process port resume request */
 664		ata_eh_handle_port_resume(ap);
 665
 666		/* fetch & clear EH info */
 667		spin_lock_irqsave(ap->lock, flags);
 668
 669		ata_for_each_link(link, ap, HOST_FIRST) {
 670			struct ata_eh_context *ehc = &link->eh_context;
 671			struct ata_device *dev;
 672
 673			memset(&link->eh_context, 0, sizeof(link->eh_context));
 674			link->eh_context.i = link->eh_info;
 675			memset(&link->eh_info, 0, sizeof(link->eh_info));
 676
 677			ata_for_each_dev(dev, link, ENABLED) {
 678				int devno = dev->devno;
 679
 680				ehc->saved_xfer_mode[devno] = dev->xfer_mode;
 681				if (ata_ncq_enabled(dev))
 682					ehc->saved_ncq_enabled |= 1 << devno;
 683			}
 684		}
 685
 686		ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
 687		ap->pflags &= ~ATA_PFLAG_EH_PENDING;
 688		ap->excl_link = NULL;	/* don't maintain exclusion over EH */
 689
 690		spin_unlock_irqrestore(ap->lock, flags);
 691
 692		/* invoke EH, skip if unloading or suspended */
 693		if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
 694			ap->ops->error_handler(ap);
 695		else {
 696			/* if unloading, commence suicide */
 697			if ((ap->pflags & ATA_PFLAG_UNLOADING) &&
 698			    !(ap->pflags & ATA_PFLAG_UNLOADED))
 699				ata_eh_unload(ap);
 700			ata_eh_finish(ap);
 701		}
 702
 703		/* process port suspend request */
 704		ata_eh_handle_port_suspend(ap);
 705
 706		/* Exception might have happened after ->error_handler
 707		 * recovered the port but before this point.  Repeat
 708		 * EH in such case.
 709		 */
 710		spin_lock_irqsave(ap->lock, flags);
 711
 712		if (ap->pflags & ATA_PFLAG_EH_PENDING) {
 713			if (--ap->eh_tries) {
 714				spin_unlock_irqrestore(ap->lock, flags);
 715				goto repeat;
 716			}
 717			ata_port_err(ap,
 718				     "EH pending after %d tries, giving up\n",
 719				     ATA_EH_MAX_TRIES);
 720			ap->pflags &= ~ATA_PFLAG_EH_PENDING;
 721		}
 722
 723		/* this run is complete, make sure EH info is clear */
 724		ata_for_each_link(link, ap, HOST_FIRST)
 725			memset(&link->eh_info, 0, sizeof(link->eh_info));
 726
 727		/* end eh (clear host_eh_scheduled) while holding
 728		 * ap->lock such that if exception occurs after this
 729		 * point but before EH completion, SCSI midlayer will
 730		 * re-initiate EH.
 731		 */
 732		ap->ops->end_eh(ap);
 733
 734		spin_unlock_irqrestore(ap->lock, flags);
 735		ata_eh_release(ap);
 736	} else {
 737		WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
 738		ap->ops->eng_timeout(ap);
 739	}
 740
 741	scsi_eh_flush_done_q(&ap->eh_done_q);
 742
 743	/* clean up */
 744	spin_lock_irqsave(ap->lock, flags);
 745
 746	if (ap->pflags & ATA_PFLAG_LOADING)
 747		ap->pflags &= ~ATA_PFLAG_LOADING;
 748	else if ((ap->pflags & ATA_PFLAG_SCSI_HOTPLUG) &&
 749		!(ap->flags & ATA_FLAG_SAS_HOST))
 750		schedule_delayed_work(&ap->hotplug_task, 0);
 751
 752	if (ap->pflags & ATA_PFLAG_RECOVERED)
 753		ata_port_info(ap, "EH complete\n");
 754
 755	ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
 756
 757	/* tell wait_eh that we're done */
 758	ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
 759	wake_up_all(&ap->eh_wait_q);
 760
 761	spin_unlock_irqrestore(ap->lock, flags);
 762}
 763EXPORT_SYMBOL_GPL(ata_scsi_port_error_handler);
 764
 765/**
 766 *	ata_port_wait_eh - Wait for the currently pending EH to complete
 767 *	@ap: Port to wait EH for
 768 *
 769 *	Wait until the currently pending EH is complete.
 770 *
 771 *	LOCKING:
 772 *	Kernel thread context (may sleep).
 773 */
 774void ata_port_wait_eh(struct ata_port *ap)
 775{
 776	unsigned long flags;
 777	DEFINE_WAIT(wait);
 778
 779 retry:
 780	spin_lock_irqsave(ap->lock, flags);
 781
 782	while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
 783		prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
 784		spin_unlock_irqrestore(ap->lock, flags);
 785		schedule();
 786		spin_lock_irqsave(ap->lock, flags);
 787	}
 788	finish_wait(&ap->eh_wait_q, &wait);
 789
 790	spin_unlock_irqrestore(ap->lock, flags);
 791
 792	/* make sure SCSI EH is complete */
 793	if (scsi_host_in_recovery(ap->scsi_host)) {
 794		ata_msleep(ap, 10);
 795		goto retry;
 796	}
 797}
 798EXPORT_SYMBOL_GPL(ata_port_wait_eh);
 799
 800static int ata_eh_nr_in_flight(struct ata_port *ap)
 801{
 802	struct ata_queued_cmd *qc;
 803	unsigned int tag;
 804	int nr = 0;
 805
 806	/* count only non-internal commands */
 807	ata_qc_for_each(ap, qc, tag) {
 808		if (qc)
 809			nr++;
 810	}
 811
 812	return nr;
 813}
 814
 815void ata_eh_fastdrain_timerfn(struct timer_list *t)
 816{
 817	struct ata_port *ap = from_timer(ap, t, fastdrain_timer);
 818	unsigned long flags;
 819	int cnt;
 820
 821	spin_lock_irqsave(ap->lock, flags);
 822
 823	cnt = ata_eh_nr_in_flight(ap);
 824
 825	/* are we done? */
 826	if (!cnt)
 827		goto out_unlock;
 828
 829	if (cnt == ap->fastdrain_cnt) {
 830		struct ata_queued_cmd *qc;
 831		unsigned int tag;
 832
 833		/* No progress during the last interval, tag all
 834		 * in-flight qcs as timed out and freeze the port.
 835		 */
 836		ata_qc_for_each(ap, qc, tag) {
 837			if (qc)
 838				qc->err_mask |= AC_ERR_TIMEOUT;
 839		}
 840
 841		ata_port_freeze(ap);
 842	} else {
 843		/* some qcs have finished, give it another chance */
 844		ap->fastdrain_cnt = cnt;
 845		ap->fastdrain_timer.expires =
 846			ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
 847		add_timer(&ap->fastdrain_timer);
 848	}
 849
 850 out_unlock:
 851	spin_unlock_irqrestore(ap->lock, flags);
 852}
 853
 854/**
 855 *	ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
 856 *	@ap: target ATA port
 857 *	@fastdrain: activate fast drain
 858 *
 859 *	Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
 860 *	is non-zero and EH wasn't pending before.  Fast drain ensures
 861 *	that EH kicks in in timely manner.
 862 *
 863 *	LOCKING:
 864 *	spin_lock_irqsave(host lock)
 865 */
 866static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
 867{
 868	int cnt;
 869
 870	/* already scheduled? */
 871	if (ap->pflags & ATA_PFLAG_EH_PENDING)
 872		return;
 873
 874	ap->pflags |= ATA_PFLAG_EH_PENDING;
 875
 876	if (!fastdrain)
 877		return;
 878
 879	/* do we have in-flight qcs? */
 880	cnt = ata_eh_nr_in_flight(ap);
 881	if (!cnt)
 882		return;
 883
 884	/* activate fast drain */
 885	ap->fastdrain_cnt = cnt;
 886	ap->fastdrain_timer.expires =
 887		ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
 888	add_timer(&ap->fastdrain_timer);
 889}
 890
 891/**
 892 *	ata_qc_schedule_eh - schedule qc for error handling
 893 *	@qc: command to schedule error handling for
 894 *
 895 *	Schedule error handling for @qc.  EH will kick in as soon as
 896 *	other commands are drained.
 897 *
 898 *	LOCKING:
 899 *	spin_lock_irqsave(host lock)
 900 */
 901void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
 902{
 903	struct ata_port *ap = qc->ap;
 904
 905	WARN_ON(!ap->ops->error_handler);
 906
 907	qc->flags |= ATA_QCFLAG_FAILED;
 908	ata_eh_set_pending(ap, 1);
 909
 910	/* The following will fail if timeout has already expired.
 911	 * ata_scsi_error() takes care of such scmds on EH entry.
 912	 * Note that ATA_QCFLAG_FAILED is unconditionally set after
 913	 * this function completes.
 914	 */
 915	blk_abort_request(qc->scsicmd->request);
 916}
 917
 918/**
 919 * ata_std_sched_eh - non-libsas ata_ports issue eh with this common routine
 920 * @ap: ATA port to schedule EH for
 921 *
 922 *	LOCKING: inherited from ata_port_schedule_eh
 923 *	spin_lock_irqsave(host lock)
 924 */
 925void ata_std_sched_eh(struct ata_port *ap)
 926{
 927	WARN_ON(!ap->ops->error_handler);
 928
 929	if (ap->pflags & ATA_PFLAG_INITIALIZING)
 930		return;
 931
 932	ata_eh_set_pending(ap, 1);
 933	scsi_schedule_eh(ap->scsi_host);
 934
 935	DPRINTK("port EH scheduled\n");
 936}
 937EXPORT_SYMBOL_GPL(ata_std_sched_eh);
 938
 939/**
 940 * ata_std_end_eh - non-libsas ata_ports complete eh with this common routine
 941 * @ap: ATA port to end EH for
 942 *
 943 * In the libata object model there is a 1:1 mapping of ata_port to
 944 * shost, so host fields can be directly manipulated under ap->lock, in
 945 * the libsas case we need to hold a lock at the ha->level to coordinate
 946 * these events.
 947 *
 948 *	LOCKING:
 949 *	spin_lock_irqsave(host lock)
 950 */
 951void ata_std_end_eh(struct ata_port *ap)
 952{
 953	struct Scsi_Host *host = ap->scsi_host;
 954
 955	host->host_eh_scheduled = 0;
 956}
 957EXPORT_SYMBOL(ata_std_end_eh);
 958
 959
 960/**
 961 *	ata_port_schedule_eh - schedule error handling without a qc
 962 *	@ap: ATA port to schedule EH for
 963 *
 964 *	Schedule error handling for @ap.  EH will kick in as soon as
 965 *	all commands are drained.
 966 *
 967 *	LOCKING:
 968 *	spin_lock_irqsave(host lock)
 969 */
 970void ata_port_schedule_eh(struct ata_port *ap)
 971{
 972	/* see: ata_std_sched_eh, unless you know better */
 973	ap->ops->sched_eh(ap);
 974}
 975EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
 976
 977static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
 978{
 979	struct ata_queued_cmd *qc;
 980	int tag, nr_aborted = 0;
 981
 982	WARN_ON(!ap->ops->error_handler);
 983
 984	/* we're gonna abort all commands, no need for fast drain */
 985	ata_eh_set_pending(ap, 0);
 986
 987	/* include internal tag in iteration */
 988	ata_qc_for_each_with_internal(ap, qc, tag) {
 989		if (qc && (!link || qc->dev->link == link)) {
 990			qc->flags |= ATA_QCFLAG_FAILED;
 991			ata_qc_complete(qc);
 992			nr_aborted++;
 993		}
 994	}
 995
 996	if (!nr_aborted)
 997		ata_port_schedule_eh(ap);
 998
 999	return nr_aborted;
1000}
1001
1002/**
1003 *	ata_link_abort - abort all qc's on the link
1004 *	@link: ATA link to abort qc's for
1005 *
1006 *	Abort all active qc's active on @link and schedule EH.
1007 *
1008 *	LOCKING:
1009 *	spin_lock_irqsave(host lock)
1010 *
1011 *	RETURNS:
1012 *	Number of aborted qc's.
1013 */
1014int ata_link_abort(struct ata_link *link)
1015{
1016	return ata_do_link_abort(link->ap, link);
1017}
1018EXPORT_SYMBOL_GPL(ata_link_abort);
1019
1020/**
1021 *	ata_port_abort - abort all qc's on the port
1022 *	@ap: ATA port to abort qc's for
1023 *
1024 *	Abort all active qc's of @ap and schedule EH.
1025 *
1026 *	LOCKING:
1027 *	spin_lock_irqsave(host_set lock)
1028 *
1029 *	RETURNS:
1030 *	Number of aborted qc's.
1031 */
1032int ata_port_abort(struct ata_port *ap)
1033{
1034	return ata_do_link_abort(ap, NULL);
1035}
1036EXPORT_SYMBOL_GPL(ata_port_abort);
1037
1038/**
1039 *	__ata_port_freeze - freeze port
1040 *	@ap: ATA port to freeze
1041 *
1042 *	This function is called when HSM violation or some other
1043 *	condition disrupts normal operation of the port.  Frozen port
1044 *	is not allowed to perform any operation until the port is
1045 *	thawed, which usually follows a successful reset.
1046 *
1047 *	ap->ops->freeze() callback can be used for freezing the port
1048 *	hardware-wise (e.g. mask interrupt and stop DMA engine).  If a
1049 *	port cannot be frozen hardware-wise, the interrupt handler
1050 *	must ack and clear interrupts unconditionally while the port
1051 *	is frozen.
1052 *
1053 *	LOCKING:
1054 *	spin_lock_irqsave(host lock)
1055 */
1056static void __ata_port_freeze(struct ata_port *ap)
1057{
1058	WARN_ON(!ap->ops->error_handler);
1059
1060	if (ap->ops->freeze)
1061		ap->ops->freeze(ap);
1062
1063	ap->pflags |= ATA_PFLAG_FROZEN;
1064
1065	DPRINTK("ata%u port frozen\n", ap->print_id);
1066}
1067
1068/**
1069 *	ata_port_freeze - abort & freeze port
1070 *	@ap: ATA port to freeze
1071 *
1072 *	Abort and freeze @ap.  The freeze operation must be called
1073 *	first, because some hardware requires special operations
1074 *	before the taskfile registers are accessible.
1075 *
1076 *	LOCKING:
1077 *	spin_lock_irqsave(host lock)
1078 *
1079 *	RETURNS:
1080 *	Number of aborted commands.
1081 */
1082int ata_port_freeze(struct ata_port *ap)
1083{
1084	int nr_aborted;
1085
1086	WARN_ON(!ap->ops->error_handler);
1087
1088	__ata_port_freeze(ap);
1089	nr_aborted = ata_port_abort(ap);
1090
1091	return nr_aborted;
1092}
1093EXPORT_SYMBOL_GPL(ata_port_freeze);
1094
1095/**
1096 *	ata_eh_freeze_port - EH helper to freeze port
1097 *	@ap: ATA port to freeze
1098 *
1099 *	Freeze @ap.
1100 *
1101 *	LOCKING:
1102 *	None.
1103 */
1104void ata_eh_freeze_port(struct ata_port *ap)
1105{
1106	unsigned long flags;
1107
1108	if (!ap->ops->error_handler)
1109		return;
1110
1111	spin_lock_irqsave(ap->lock, flags);
1112	__ata_port_freeze(ap);
1113	spin_unlock_irqrestore(ap->lock, flags);
1114}
1115EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
1116
1117/**
1118 *	ata_port_thaw_port - EH helper to thaw port
1119 *	@ap: ATA port to thaw
1120 *
1121 *	Thaw frozen port @ap.
1122 *
1123 *	LOCKING:
1124 *	None.
1125 */
1126void ata_eh_thaw_port(struct ata_port *ap)
1127{
1128	unsigned long flags;
1129
1130	if (!ap->ops->error_handler)
1131		return;
1132
1133	spin_lock_irqsave(ap->lock, flags);
1134
1135	ap->pflags &= ~ATA_PFLAG_FROZEN;
1136
1137	if (ap->ops->thaw)
1138		ap->ops->thaw(ap);
1139
1140	spin_unlock_irqrestore(ap->lock, flags);
1141
1142	DPRINTK("ata%u port thawed\n", ap->print_id);
1143}
1144
1145static void ata_eh_scsidone(struct scsi_cmnd *scmd)
1146{
1147	/* nada */
1148}
1149
1150static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
1151{
1152	struct ata_port *ap = qc->ap;
1153	struct scsi_cmnd *scmd = qc->scsicmd;
1154	unsigned long flags;
1155
1156	spin_lock_irqsave(ap->lock, flags);
1157	qc->scsidone = ata_eh_scsidone;
1158	__ata_qc_complete(qc);
1159	WARN_ON(ata_tag_valid(qc->tag));
1160	spin_unlock_irqrestore(ap->lock, flags);
1161
1162	scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
1163}
1164
1165/**
1166 *	ata_eh_qc_complete - Complete an active ATA command from EH
1167 *	@qc: Command to complete
1168 *
1169 *	Indicate to the mid and upper layers that an ATA command has
1170 *	completed.  To be used from EH.
1171 */
1172void ata_eh_qc_complete(struct ata_queued_cmd *qc)
1173{
1174	struct scsi_cmnd *scmd = qc->scsicmd;
1175	scmd->retries = scmd->allowed;
1176	__ata_eh_qc_complete(qc);
1177}
1178
1179/**
1180 *	ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
1181 *	@qc: Command to retry
1182 *
1183 *	Indicate to the mid and upper layers that an ATA command
1184 *	should be retried.  To be used from EH.
1185 *
1186 *	SCSI midlayer limits the number of retries to scmd->allowed.
1187 *	scmd->allowed is incremented for commands which get retried
1188 *	due to unrelated failures (qc->err_mask is zero).
1189 */
1190void ata_eh_qc_retry(struct ata_queued_cmd *qc)
1191{
1192	struct scsi_cmnd *scmd = qc->scsicmd;
1193	if (!qc->err_mask)
1194		scmd->allowed++;
1195	__ata_eh_qc_complete(qc);
1196}
1197
1198/**
1199 *	ata_dev_disable - disable ATA device
1200 *	@dev: ATA device to disable
1201 *
1202 *	Disable @dev.
1203 *
1204 *	Locking:
1205 *	EH context.
1206 */
1207void ata_dev_disable(struct ata_device *dev)
1208{
1209	if (!ata_dev_enabled(dev))
1210		return;
1211
1212	if (ata_msg_drv(dev->link->ap))
1213		ata_dev_warn(dev, "disabled\n");
1214	ata_acpi_on_disable(dev);
1215	ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET);
1216	dev->class++;
1217
1218	/* From now till the next successful probe, ering is used to
1219	 * track probe failures.  Clear accumulated device error info.
1220	 */
1221	ata_ering_clear(&dev->ering);
1222}
1223EXPORT_SYMBOL_GPL(ata_dev_disable);
1224
1225/**
1226 *	ata_eh_detach_dev - detach ATA device
1227 *	@dev: ATA device to detach
1228 *
1229 *	Detach @dev.
1230 *
1231 *	LOCKING:
1232 *	None.
1233 */
1234void ata_eh_detach_dev(struct ata_device *dev)
1235{
1236	struct ata_link *link = dev->link;
1237	struct ata_port *ap = link->ap;
1238	struct ata_eh_context *ehc = &link->eh_context;
1239	unsigned long flags;
1240
1241	ata_dev_disable(dev);
1242
1243	spin_lock_irqsave(ap->lock, flags);
1244
1245	dev->flags &= ~ATA_DFLAG_DETACH;
1246
1247	if (ata_scsi_offline_dev(dev)) {
1248		dev->flags |= ATA_DFLAG_DETACHED;
1249		ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
1250	}
1251
1252	/* clear per-dev EH info */
1253	ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
1254	ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
1255	ehc->saved_xfer_mode[dev->devno] = 0;
1256	ehc->saved_ncq_enabled &= ~(1 << dev->devno);
1257
1258	spin_unlock_irqrestore(ap->lock, flags);
1259}
1260
1261/**
1262 *	ata_eh_about_to_do - about to perform eh_action
1263 *	@link: target ATA link
1264 *	@dev: target ATA dev for per-dev action (can be NULL)
1265 *	@action: action about to be performed
1266 *
1267 *	Called just before performing EH actions to clear related bits
1268 *	in @link->eh_info such that eh actions are not unnecessarily
1269 *	repeated.
1270 *
1271 *	LOCKING:
1272 *	None.
1273 */
1274void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
1275			unsigned int action)
1276{
1277	struct ata_port *ap = link->ap;
1278	struct ata_eh_info *ehi = &link->eh_info;
1279	struct ata_eh_context *ehc = &link->eh_context;
1280	unsigned long flags;
1281
1282	spin_lock_irqsave(ap->lock, flags);
1283
1284	ata_eh_clear_action(link, dev, ehi, action);
1285
1286	/* About to take EH action, set RECOVERED.  Ignore actions on
1287	 * slave links as master will do them again.
1288	 */
1289	if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link)
1290		ap->pflags |= ATA_PFLAG_RECOVERED;
1291
1292	spin_unlock_irqrestore(ap->lock, flags);
1293}
1294
1295/**
1296 *	ata_eh_done - EH action complete
1297 *	@link: ATA link for which EH actions are complete
1298 *	@dev: target ATA dev for per-dev action (can be NULL)
1299 *	@action: action just completed
1300 *
1301 *	Called right after performing EH actions to clear related bits
1302 *	in @link->eh_context.
1303 *
1304 *	LOCKING:
1305 *	None.
1306 */
1307void ata_eh_done(struct ata_link *link, struct ata_device *dev,
1308		 unsigned int action)
1309{
1310	struct ata_eh_context *ehc = &link->eh_context;
1311
1312	ata_eh_clear_action(link, dev, &ehc->i, action);
1313}
1314
1315/**
1316 *	ata_err_string - convert err_mask to descriptive string
1317 *	@err_mask: error mask to convert to string
1318 *
1319 *	Convert @err_mask to descriptive string.  Errors are
1320 *	prioritized according to severity and only the most severe
1321 *	error is reported.
1322 *
1323 *	LOCKING:
1324 *	None.
1325 *
1326 *	RETURNS:
1327 *	Descriptive string for @err_mask
1328 */
1329static const char *ata_err_string(unsigned int err_mask)
1330{
1331	if (err_mask & AC_ERR_HOST_BUS)
1332		return "host bus error";
1333	if (err_mask & AC_ERR_ATA_BUS)
1334		return "ATA bus error";
1335	if (err_mask & AC_ERR_TIMEOUT)
1336		return "timeout";
1337	if (err_mask & AC_ERR_HSM)
1338		return "HSM violation";
1339	if (err_mask & AC_ERR_SYSTEM)
1340		return "internal error";
1341	if (err_mask & AC_ERR_MEDIA)
1342		return "media error";
1343	if (err_mask & AC_ERR_INVALID)
1344		return "invalid argument";
1345	if (err_mask & AC_ERR_DEV)
1346		return "device error";
1347	if (err_mask & AC_ERR_NCQ)
1348		return "NCQ error";
1349	if (err_mask & AC_ERR_NODEV_HINT)
1350		return "Polling detection error";
1351	return "unknown error";
1352}
1353
1354/**
1355 *	atapi_eh_tur - perform ATAPI TEST_UNIT_READY
1356 *	@dev: target ATAPI device
1357 *	@r_sense_key: out parameter for sense_key
1358 *
1359 *	Perform ATAPI TEST_UNIT_READY.
1360 *
1361 *	LOCKING:
1362 *	EH context (may sleep).
1363 *
1364 *	RETURNS:
1365 *	0 on success, AC_ERR_* mask on failure.
1366 */
1367unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
1368{
1369	u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 };
1370	struct ata_taskfile tf;
1371	unsigned int err_mask;
1372
1373	ata_tf_init(dev, &tf);
1374
1375	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1376	tf.command = ATA_CMD_PACKET;
1377	tf.protocol = ATAPI_PROT_NODATA;
1378
1379	err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
1380	if (err_mask == AC_ERR_DEV)
1381		*r_sense_key = tf.feature >> 4;
1382	return err_mask;
1383}
1384
1385/**
1386 *	ata_eh_request_sense - perform REQUEST_SENSE_DATA_EXT
1387 *	@qc: qc to perform REQUEST_SENSE_SENSE_DATA_EXT to
1388 *	@cmd: scsi command for which the sense code should be set
1389 *
1390 *	Perform REQUEST_SENSE_DATA_EXT after the device reported CHECK
1391 *	SENSE.  This function is an EH helper.
1392 *
1393 *	LOCKING:
1394 *	Kernel thread context (may sleep).
1395 */
1396static void ata_eh_request_sense(struct ata_queued_cmd *qc,
1397				 struct scsi_cmnd *cmd)
1398{
1399	struct ata_device *dev = qc->dev;
1400	struct ata_taskfile tf;
1401	unsigned int err_mask;
1402
1403	if (qc->ap->pflags & ATA_PFLAG_FROZEN) {
1404		ata_dev_warn(dev, "sense data available but port frozen\n");
1405		return;
1406	}
1407
1408	if (!cmd || qc->flags & ATA_QCFLAG_SENSE_VALID)
1409		return;
1410
1411	if (!ata_id_sense_reporting_enabled(dev->id)) {
1412		ata_dev_warn(qc->dev, "sense data reporting disabled\n");
1413		return;
1414	}
1415
1416	DPRINTK("ATA request sense\n");
1417
1418	ata_tf_init(dev, &tf);
1419	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1420	tf.flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
1421	tf.command = ATA_CMD_REQ_SENSE_DATA;
1422	tf.protocol = ATA_PROT_NODATA;
1423
1424	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1425	/* Ignore err_mask; ATA_ERR might be set */
1426	if (tf.command & ATA_SENSE) {
1427		ata_scsi_set_sense(dev, cmd, tf.lbah, tf.lbam, tf.lbal);
1428		qc->flags |= ATA_QCFLAG_SENSE_VALID;
1429	} else {
1430		ata_dev_warn(dev, "request sense failed stat %02x emask %x\n",
1431			     tf.command, err_mask);
1432	}
1433}
1434
1435/**
1436 *	atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
1437 *	@dev: device to perform REQUEST_SENSE to
1438 *	@sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
1439 *	@dfl_sense_key: default sense key to use
1440 *
1441 *	Perform ATAPI REQUEST_SENSE after the device reported CHECK
1442 *	SENSE.  This function is EH helper.
1443 *
1444 *	LOCKING:
1445 *	Kernel thread context (may sleep).
1446 *
1447 *	RETURNS:
1448 *	0 on success, AC_ERR_* mask on failure
1449 */
1450unsigned int atapi_eh_request_sense(struct ata_device *dev,
1451					   u8 *sense_buf, u8 dfl_sense_key)
1452{
1453	u8 cdb[ATAPI_CDB_LEN] =
1454		{ REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 };
1455	struct ata_port *ap = dev->link->ap;
1456	struct ata_taskfile tf;
1457
1458	DPRINTK("ATAPI request sense\n");
1459
1460	memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
1461
1462	/* initialize sense_buf with the error register,
1463	 * for the case where they are -not- overwritten
1464	 */
1465	sense_buf[0] = 0x70;
1466	sense_buf[2] = dfl_sense_key;
1467
1468	/* some devices time out if garbage left in tf */
1469	ata_tf_init(dev, &tf);
1470
1471	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1472	tf.command = ATA_CMD_PACKET;
1473
1474	/* is it pointless to prefer PIO for "safety reasons"? */
1475	if (ap->flags & ATA_FLAG_PIO_DMA) {
1476		tf.protocol = ATAPI_PROT_DMA;
1477		tf.feature |= ATAPI_PKT_DMA;
1478	} else {
1479		tf.protocol = ATAPI_PROT_PIO;
1480		tf.lbam = SCSI_SENSE_BUFFERSIZE;
1481		tf.lbah = 0;
1482	}
1483
1484	return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
1485				 sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
1486}
1487
1488/**
1489 *	ata_eh_analyze_serror - analyze SError for a failed port
1490 *	@link: ATA link to analyze SError for
1491 *
1492 *	Analyze SError if available and further determine cause of
1493 *	failure.
1494 *
1495 *	LOCKING:
1496 *	None.
1497 */
1498static void ata_eh_analyze_serror(struct ata_link *link)
1499{
1500	struct ata_eh_context *ehc = &link->eh_context;
1501	u32 serror = ehc->i.serror;
1502	unsigned int err_mask = 0, action = 0;
1503	u32 hotplug_mask;
1504
1505	if (serror & (SERR_PERSISTENT | SERR_DATA)) {
1506		err_mask |= AC_ERR_ATA_BUS;
1507		action |= ATA_EH_RESET;
1508	}
1509	if (serror & SERR_PROTOCOL) {
1510		err_mask |= AC_ERR_HSM;
1511		action |= ATA_EH_RESET;
1512	}
1513	if (serror & SERR_INTERNAL) {
1514		err_mask |= AC_ERR_SYSTEM;
1515		action |= ATA_EH_RESET;
1516	}
1517
1518	/* Determine whether a hotplug event has occurred.  Both
1519	 * SError.N/X are considered hotplug events for enabled or
1520	 * host links.  For disabled PMP links, only N bit is
1521	 * considered as X bit is left at 1 for link plugging.
1522	 */
1523	if (link->lpm_policy > ATA_LPM_MAX_POWER)
1524		hotplug_mask = 0;	/* hotplug doesn't work w/ LPM */
1525	else if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
1526		hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
1527	else
1528		hotplug_mask = SERR_PHYRDY_CHG;
1529
1530	if (serror & hotplug_mask)
1531		ata_ehi_hotplugged(&ehc->i);
1532
1533	ehc->i.err_mask |= err_mask;
1534	ehc->i.action |= action;
1535}
1536
1537/**
1538 *	ata_eh_analyze_tf - analyze taskfile of a failed qc
1539 *	@qc: qc to analyze
1540 *	@tf: Taskfile registers to analyze
1541 *
1542 *	Analyze taskfile of @qc and further determine cause of
1543 *	failure.  This function also requests ATAPI sense data if
1544 *	available.
1545 *
1546 *	LOCKING:
1547 *	Kernel thread context (may sleep).
1548 *
1549 *	RETURNS:
1550 *	Determined recovery action
1551 */
1552static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
1553				      const struct ata_taskfile *tf)
1554{
1555	unsigned int tmp, action = 0;
1556	u8 stat = tf->command, err = tf->feature;
1557
1558	if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
1559		qc->err_mask |= AC_ERR_HSM;
1560		return ATA_EH_RESET;
1561	}
1562
1563	if (stat & (ATA_ERR | ATA_DF)) {
1564		qc->err_mask |= AC_ERR_DEV;
1565		/*
1566		 * Sense data reporting does not work if the
1567		 * device fault bit is set.
1568		 */
1569		if (stat & ATA_DF)
1570			stat &= ~ATA_SENSE;
1571	} else {
1572		return 0;
1573	}
1574
1575	switch (qc->dev->class) {
1576	case ATA_DEV_ZAC:
1577		if (stat & ATA_SENSE)
1578			ata_eh_request_sense(qc, qc->scsicmd);
1579		/* fall through */
1580	case ATA_DEV_ATA:
1581		if (err & ATA_ICRC)
1582			qc->err_mask |= AC_ERR_ATA_BUS;
1583		if (err & (ATA_UNC | ATA_AMNF))
1584			qc->err_mask |= AC_ERR_MEDIA;
1585		if (err & ATA_IDNF)
1586			qc->err_mask |= AC_ERR_INVALID;
1587		break;
1588
1589	case ATA_DEV_ATAPI:
1590		if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
1591			tmp = atapi_eh_request_sense(qc->dev,
1592						qc->scsicmd->sense_buffer,
1593						qc->result_tf.feature >> 4);
1594			if (!tmp)
1595				qc->flags |= ATA_QCFLAG_SENSE_VALID;
1596			else
1597				qc->err_mask |= tmp;
1598		}
1599	}
1600
1601	if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
1602		int ret = scsi_check_sense(qc->scsicmd);
1603		/*
1604		 * SUCCESS here means that the sense code could be
1605		 * evaluated and should be passed to the upper layers
1606		 * for correct evaluation.
1607		 * FAILED means the sense code could not be interpreted
1608		 * and the device would need to be reset.
1609		 * NEEDS_RETRY and ADD_TO_MLQUEUE means that the
1610		 * command would need to be retried.
1611		 */
1612		if (ret == NEEDS_RETRY || ret == ADD_TO_MLQUEUE) {
1613			qc->flags |= ATA_QCFLAG_RETRY;
1614			qc->err_mask |= AC_ERR_OTHER;
1615		} else if (ret != SUCCESS) {
1616			qc->err_mask |= AC_ERR_HSM;
1617		}
1618	}
1619	if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
1620		action |= ATA_EH_RESET;
1621
1622	return action;
1623}
1624
1625static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
1626				   int *xfer_ok)
1627{
1628	int base = 0;
1629
1630	if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
1631		*xfer_ok = 1;
1632
1633	if (!*xfer_ok)
1634		base = ATA_ECAT_DUBIOUS_NONE;
1635
1636	if (err_mask & AC_ERR_ATA_BUS)
1637		return base + ATA_ECAT_ATA_BUS;
1638
1639	if (err_mask & AC_ERR_TIMEOUT)
1640		return base + ATA_ECAT_TOUT_HSM;
1641
1642	if (eflags & ATA_EFLAG_IS_IO) {
1643		if (err_mask & AC_ERR_HSM)
1644			return base + ATA_ECAT_TOUT_HSM;
1645		if ((err_mask &
1646		     (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
1647			return base + ATA_ECAT_UNK_DEV;
1648	}
1649
1650	return 0;
1651}
1652
1653struct speed_down_verdict_arg {
1654	u64 since;
1655	int xfer_ok;
1656	int nr_errors[ATA_ECAT_NR];
1657};
1658
1659static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
1660{
1661	struct speed_down_verdict_arg *arg = void_arg;
1662	int cat;
1663
1664	if ((ent->eflags & ATA_EFLAG_OLD_ER) || (ent->timestamp < arg->since))
1665		return -1;
1666
1667	cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
1668				      &arg->xfer_ok);
1669	arg->nr_errors[cat]++;
1670
1671	return 0;
1672}
1673
1674/**
1675 *	ata_eh_speed_down_verdict - Determine speed down verdict
1676 *	@dev: Device of interest
1677 *
1678 *	This function examines error ring of @dev and determines
1679 *	whether NCQ needs to be turned off, transfer speed should be
1680 *	stepped down, or falling back to PIO is necessary.
1681 *
1682 *	ECAT_ATA_BUS	: ATA_BUS error for any command
1683 *
1684 *	ECAT_TOUT_HSM	: TIMEOUT for any command or HSM violation for
1685 *			  IO commands
1686 *
1687 *	ECAT_UNK_DEV	: Unknown DEV error for IO commands
1688 *
1689 *	ECAT_DUBIOUS_*	: Identical to above three but occurred while
1690 *			  data transfer hasn't been verified.
1691 *
1692 *	Verdicts are
1693 *
1694 *	NCQ_OFF		: Turn off NCQ.
1695 *
1696 *	SPEED_DOWN	: Speed down transfer speed but don't fall back
1697 *			  to PIO.
1698 *
1699 *	FALLBACK_TO_PIO	: Fall back to PIO.
1700 *
1701 *	Even if multiple verdicts are returned, only one action is
1702 *	taken per error.  An action triggered by non-DUBIOUS errors
1703 *	clears ering, while one triggered by DUBIOUS_* errors doesn't.
1704 *	This is to expedite speed down decisions right after device is
1705 *	initially configured.
1706 *
1707 *	The following are speed down rules.  #1 and #2 deal with
1708 *	DUBIOUS errors.
1709 *
1710 *	1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors
1711 *	   occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO.
1712 *
1713 *	2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors
1714 *	   occurred during last 5 mins, NCQ_OFF.
1715 *
1716 *	3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
1717 *	   occurred during last 5 mins, FALLBACK_TO_PIO
1718 *
1719 *	4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
1720 *	   during last 10 mins, NCQ_OFF.
1721 *
1722 *	5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6
1723 *	   UNK_DEV errors occurred during last 10 mins, SPEED_DOWN.
1724 *
1725 *	LOCKING:
1726 *	Inherited from caller.
1727 *
1728 *	RETURNS:
1729 *	OR of ATA_EH_SPDN_* flags.
1730 */
1731static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
1732{
1733	const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
1734	u64 j64 = get_jiffies_64();
1735	struct speed_down_verdict_arg arg;
1736	unsigned int verdict = 0;
1737
1738	/* scan past 5 mins of error history */
1739	memset(&arg, 0, sizeof(arg));
1740	arg.since = j64 - min(j64, j5mins);
1741	ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1742
1743	if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
1744	    arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
1745		verdict |= ATA_EH_SPDN_SPEED_DOWN |
1746			ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
1747
1748	if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
1749	    arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
1750		verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
1751
1752	if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1753	    arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1754	    arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
1755		verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
1756
1757	/* scan past 10 mins of error history */
1758	memset(&arg, 0, sizeof(arg));
1759	arg.since = j64 - min(j64, j10mins);
1760	ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1761
1762	if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1763	    arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
1764		verdict |= ATA_EH_SPDN_NCQ_OFF;
1765
1766	if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1767	    arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
1768	    arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
1769		verdict |= ATA_EH_SPDN_SPEED_DOWN;
1770
1771	return verdict;
1772}
1773
1774/**
1775 *	ata_eh_speed_down - record error and speed down if necessary
1776 *	@dev: Failed device
1777 *	@eflags: mask of ATA_EFLAG_* flags
1778 *	@err_mask: err_mask of the error
1779 *
1780 *	Record error and examine error history to determine whether
1781 *	adjusting transmission speed is necessary.  It also sets
1782 *	transmission limits appropriately if such adjustment is
1783 *	necessary.
1784 *
1785 *	LOCKING:
1786 *	Kernel thread context (may sleep).
1787 *
1788 *	RETURNS:
1789 *	Determined recovery action.
1790 */
1791static unsigned int ata_eh_speed_down(struct ata_device *dev,
1792				unsigned int eflags, unsigned int err_mask)
1793{
1794	struct ata_link *link = ata_dev_phys_link(dev);
1795	int xfer_ok = 0;
1796	unsigned int verdict;
1797	unsigned int action = 0;
1798
1799	/* don't bother if Cat-0 error */
1800	if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
1801		return 0;
1802
1803	/* record error and determine whether speed down is necessary */
1804	ata_ering_record(&dev->ering, eflags, err_mask);
1805	verdict = ata_eh_speed_down_verdict(dev);
1806
1807	/* turn off NCQ? */
1808	if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
1809	    (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
1810			   ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
1811		dev->flags |= ATA_DFLAG_NCQ_OFF;
1812		ata_dev_warn(dev, "NCQ disabled due to excessive errors\n");
1813		goto done;
1814	}
1815
1816	/* speed down? */
1817	if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
1818		/* speed down SATA link speed if possible */
1819		if (sata_down_spd_limit(link, 0) == 0) {
1820			action |= ATA_EH_RESET;
1821			goto done;
1822		}
1823
1824		/* lower transfer mode */
1825		if (dev->spdn_cnt < 2) {
1826			static const int dma_dnxfer_sel[] =
1827				{ ATA_DNXFER_DMA, ATA_DNXFER_40C };
1828			static const int pio_dnxfer_sel[] =
1829				{ ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
1830			int sel;
1831
1832			if (dev->xfer_shift != ATA_SHIFT_PIO)
1833				sel = dma_dnxfer_sel[dev->spdn_cnt];
1834			else
1835				sel = pio_dnxfer_sel[dev->spdn_cnt];
1836
1837			dev->spdn_cnt++;
1838
1839			if (ata_down_xfermask_limit(dev, sel) == 0) {
1840				action |= ATA_EH_RESET;
1841				goto done;
1842			}
1843		}
1844	}
1845
1846	/* Fall back to PIO?  Slowing down to PIO is meaningless for
1847	 * SATA ATA devices.  Consider it only for PATA and SATAPI.
1848	 */
1849	if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
1850	    (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) &&
1851	    (dev->xfer_shift != ATA_SHIFT_PIO)) {
1852		if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
1853			dev->spdn_cnt = 0;
1854			action |= ATA_EH_RESET;
1855			goto done;
1856		}
1857	}
1858
1859	return 0;
1860 done:
1861	/* device has been slowed down, blow error history */
1862	if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS))
1863		ata_ering_clear(&dev->ering);
1864	return action;
1865}
1866
1867/**
1868 *	ata_eh_worth_retry - analyze error and decide whether to retry
1869 *	@qc: qc to possibly retry
1870 *
1871 *	Look at the cause of the error and decide if a retry
1872 * 	might be useful or not.  We don't want to retry media errors
1873 *	because the drive itself has probably already taken 10-30 seconds
1874 *	doing its own internal retries before reporting the failure.
1875 */
1876static inline int ata_eh_worth_retry(struct ata_queued_cmd *qc)
1877{
1878	if (qc->err_mask & AC_ERR_MEDIA)
1879		return 0;	/* don't retry media errors */
1880	if (qc->flags & ATA_QCFLAG_IO)
1881		return 1;	/* otherwise retry anything from fs stack */
1882	if (qc->err_mask & AC_ERR_INVALID)
1883		return 0;	/* don't retry these */
1884	return qc->err_mask != AC_ERR_DEV;  /* retry if not dev error */
1885}
1886
1887/**
1888 *      ata_eh_quiet - check if we need to be quiet about a command error
1889 *      @qc: qc to check
1890 *
1891 *      Look at the qc flags anbd its scsi command request flags to determine
1892 *      if we need to be quiet about the command failure.
1893 */
1894static inline bool ata_eh_quiet(struct ata_queued_cmd *qc)
1895{
1896	if (qc->scsicmd &&
1897	    qc->scsicmd->request->rq_flags & RQF_QUIET)
1898		qc->flags |= ATA_QCFLAG_QUIET;
1899	return qc->flags & ATA_QCFLAG_QUIET;
1900}
1901
1902/**
1903 *	ata_eh_link_autopsy - analyze error and determine recovery action
1904 *	@link: host link to perform autopsy on
1905 *
1906 *	Analyze why @link failed and determine which recovery actions
1907 *	are needed.  This function also sets more detailed AC_ERR_*
1908 *	values and fills sense data for ATAPI CHECK SENSE.
1909 *
1910 *	LOCKING:
1911 *	Kernel thread context (may sleep).
1912 */
1913static void ata_eh_link_autopsy(struct ata_link *link)
1914{
1915	struct ata_port *ap = link->ap;
1916	struct ata_eh_context *ehc = &link->eh_context;
1917	struct ata_queued_cmd *qc;
1918	struct ata_device *dev;
1919	unsigned int all_err_mask = 0, eflags = 0;
1920	

Large files files are truncated, but you can click here to view the full file