xref: /openbmc/linux/drivers/ata/libata-eh.c (revision 305d2a1ab137d11d573319c315748a87060fe82d)
1c6fd2807SJeff Garzik /*
2c6fd2807SJeff Garzik  *  libata-eh.c - libata error handling
3c6fd2807SJeff Garzik  *
4c6fd2807SJeff Garzik  *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
5c6fd2807SJeff Garzik  *    		    Please ALWAYS copy linux-ide@vger.kernel.org
6c6fd2807SJeff Garzik  *		    on emails.
7c6fd2807SJeff Garzik  *
8c6fd2807SJeff Garzik  *  Copyright 2006 Tejun Heo <htejun@gmail.com>
9c6fd2807SJeff Garzik  *
10c6fd2807SJeff Garzik  *
11c6fd2807SJeff Garzik  *  This program is free software; you can redistribute it and/or
12c6fd2807SJeff Garzik  *  modify it under the terms of the GNU General Public License as
13c6fd2807SJeff Garzik  *  published by the Free Software Foundation; either version 2, or
14c6fd2807SJeff Garzik  *  (at your option) any later version.
15c6fd2807SJeff Garzik  *
16c6fd2807SJeff Garzik  *  This program is distributed in the hope that it will be useful,
17c6fd2807SJeff Garzik  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18c6fd2807SJeff Garzik  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19c6fd2807SJeff Garzik  *  General Public License for more details.
20c6fd2807SJeff Garzik  *
21c6fd2807SJeff Garzik  *  You should have received a copy of the GNU General Public License
22c6fd2807SJeff Garzik  *  along with this program; see the file COPYING.  If not, write to
23c6fd2807SJeff Garzik  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
24c6fd2807SJeff Garzik  *  USA.
25c6fd2807SJeff Garzik  *
26c6fd2807SJeff Garzik  *
27c6fd2807SJeff Garzik  *  libata documentation is available via 'make {ps|pdf}docs',
28c6fd2807SJeff Garzik  *  as Documentation/DocBook/libata.*
29c6fd2807SJeff Garzik  *
30c6fd2807SJeff Garzik  *  Hardware documentation available from http://www.t13.org/ and
31c6fd2807SJeff Garzik  *  http://www.sata-io.org/
32c6fd2807SJeff Garzik  *
33c6fd2807SJeff Garzik  */
34c6fd2807SJeff Garzik 
35c6fd2807SJeff Garzik #include <linux/kernel.h>
362855568bSJeff Garzik #include <linux/pci.h>
37c6fd2807SJeff Garzik #include <scsi/scsi.h>
38c6fd2807SJeff Garzik #include <scsi/scsi_host.h>
39c6fd2807SJeff Garzik #include <scsi/scsi_eh.h>
40c6fd2807SJeff Garzik #include <scsi/scsi_device.h>
41c6fd2807SJeff Garzik #include <scsi/scsi_cmnd.h>
42c6fd2807SJeff Garzik #include "../scsi/scsi_transport_api.h"
43c6fd2807SJeff Garzik 
44c6fd2807SJeff Garzik #include <linux/libata.h>
45c6fd2807SJeff Garzik 
46c6fd2807SJeff Garzik #include "libata.h"
47c6fd2807SJeff Garzik 
487d47e8d4STejun Heo enum {
493884f7b0STejun Heo 	/* speed down verdicts */
507d47e8d4STejun Heo 	ATA_EH_SPDN_NCQ_OFF		= (1 << 0),
517d47e8d4STejun Heo 	ATA_EH_SPDN_SPEED_DOWN		= (1 << 1),
527d47e8d4STejun Heo 	ATA_EH_SPDN_FALLBACK_TO_PIO	= (1 << 2),
5376326ac1STejun Heo 	ATA_EH_SPDN_KEEP_ERRORS		= (1 << 3),
543884f7b0STejun Heo 
553884f7b0STejun Heo 	/* error flags */
563884f7b0STejun Heo 	ATA_EFLAG_IS_IO			= (1 << 0),
5776326ac1STejun Heo 	ATA_EFLAG_DUBIOUS_XFER		= (1 << 1),
583884f7b0STejun Heo 
593884f7b0STejun Heo 	/* error categories */
603884f7b0STejun Heo 	ATA_ECAT_NONE			= 0,
613884f7b0STejun Heo 	ATA_ECAT_ATA_BUS		= 1,
623884f7b0STejun Heo 	ATA_ECAT_TOUT_HSM		= 2,
633884f7b0STejun Heo 	ATA_ECAT_UNK_DEV		= 3,
6475f9cafcSTejun Heo 	ATA_ECAT_DUBIOUS_NONE		= 4,
6575f9cafcSTejun Heo 	ATA_ECAT_DUBIOUS_ATA_BUS	= 5,
6675f9cafcSTejun Heo 	ATA_ECAT_DUBIOUS_TOUT_HSM	= 6,
6775f9cafcSTejun Heo 	ATA_ECAT_DUBIOUS_UNK_DEV	= 7,
6875f9cafcSTejun Heo 	ATA_ECAT_NR			= 8,
697d47e8d4STejun Heo };
707d47e8d4STejun Heo 
7131daabdaSTejun Heo /* Waiting in ->prereset can never be reliable.  It's sometimes nice
7231daabdaSTejun Heo  * to wait there but it can't be depended upon; otherwise, we wouldn't
7331daabdaSTejun Heo  * be resetting.  Just give it enough time for most drives to spin up.
7431daabdaSTejun Heo  */
7531daabdaSTejun Heo enum {
7631daabdaSTejun Heo 	ATA_EH_PRERESET_TIMEOUT		= 10 * HZ,
775ddf24c5STejun Heo 	ATA_EH_FASTDRAIN_INTERVAL	= 3 * HZ,
7831daabdaSTejun Heo };
7931daabdaSTejun Heo 
8031daabdaSTejun Heo /* The following table determines how we sequence resets.  Each entry
8131daabdaSTejun Heo  * represents timeout for that try.  The first try can be soft or
8231daabdaSTejun Heo  * hardreset.  All others are hardreset if available.  In most cases
8331daabdaSTejun Heo  * the first reset w/ 10sec timeout should succeed.  Following entries
8431daabdaSTejun Heo  * are mostly for error handling, hotplug and retarded devices.
8531daabdaSTejun Heo  */
8631daabdaSTejun Heo static const unsigned long ata_eh_reset_timeouts[] = {
8731daabdaSTejun Heo 	10 * HZ,	/* most drives spin up by 10sec */
8831daabdaSTejun Heo 	10 * HZ,	/* > 99% working drives spin up before 20sec */
8931daabdaSTejun Heo 	35 * HZ,	/* give > 30 secs of idleness for retarded devices */
9031daabdaSTejun Heo 	5 * HZ,		/* and sweet one last chance */
9131daabdaSTejun Heo 	/* > 1 min has elapsed, give up */
9231daabdaSTejun Heo };
9331daabdaSTejun Heo 
94c6fd2807SJeff Garzik static void __ata_port_freeze(struct ata_port *ap);
956ffa01d8STejun Heo #ifdef CONFIG_PM
96c6fd2807SJeff Garzik static void ata_eh_handle_port_suspend(struct ata_port *ap);
97c6fd2807SJeff Garzik static void ata_eh_handle_port_resume(struct ata_port *ap);
986ffa01d8STejun Heo #else /* CONFIG_PM */
996ffa01d8STejun Heo static void ata_eh_handle_port_suspend(struct ata_port *ap)
1006ffa01d8STejun Heo { }
1016ffa01d8STejun Heo 
1026ffa01d8STejun Heo static void ata_eh_handle_port_resume(struct ata_port *ap)
1036ffa01d8STejun Heo { }
1046ffa01d8STejun Heo #endif /* CONFIG_PM */
105c6fd2807SJeff Garzik 
106b64bbc39STejun Heo static void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, const char *fmt,
107b64bbc39STejun Heo 				 va_list args)
108b64bbc39STejun Heo {
109b64bbc39STejun Heo 	ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
110b64bbc39STejun Heo 				     ATA_EH_DESC_LEN - ehi->desc_len,
111b64bbc39STejun Heo 				     fmt, args);
112b64bbc39STejun Heo }
113b64bbc39STejun Heo 
114b64bbc39STejun Heo /**
115b64bbc39STejun Heo  *	__ata_ehi_push_desc - push error description without adding separator
116b64bbc39STejun Heo  *	@ehi: target EHI
117b64bbc39STejun Heo  *	@fmt: printf format string
118b64bbc39STejun Heo  *
119b64bbc39STejun Heo  *	Format string according to @fmt and append it to @ehi->desc.
120b64bbc39STejun Heo  *
121b64bbc39STejun Heo  *	LOCKING:
122b64bbc39STejun Heo  *	spin_lock_irqsave(host lock)
123b64bbc39STejun Heo  */
124b64bbc39STejun Heo void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
125b64bbc39STejun Heo {
126b64bbc39STejun Heo 	va_list args;
127b64bbc39STejun Heo 
128b64bbc39STejun Heo 	va_start(args, fmt);
129b64bbc39STejun Heo 	__ata_ehi_pushv_desc(ehi, fmt, args);
130b64bbc39STejun Heo 	va_end(args);
131b64bbc39STejun Heo }
132b64bbc39STejun Heo 
133b64bbc39STejun Heo /**
134b64bbc39STejun Heo  *	ata_ehi_push_desc - push error description with separator
135b64bbc39STejun Heo  *	@ehi: target EHI
136b64bbc39STejun Heo  *	@fmt: printf format string
137b64bbc39STejun Heo  *
138b64bbc39STejun Heo  *	Format string according to @fmt and append it to @ehi->desc.
139b64bbc39STejun Heo  *	If @ehi->desc is not empty, ", " is added in-between.
140b64bbc39STejun Heo  *
141b64bbc39STejun Heo  *	LOCKING:
142b64bbc39STejun Heo  *	spin_lock_irqsave(host lock)
143b64bbc39STejun Heo  */
144b64bbc39STejun Heo void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
145b64bbc39STejun Heo {
146b64bbc39STejun Heo 	va_list args;
147b64bbc39STejun Heo 
148b64bbc39STejun Heo 	if (ehi->desc_len)
149b64bbc39STejun Heo 		__ata_ehi_push_desc(ehi, ", ");
150b64bbc39STejun Heo 
151b64bbc39STejun Heo 	va_start(args, fmt);
152b64bbc39STejun Heo 	__ata_ehi_pushv_desc(ehi, fmt, args);
153b64bbc39STejun Heo 	va_end(args);
154b64bbc39STejun Heo }
155b64bbc39STejun Heo 
156b64bbc39STejun Heo /**
157b64bbc39STejun Heo  *	ata_ehi_clear_desc - clean error description
158b64bbc39STejun Heo  *	@ehi: target EHI
159b64bbc39STejun Heo  *
160b64bbc39STejun Heo  *	Clear @ehi->desc.
161b64bbc39STejun Heo  *
162b64bbc39STejun Heo  *	LOCKING:
163b64bbc39STejun Heo  *	spin_lock_irqsave(host lock)
164b64bbc39STejun Heo  */
165b64bbc39STejun Heo void ata_ehi_clear_desc(struct ata_eh_info *ehi)
166b64bbc39STejun Heo {
167b64bbc39STejun Heo 	ehi->desc[0] = '\0';
168b64bbc39STejun Heo 	ehi->desc_len = 0;
169b64bbc39STejun Heo }
170b64bbc39STejun Heo 
171cbcdd875STejun Heo /**
172cbcdd875STejun Heo  *	ata_port_desc - append port description
173cbcdd875STejun Heo  *	@ap: target ATA port
174cbcdd875STejun Heo  *	@fmt: printf format string
175cbcdd875STejun Heo  *
176cbcdd875STejun Heo  *	Format string according to @fmt and append it to port
177cbcdd875STejun Heo  *	description.  If port description is not empty, " " is added
178cbcdd875STejun Heo  *	in-between.  This function is to be used while initializing
179cbcdd875STejun Heo  *	ata_host.  The description is printed on host registration.
180cbcdd875STejun Heo  *
181cbcdd875STejun Heo  *	LOCKING:
182cbcdd875STejun Heo  *	None.
183cbcdd875STejun Heo  */
184cbcdd875STejun Heo void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
185cbcdd875STejun Heo {
186cbcdd875STejun Heo 	va_list args;
187cbcdd875STejun Heo 
188cbcdd875STejun Heo 	WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
189cbcdd875STejun Heo 
190cbcdd875STejun Heo 	if (ap->link.eh_info.desc_len)
191cbcdd875STejun Heo 		__ata_ehi_push_desc(&ap->link.eh_info, " ");
192cbcdd875STejun Heo 
193cbcdd875STejun Heo 	va_start(args, fmt);
194cbcdd875STejun Heo 	__ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
195cbcdd875STejun Heo 	va_end(args);
196cbcdd875STejun Heo }
197cbcdd875STejun Heo 
198cbcdd875STejun Heo #ifdef CONFIG_PCI
199cbcdd875STejun Heo 
200cbcdd875STejun Heo /**
201cbcdd875STejun Heo  *	ata_port_pbar_desc - append PCI BAR description
202cbcdd875STejun Heo  *	@ap: target ATA port
203cbcdd875STejun Heo  *	@bar: target PCI BAR
204cbcdd875STejun Heo  *	@offset: offset into PCI BAR
205cbcdd875STejun Heo  *	@name: name of the area
206cbcdd875STejun Heo  *
207cbcdd875STejun Heo  *	If @offset is negative, this function formats a string which
208cbcdd875STejun Heo  *	contains the name, address, size and type of the BAR and
209cbcdd875STejun Heo  *	appends it to the port description.  If @offset is zero or
210cbcdd875STejun Heo  *	positive, only name and offsetted address is appended.
211cbcdd875STejun Heo  *
212cbcdd875STejun Heo  *	LOCKING:
213cbcdd875STejun Heo  *	None.
214cbcdd875STejun Heo  */
215cbcdd875STejun Heo void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
216cbcdd875STejun Heo 			const char *name)
217cbcdd875STejun Heo {
218cbcdd875STejun Heo 	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
219cbcdd875STejun Heo 	char *type = "";
220cbcdd875STejun Heo 	unsigned long long start, len;
221cbcdd875STejun Heo 
222cbcdd875STejun Heo 	if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
223cbcdd875STejun Heo 		type = "m";
224cbcdd875STejun Heo 	else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
225cbcdd875STejun Heo 		type = "i";
226cbcdd875STejun Heo 
227cbcdd875STejun Heo 	start = (unsigned long long)pci_resource_start(pdev, bar);
228cbcdd875STejun Heo 	len = (unsigned long long)pci_resource_len(pdev, bar);
229cbcdd875STejun Heo 
230cbcdd875STejun Heo 	if (offset < 0)
231cbcdd875STejun Heo 		ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
232cbcdd875STejun Heo 	else
233e6a73ab1SAndrew Morton 		ata_port_desc(ap, "%s 0x%llx", name,
234e6a73ab1SAndrew Morton 				start + (unsigned long long)offset);
235cbcdd875STejun Heo }
236cbcdd875STejun Heo 
237cbcdd875STejun Heo #endif /* CONFIG_PCI */
238cbcdd875STejun Heo 
2393884f7b0STejun Heo static void ata_ering_record(struct ata_ering *ering, unsigned int eflags,
240c6fd2807SJeff Garzik 			     unsigned int err_mask)
241c6fd2807SJeff Garzik {
242c6fd2807SJeff Garzik 	struct ata_ering_entry *ent;
243c6fd2807SJeff Garzik 
244c6fd2807SJeff Garzik 	WARN_ON(!err_mask);
245c6fd2807SJeff Garzik 
246c6fd2807SJeff Garzik 	ering->cursor++;
247c6fd2807SJeff Garzik 	ering->cursor %= ATA_ERING_SIZE;
248c6fd2807SJeff Garzik 
249c6fd2807SJeff Garzik 	ent = &ering->ring[ering->cursor];
2503884f7b0STejun Heo 	ent->eflags = eflags;
251c6fd2807SJeff Garzik 	ent->err_mask = err_mask;
252c6fd2807SJeff Garzik 	ent->timestamp = get_jiffies_64();
253c6fd2807SJeff Garzik }
254c6fd2807SJeff Garzik 
25576326ac1STejun Heo static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
25676326ac1STejun Heo {
25776326ac1STejun Heo 	struct ata_ering_entry *ent = &ering->ring[ering->cursor];
25876326ac1STejun Heo 
25976326ac1STejun Heo 	if (ent->err_mask)
26076326ac1STejun Heo 		return ent;
26176326ac1STejun Heo 	return NULL;
26276326ac1STejun Heo }
26376326ac1STejun Heo 
2647d47e8d4STejun Heo static void ata_ering_clear(struct ata_ering *ering)
265c6fd2807SJeff Garzik {
2667d47e8d4STejun Heo 	memset(ering, 0, sizeof(*ering));
267c6fd2807SJeff Garzik }
268c6fd2807SJeff Garzik 
269c6fd2807SJeff Garzik static int ata_ering_map(struct ata_ering *ering,
270c6fd2807SJeff Garzik 			 int (*map_fn)(struct ata_ering_entry *, void *),
271c6fd2807SJeff Garzik 			 void *arg)
272c6fd2807SJeff Garzik {
273c6fd2807SJeff Garzik 	int idx, rc = 0;
274c6fd2807SJeff Garzik 	struct ata_ering_entry *ent;
275c6fd2807SJeff Garzik 
276c6fd2807SJeff Garzik 	idx = ering->cursor;
277c6fd2807SJeff Garzik 	do {
278c6fd2807SJeff Garzik 		ent = &ering->ring[idx];
279c6fd2807SJeff Garzik 		if (!ent->err_mask)
280c6fd2807SJeff Garzik 			break;
281c6fd2807SJeff Garzik 		rc = map_fn(ent, arg);
282c6fd2807SJeff Garzik 		if (rc)
283c6fd2807SJeff Garzik 			break;
284c6fd2807SJeff Garzik 		idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
285c6fd2807SJeff Garzik 	} while (idx != ering->cursor);
286c6fd2807SJeff Garzik 
287c6fd2807SJeff Garzik 	return rc;
288c6fd2807SJeff Garzik }
289c6fd2807SJeff Garzik 
290c6fd2807SJeff Garzik static unsigned int ata_eh_dev_action(struct ata_device *dev)
291c6fd2807SJeff Garzik {
2929af5c9c9STejun Heo 	struct ata_eh_context *ehc = &dev->link->eh_context;
293c6fd2807SJeff Garzik 
294c6fd2807SJeff Garzik 	return ehc->i.action | ehc->i.dev_action[dev->devno];
295c6fd2807SJeff Garzik }
296c6fd2807SJeff Garzik 
297f58229f8STejun Heo static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
298c6fd2807SJeff Garzik 				struct ata_eh_info *ehi, unsigned int action)
299c6fd2807SJeff Garzik {
300f58229f8STejun Heo 	struct ata_device *tdev;
301c6fd2807SJeff Garzik 
302c6fd2807SJeff Garzik 	if (!dev) {
303c6fd2807SJeff Garzik 		ehi->action &= ~action;
304f58229f8STejun Heo 		ata_link_for_each_dev(tdev, link)
305f58229f8STejun Heo 			ehi->dev_action[tdev->devno] &= ~action;
306c6fd2807SJeff Garzik 	} else {
307c6fd2807SJeff Garzik 		/* doesn't make sense for port-wide EH actions */
308c6fd2807SJeff Garzik 		WARN_ON(!(action & ATA_EH_PERDEV_MASK));
309c6fd2807SJeff Garzik 
310c6fd2807SJeff Garzik 		/* break ehi->action into ehi->dev_action */
311c6fd2807SJeff Garzik 		if (ehi->action & action) {
312f58229f8STejun Heo 			ata_link_for_each_dev(tdev, link)
313f58229f8STejun Heo 				ehi->dev_action[tdev->devno] |=
314f58229f8STejun Heo 					ehi->action & action;
315c6fd2807SJeff Garzik 			ehi->action &= ~action;
316c6fd2807SJeff Garzik 		}
317c6fd2807SJeff Garzik 
318c6fd2807SJeff Garzik 		/* turn off the specified per-dev action */
319c6fd2807SJeff Garzik 		ehi->dev_action[dev->devno] &= ~action;
320c6fd2807SJeff Garzik 	}
321c6fd2807SJeff Garzik }
322c6fd2807SJeff Garzik 
323c6fd2807SJeff Garzik /**
324c6fd2807SJeff Garzik  *	ata_scsi_timed_out - SCSI layer time out callback
325c6fd2807SJeff Garzik  *	@cmd: timed out SCSI command
326c6fd2807SJeff Garzik  *
327c6fd2807SJeff Garzik  *	Handles SCSI layer timeout.  We race with normal completion of
328c6fd2807SJeff Garzik  *	the qc for @cmd.  If the qc is already gone, we lose and let
329c6fd2807SJeff Garzik  *	the scsi command finish (EH_HANDLED).  Otherwise, the qc has
330c6fd2807SJeff Garzik  *	timed out and EH should be invoked.  Prevent ata_qc_complete()
331c6fd2807SJeff Garzik  *	from finishing it by setting EH_SCHEDULED and return
332c6fd2807SJeff Garzik  *	EH_NOT_HANDLED.
333c6fd2807SJeff Garzik  *
334c6fd2807SJeff Garzik  *	TODO: kill this function once old EH is gone.
335c6fd2807SJeff Garzik  *
336c6fd2807SJeff Garzik  *	LOCKING:
337c6fd2807SJeff Garzik  *	Called from timer context
338c6fd2807SJeff Garzik  *
339c6fd2807SJeff Garzik  *	RETURNS:
340c6fd2807SJeff Garzik  *	EH_HANDLED or EH_NOT_HANDLED
341c6fd2807SJeff Garzik  */
342c6fd2807SJeff Garzik enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
343c6fd2807SJeff Garzik {
344c6fd2807SJeff Garzik 	struct Scsi_Host *host = cmd->device->host;
345c6fd2807SJeff Garzik 	struct ata_port *ap = ata_shost_to_port(host);
346c6fd2807SJeff Garzik 	unsigned long flags;
347c6fd2807SJeff Garzik 	struct ata_queued_cmd *qc;
348c6fd2807SJeff Garzik 	enum scsi_eh_timer_return ret;
349c6fd2807SJeff Garzik 
350c6fd2807SJeff Garzik 	DPRINTK("ENTER\n");
351c6fd2807SJeff Garzik 
352c6fd2807SJeff Garzik 	if (ap->ops->error_handler) {
353c6fd2807SJeff Garzik 		ret = EH_NOT_HANDLED;
354c6fd2807SJeff Garzik 		goto out;
355c6fd2807SJeff Garzik 	}
356c6fd2807SJeff Garzik 
357c6fd2807SJeff Garzik 	ret = EH_HANDLED;
358c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
3599af5c9c9STejun Heo 	qc = ata_qc_from_tag(ap, ap->link.active_tag);
360c6fd2807SJeff Garzik 	if (qc) {
361c6fd2807SJeff Garzik 		WARN_ON(qc->scsicmd != cmd);
362c6fd2807SJeff Garzik 		qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
363c6fd2807SJeff Garzik 		qc->err_mask |= AC_ERR_TIMEOUT;
364c6fd2807SJeff Garzik 		ret = EH_NOT_HANDLED;
365c6fd2807SJeff Garzik 	}
366c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
367c6fd2807SJeff Garzik 
368c6fd2807SJeff Garzik  out:
369c6fd2807SJeff Garzik 	DPRINTK("EXIT, ret=%d\n", ret);
370c6fd2807SJeff Garzik 	return ret;
371c6fd2807SJeff Garzik }
372c6fd2807SJeff Garzik 
373c6fd2807SJeff Garzik /**
374c6fd2807SJeff Garzik  *	ata_scsi_error - SCSI layer error handler callback
375c6fd2807SJeff Garzik  *	@host: SCSI host on which error occurred
376c6fd2807SJeff Garzik  *
377c6fd2807SJeff Garzik  *	Handles SCSI-layer-thrown error events.
378c6fd2807SJeff Garzik  *
379c6fd2807SJeff Garzik  *	LOCKING:
380c6fd2807SJeff Garzik  *	Inherited from SCSI layer (none, can sleep)
381c6fd2807SJeff Garzik  *
382c6fd2807SJeff Garzik  *	RETURNS:
383c6fd2807SJeff Garzik  *	Zero.
384c6fd2807SJeff Garzik  */
385c6fd2807SJeff Garzik void ata_scsi_error(struct Scsi_Host *host)
386c6fd2807SJeff Garzik {
387c6fd2807SJeff Garzik 	struct ata_port *ap = ata_shost_to_port(host);
388a1e10f7eSTejun Heo 	int i;
389c6fd2807SJeff Garzik 	unsigned long flags;
390c6fd2807SJeff Garzik 
391c6fd2807SJeff Garzik 	DPRINTK("ENTER\n");
392c6fd2807SJeff Garzik 
393c6fd2807SJeff Garzik 	/* synchronize with port task */
394c6fd2807SJeff Garzik 	ata_port_flush_task(ap);
395c6fd2807SJeff Garzik 
396cca3974eSJeff Garzik 	/* synchronize with host lock and sort out timeouts */
397c6fd2807SJeff Garzik 
398c6fd2807SJeff Garzik 	/* For new EH, all qcs are finished in one of three ways -
399c6fd2807SJeff Garzik 	 * normal completion, error completion, and SCSI timeout.
400c6fd2807SJeff Garzik 	 * Both cmpletions can race against SCSI timeout.  When normal
401c6fd2807SJeff Garzik 	 * completion wins, the qc never reaches EH.  When error
402c6fd2807SJeff Garzik 	 * completion wins, the qc has ATA_QCFLAG_FAILED set.
403c6fd2807SJeff Garzik 	 *
404c6fd2807SJeff Garzik 	 * When SCSI timeout wins, things are a bit more complex.
405c6fd2807SJeff Garzik 	 * Normal or error completion can occur after the timeout but
406c6fd2807SJeff Garzik 	 * before this point.  In such cases, both types of
407c6fd2807SJeff Garzik 	 * completions are honored.  A scmd is determined to have
408c6fd2807SJeff Garzik 	 * timed out iff its associated qc is active and not failed.
409c6fd2807SJeff Garzik 	 */
410c6fd2807SJeff Garzik 	if (ap->ops->error_handler) {
411c6fd2807SJeff Garzik 		struct scsi_cmnd *scmd, *tmp;
412c6fd2807SJeff Garzik 		int nr_timedout = 0;
413c6fd2807SJeff Garzik 
414c6fd2807SJeff Garzik 		spin_lock_irqsave(ap->lock, flags);
415c6fd2807SJeff Garzik 
416c6fd2807SJeff Garzik 		list_for_each_entry_safe(scmd, tmp, &host->eh_cmd_q, eh_entry) {
417c6fd2807SJeff Garzik 			struct ata_queued_cmd *qc;
418c6fd2807SJeff Garzik 
419c6fd2807SJeff Garzik 			for (i = 0; i < ATA_MAX_QUEUE; i++) {
420c6fd2807SJeff Garzik 				qc = __ata_qc_from_tag(ap, i);
421c6fd2807SJeff Garzik 				if (qc->flags & ATA_QCFLAG_ACTIVE &&
422c6fd2807SJeff Garzik 				    qc->scsicmd == scmd)
423c6fd2807SJeff Garzik 					break;
424c6fd2807SJeff Garzik 			}
425c6fd2807SJeff Garzik 
426c6fd2807SJeff Garzik 			if (i < ATA_MAX_QUEUE) {
427c6fd2807SJeff Garzik 				/* the scmd has an associated qc */
428c6fd2807SJeff Garzik 				if (!(qc->flags & ATA_QCFLAG_FAILED)) {
429c6fd2807SJeff Garzik 					/* which hasn't failed yet, timeout */
430c6fd2807SJeff Garzik 					qc->err_mask |= AC_ERR_TIMEOUT;
431c6fd2807SJeff Garzik 					qc->flags |= ATA_QCFLAG_FAILED;
432c6fd2807SJeff Garzik 					nr_timedout++;
433c6fd2807SJeff Garzik 				}
434c6fd2807SJeff Garzik 			} else {
435c6fd2807SJeff Garzik 				/* Normal completion occurred after
436c6fd2807SJeff Garzik 				 * SCSI timeout but before this point.
437c6fd2807SJeff Garzik 				 * Successfully complete it.
438c6fd2807SJeff Garzik 				 */
439c6fd2807SJeff Garzik 				scmd->retries = scmd->allowed;
440c6fd2807SJeff Garzik 				scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
441c6fd2807SJeff Garzik 			}
442c6fd2807SJeff Garzik 		}
443c6fd2807SJeff Garzik 
444c6fd2807SJeff Garzik 		/* If we have timed out qcs.  They belong to EH from
445c6fd2807SJeff Garzik 		 * this point but the state of the controller is
446c6fd2807SJeff Garzik 		 * unknown.  Freeze the port to make sure the IRQ
447c6fd2807SJeff Garzik 		 * handler doesn't diddle with those qcs.  This must
448c6fd2807SJeff Garzik 		 * be done atomically w.r.t. setting QCFLAG_FAILED.
449c6fd2807SJeff Garzik 		 */
450c6fd2807SJeff Garzik 		if (nr_timedout)
451c6fd2807SJeff Garzik 			__ata_port_freeze(ap);
452c6fd2807SJeff Garzik 
453c6fd2807SJeff Garzik 		spin_unlock_irqrestore(ap->lock, flags);
454a1e10f7eSTejun Heo 
455a1e10f7eSTejun Heo 		/* initialize eh_tries */
456a1e10f7eSTejun Heo 		ap->eh_tries = ATA_EH_MAX_TRIES;
457c6fd2807SJeff Garzik 	} else
458c6fd2807SJeff Garzik 		spin_unlock_wait(ap->lock);
459c6fd2807SJeff Garzik 
460c6fd2807SJeff Garzik  repeat:
461c6fd2807SJeff Garzik 	/* invoke error handler */
462c6fd2807SJeff Garzik 	if (ap->ops->error_handler) {
463cf1b86c8STejun Heo 		struct ata_link *link;
464cf1b86c8STejun Heo 
4655ddf24c5STejun Heo 		/* kill fast drain timer */
4665ddf24c5STejun Heo 		del_timer_sync(&ap->fastdrain_timer);
4675ddf24c5STejun Heo 
468c6fd2807SJeff Garzik 		/* process port resume request */
469c6fd2807SJeff Garzik 		ata_eh_handle_port_resume(ap);
470c6fd2807SJeff Garzik 
471c6fd2807SJeff Garzik 		/* fetch & clear EH info */
472c6fd2807SJeff Garzik 		spin_lock_irqsave(ap->lock, flags);
473c6fd2807SJeff Garzik 
474cf1b86c8STejun Heo 		__ata_port_for_each_link(link, ap) {
47500115e0fSTejun Heo 			struct ata_eh_context *ehc = &link->eh_context;
47600115e0fSTejun Heo 			struct ata_device *dev;
47700115e0fSTejun Heo 
478cf1b86c8STejun Heo 			memset(&link->eh_context, 0, sizeof(link->eh_context));
479cf1b86c8STejun Heo 			link->eh_context.i = link->eh_info;
480cf1b86c8STejun Heo 			memset(&link->eh_info, 0, sizeof(link->eh_info));
48100115e0fSTejun Heo 
48200115e0fSTejun Heo 			ata_link_for_each_dev(dev, link) {
48300115e0fSTejun Heo 				int devno = dev->devno;
48400115e0fSTejun Heo 
48500115e0fSTejun Heo 				ehc->saved_xfer_mode[devno] = dev->xfer_mode;
48600115e0fSTejun Heo 				if (ata_ncq_enabled(dev))
48700115e0fSTejun Heo 					ehc->saved_ncq_enabled |= 1 << devno;
48800115e0fSTejun Heo 			}
489cf1b86c8STejun Heo 		}
490c6fd2807SJeff Garzik 
491c6fd2807SJeff Garzik 		ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
492c6fd2807SJeff Garzik 		ap->pflags &= ~ATA_PFLAG_EH_PENDING;
493da917d69STejun Heo 		ap->excl_link = NULL;	/* don't maintain exclusion over EH */
494c6fd2807SJeff Garzik 
495c6fd2807SJeff Garzik 		spin_unlock_irqrestore(ap->lock, flags);
496c6fd2807SJeff Garzik 
497c6fd2807SJeff Garzik 		/* invoke EH, skip if unloading or suspended */
498c6fd2807SJeff Garzik 		if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
499c6fd2807SJeff Garzik 			ap->ops->error_handler(ap);
500c6fd2807SJeff Garzik 		else
501c6fd2807SJeff Garzik 			ata_eh_finish(ap);
502c6fd2807SJeff Garzik 
503c6fd2807SJeff Garzik 		/* process port suspend request */
504c6fd2807SJeff Garzik 		ata_eh_handle_port_suspend(ap);
505c6fd2807SJeff Garzik 
506c6fd2807SJeff Garzik 		/* Exception might have happend after ->error_handler
507c6fd2807SJeff Garzik 		 * recovered the port but before this point.  Repeat
508c6fd2807SJeff Garzik 		 * EH in such case.
509c6fd2807SJeff Garzik 		 */
510c6fd2807SJeff Garzik 		spin_lock_irqsave(ap->lock, flags);
511c6fd2807SJeff Garzik 
512c6fd2807SJeff Garzik 		if (ap->pflags & ATA_PFLAG_EH_PENDING) {
513a1e10f7eSTejun Heo 			if (--ap->eh_tries) {
514c6fd2807SJeff Garzik 				spin_unlock_irqrestore(ap->lock, flags);
515c6fd2807SJeff Garzik 				goto repeat;
516c6fd2807SJeff Garzik 			}
517c6fd2807SJeff Garzik 			ata_port_printk(ap, KERN_ERR, "EH pending after %d "
518a1e10f7eSTejun Heo 					"tries, giving up\n", ATA_EH_MAX_TRIES);
519914616a3STejun Heo 			ap->pflags &= ~ATA_PFLAG_EH_PENDING;
520c6fd2807SJeff Garzik 		}
521c6fd2807SJeff Garzik 
522c6fd2807SJeff Garzik 		/* this run is complete, make sure EH info is clear */
523cf1b86c8STejun Heo 		__ata_port_for_each_link(link, ap)
524cf1b86c8STejun Heo 			memset(&link->eh_info, 0, sizeof(link->eh_info));
525c6fd2807SJeff Garzik 
526c6fd2807SJeff Garzik 		/* Clear host_eh_scheduled while holding ap->lock such
527c6fd2807SJeff Garzik 		 * that if exception occurs after this point but
528c6fd2807SJeff Garzik 		 * before EH completion, SCSI midlayer will
529c6fd2807SJeff Garzik 		 * re-initiate EH.
530c6fd2807SJeff Garzik 		 */
531c6fd2807SJeff Garzik 		host->host_eh_scheduled = 0;
532c6fd2807SJeff Garzik 
533c6fd2807SJeff Garzik 		spin_unlock_irqrestore(ap->lock, flags);
534c6fd2807SJeff Garzik 	} else {
5359af5c9c9STejun Heo 		WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
536c6fd2807SJeff Garzik 		ap->ops->eng_timeout(ap);
537c6fd2807SJeff Garzik 	}
538c6fd2807SJeff Garzik 
539c6fd2807SJeff Garzik 	/* finish or retry handled scmd's and clean up */
540c6fd2807SJeff Garzik 	WARN_ON(host->host_failed || !list_empty(&host->eh_cmd_q));
541c6fd2807SJeff Garzik 
542c6fd2807SJeff Garzik 	scsi_eh_flush_done_q(&ap->eh_done_q);
543c6fd2807SJeff Garzik 
544c6fd2807SJeff Garzik 	/* clean up */
545c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
546c6fd2807SJeff Garzik 
547c6fd2807SJeff Garzik 	if (ap->pflags & ATA_PFLAG_LOADING)
548c6fd2807SJeff Garzik 		ap->pflags &= ~ATA_PFLAG_LOADING;
549c6fd2807SJeff Garzik 	else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
55052bad64dSDavid Howells 		queue_delayed_work(ata_aux_wq, &ap->hotplug_task, 0);
551c6fd2807SJeff Garzik 
552c6fd2807SJeff Garzik 	if (ap->pflags & ATA_PFLAG_RECOVERED)
553c6fd2807SJeff Garzik 		ata_port_printk(ap, KERN_INFO, "EH complete\n");
554c6fd2807SJeff Garzik 
555c6fd2807SJeff Garzik 	ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
556c6fd2807SJeff Garzik 
557c6fd2807SJeff Garzik 	/* tell wait_eh that we're done */
558c6fd2807SJeff Garzik 	ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
559c6fd2807SJeff Garzik 	wake_up_all(&ap->eh_wait_q);
560c6fd2807SJeff Garzik 
561c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
562c6fd2807SJeff Garzik 
563c6fd2807SJeff Garzik 	DPRINTK("EXIT\n");
564c6fd2807SJeff Garzik }
565c6fd2807SJeff Garzik 
566c6fd2807SJeff Garzik /**
567c6fd2807SJeff Garzik  *	ata_port_wait_eh - Wait for the currently pending EH to complete
568c6fd2807SJeff Garzik  *	@ap: Port to wait EH for
569c6fd2807SJeff Garzik  *
570c6fd2807SJeff Garzik  *	Wait until the currently pending EH is complete.
571c6fd2807SJeff Garzik  *
572c6fd2807SJeff Garzik  *	LOCKING:
573c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
574c6fd2807SJeff Garzik  */
575c6fd2807SJeff Garzik void ata_port_wait_eh(struct ata_port *ap)
576c6fd2807SJeff Garzik {
577c6fd2807SJeff Garzik 	unsigned long flags;
578c6fd2807SJeff Garzik 	DEFINE_WAIT(wait);
579c6fd2807SJeff Garzik 
580c6fd2807SJeff Garzik  retry:
581c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
582c6fd2807SJeff Garzik 
583c6fd2807SJeff Garzik 	while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
584c6fd2807SJeff Garzik 		prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
585c6fd2807SJeff Garzik 		spin_unlock_irqrestore(ap->lock, flags);
586c6fd2807SJeff Garzik 		schedule();
587c6fd2807SJeff Garzik 		spin_lock_irqsave(ap->lock, flags);
588c6fd2807SJeff Garzik 	}
589c6fd2807SJeff Garzik 	finish_wait(&ap->eh_wait_q, &wait);
590c6fd2807SJeff Garzik 
591c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
592c6fd2807SJeff Garzik 
593c6fd2807SJeff Garzik 	/* make sure SCSI EH is complete */
594cca3974eSJeff Garzik 	if (scsi_host_in_recovery(ap->scsi_host)) {
595c6fd2807SJeff Garzik 		msleep(10);
596c6fd2807SJeff Garzik 		goto retry;
597c6fd2807SJeff Garzik 	}
598c6fd2807SJeff Garzik }
599c6fd2807SJeff Garzik 
6005ddf24c5STejun Heo static int ata_eh_nr_in_flight(struct ata_port *ap)
6015ddf24c5STejun Heo {
6025ddf24c5STejun Heo 	unsigned int tag;
6035ddf24c5STejun Heo 	int nr = 0;
6045ddf24c5STejun Heo 
6055ddf24c5STejun Heo 	/* count only non-internal commands */
6065ddf24c5STejun Heo 	for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
6075ddf24c5STejun Heo 		if (ata_qc_from_tag(ap, tag))
6085ddf24c5STejun Heo 			nr++;
6095ddf24c5STejun Heo 
6105ddf24c5STejun Heo 	return nr;
6115ddf24c5STejun Heo }
6125ddf24c5STejun Heo 
6135ddf24c5STejun Heo void ata_eh_fastdrain_timerfn(unsigned long arg)
6145ddf24c5STejun Heo {
6155ddf24c5STejun Heo 	struct ata_port *ap = (void *)arg;
6165ddf24c5STejun Heo 	unsigned long flags;
6175ddf24c5STejun Heo 	int cnt;
6185ddf24c5STejun Heo 
6195ddf24c5STejun Heo 	spin_lock_irqsave(ap->lock, flags);
6205ddf24c5STejun Heo 
6215ddf24c5STejun Heo 	cnt = ata_eh_nr_in_flight(ap);
6225ddf24c5STejun Heo 
6235ddf24c5STejun Heo 	/* are we done? */
6245ddf24c5STejun Heo 	if (!cnt)
6255ddf24c5STejun Heo 		goto out_unlock;
6265ddf24c5STejun Heo 
6275ddf24c5STejun Heo 	if (cnt == ap->fastdrain_cnt) {
6285ddf24c5STejun Heo 		unsigned int tag;
6295ddf24c5STejun Heo 
6305ddf24c5STejun Heo 		/* No progress during the last interval, tag all
6315ddf24c5STejun Heo 		 * in-flight qcs as timed out and freeze the port.
6325ddf24c5STejun Heo 		 */
6335ddf24c5STejun Heo 		for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
6345ddf24c5STejun Heo 			struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
6355ddf24c5STejun Heo 			if (qc)
6365ddf24c5STejun Heo 				qc->err_mask |= AC_ERR_TIMEOUT;
6375ddf24c5STejun Heo 		}
6385ddf24c5STejun Heo 
6395ddf24c5STejun Heo 		ata_port_freeze(ap);
6405ddf24c5STejun Heo 	} else {
6415ddf24c5STejun Heo 		/* some qcs have finished, give it another chance */
6425ddf24c5STejun Heo 		ap->fastdrain_cnt = cnt;
6435ddf24c5STejun Heo 		ap->fastdrain_timer.expires =
6445ddf24c5STejun Heo 			jiffies + ATA_EH_FASTDRAIN_INTERVAL;
6455ddf24c5STejun Heo 		add_timer(&ap->fastdrain_timer);
6465ddf24c5STejun Heo 	}
6475ddf24c5STejun Heo 
6485ddf24c5STejun Heo  out_unlock:
6495ddf24c5STejun Heo 	spin_unlock_irqrestore(ap->lock, flags);
6505ddf24c5STejun Heo }
6515ddf24c5STejun Heo 
6525ddf24c5STejun Heo /**
6535ddf24c5STejun Heo  *	ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
6545ddf24c5STejun Heo  *	@ap: target ATA port
6555ddf24c5STejun Heo  *	@fastdrain: activate fast drain
6565ddf24c5STejun Heo  *
6575ddf24c5STejun Heo  *	Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
6585ddf24c5STejun Heo  *	is non-zero and EH wasn't pending before.  Fast drain ensures
6595ddf24c5STejun Heo  *	that EH kicks in in timely manner.
6605ddf24c5STejun Heo  *
6615ddf24c5STejun Heo  *	LOCKING:
6625ddf24c5STejun Heo  *	spin_lock_irqsave(host lock)
6635ddf24c5STejun Heo  */
6645ddf24c5STejun Heo static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
6655ddf24c5STejun Heo {
6665ddf24c5STejun Heo 	int cnt;
6675ddf24c5STejun Heo 
6685ddf24c5STejun Heo 	/* already scheduled? */
6695ddf24c5STejun Heo 	if (ap->pflags & ATA_PFLAG_EH_PENDING)
6705ddf24c5STejun Heo 		return;
6715ddf24c5STejun Heo 
6725ddf24c5STejun Heo 	ap->pflags |= ATA_PFLAG_EH_PENDING;
6735ddf24c5STejun Heo 
6745ddf24c5STejun Heo 	if (!fastdrain)
6755ddf24c5STejun Heo 		return;
6765ddf24c5STejun Heo 
6775ddf24c5STejun Heo 	/* do we have in-flight qcs? */
6785ddf24c5STejun Heo 	cnt = ata_eh_nr_in_flight(ap);
6795ddf24c5STejun Heo 	if (!cnt)
6805ddf24c5STejun Heo 		return;
6815ddf24c5STejun Heo 
6825ddf24c5STejun Heo 	/* activate fast drain */
6835ddf24c5STejun Heo 	ap->fastdrain_cnt = cnt;
6845ddf24c5STejun Heo 	ap->fastdrain_timer.expires = jiffies + ATA_EH_FASTDRAIN_INTERVAL;
6855ddf24c5STejun Heo 	add_timer(&ap->fastdrain_timer);
6865ddf24c5STejun Heo }
6875ddf24c5STejun Heo 
688c6fd2807SJeff Garzik /**
689c6fd2807SJeff Garzik  *	ata_qc_schedule_eh - schedule qc for error handling
690c6fd2807SJeff Garzik  *	@qc: command to schedule error handling for
691c6fd2807SJeff Garzik  *
692c6fd2807SJeff Garzik  *	Schedule error handling for @qc.  EH will kick in as soon as
693c6fd2807SJeff Garzik  *	other commands are drained.
694c6fd2807SJeff Garzik  *
695c6fd2807SJeff Garzik  *	LOCKING:
696cca3974eSJeff Garzik  *	spin_lock_irqsave(host lock)
697c6fd2807SJeff Garzik  */
698c6fd2807SJeff Garzik void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
699c6fd2807SJeff Garzik {
700c6fd2807SJeff Garzik 	struct ata_port *ap = qc->ap;
701c6fd2807SJeff Garzik 
702c6fd2807SJeff Garzik 	WARN_ON(!ap->ops->error_handler);
703c6fd2807SJeff Garzik 
704c6fd2807SJeff Garzik 	qc->flags |= ATA_QCFLAG_FAILED;
7055ddf24c5STejun Heo 	ata_eh_set_pending(ap, 1);
706c6fd2807SJeff Garzik 
707c6fd2807SJeff Garzik 	/* The following will fail if timeout has already expired.
708c6fd2807SJeff Garzik 	 * ata_scsi_error() takes care of such scmds on EH entry.
709c6fd2807SJeff Garzik 	 * Note that ATA_QCFLAG_FAILED is unconditionally set after
710c6fd2807SJeff Garzik 	 * this function completes.
711c6fd2807SJeff Garzik 	 */
712c6fd2807SJeff Garzik 	scsi_req_abort_cmd(qc->scsicmd);
713c6fd2807SJeff Garzik }
714c6fd2807SJeff Garzik 
715c6fd2807SJeff Garzik /**
716c6fd2807SJeff Garzik  *	ata_port_schedule_eh - schedule error handling without a qc
717c6fd2807SJeff Garzik  *	@ap: ATA port to schedule EH for
718c6fd2807SJeff Garzik  *
719c6fd2807SJeff Garzik  *	Schedule error handling for @ap.  EH will kick in as soon as
720c6fd2807SJeff Garzik  *	all commands are drained.
721c6fd2807SJeff Garzik  *
722c6fd2807SJeff Garzik  *	LOCKING:
723cca3974eSJeff Garzik  *	spin_lock_irqsave(host lock)
724c6fd2807SJeff Garzik  */
725c6fd2807SJeff Garzik void ata_port_schedule_eh(struct ata_port *ap)
726c6fd2807SJeff Garzik {
727c6fd2807SJeff Garzik 	WARN_ON(!ap->ops->error_handler);
728c6fd2807SJeff Garzik 
729f4d6d004STejun Heo 	if (ap->pflags & ATA_PFLAG_INITIALIZING)
730f4d6d004STejun Heo 		return;
731f4d6d004STejun Heo 
7325ddf24c5STejun Heo 	ata_eh_set_pending(ap, 1);
733cca3974eSJeff Garzik 	scsi_schedule_eh(ap->scsi_host);
734c6fd2807SJeff Garzik 
735c6fd2807SJeff Garzik 	DPRINTK("port EH scheduled\n");
736c6fd2807SJeff Garzik }
737c6fd2807SJeff Garzik 
738dbd82616STejun Heo static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
739c6fd2807SJeff Garzik {
740c6fd2807SJeff Garzik 	int tag, nr_aborted = 0;
741c6fd2807SJeff Garzik 
742c6fd2807SJeff Garzik 	WARN_ON(!ap->ops->error_handler);
743c6fd2807SJeff Garzik 
7445ddf24c5STejun Heo 	/* we're gonna abort all commands, no need for fast drain */
7455ddf24c5STejun Heo 	ata_eh_set_pending(ap, 0);
7465ddf24c5STejun Heo 
747c6fd2807SJeff Garzik 	for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
748c6fd2807SJeff Garzik 		struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
749c6fd2807SJeff Garzik 
750dbd82616STejun Heo 		if (qc && (!link || qc->dev->link == link)) {
751c6fd2807SJeff Garzik 			qc->flags |= ATA_QCFLAG_FAILED;
752c6fd2807SJeff Garzik 			ata_qc_complete(qc);
753c6fd2807SJeff Garzik 			nr_aborted++;
754c6fd2807SJeff Garzik 		}
755c6fd2807SJeff Garzik 	}
756c6fd2807SJeff Garzik 
757c6fd2807SJeff Garzik 	if (!nr_aborted)
758c6fd2807SJeff Garzik 		ata_port_schedule_eh(ap);
759c6fd2807SJeff Garzik 
760c6fd2807SJeff Garzik 	return nr_aborted;
761c6fd2807SJeff Garzik }
762c6fd2807SJeff Garzik 
763c6fd2807SJeff Garzik /**
764dbd82616STejun Heo  *	ata_link_abort - abort all qc's on the link
765dbd82616STejun Heo  *	@link: ATA link to abort qc's for
766dbd82616STejun Heo  *
767dbd82616STejun Heo  *	Abort all active qc's active on @link and schedule EH.
768dbd82616STejun Heo  *
769dbd82616STejun Heo  *	LOCKING:
770dbd82616STejun Heo  *	spin_lock_irqsave(host lock)
771dbd82616STejun Heo  *
772dbd82616STejun Heo  *	RETURNS:
773dbd82616STejun Heo  *	Number of aborted qc's.
774dbd82616STejun Heo  */
775dbd82616STejun Heo int ata_link_abort(struct ata_link *link)
776dbd82616STejun Heo {
777dbd82616STejun Heo 	return ata_do_link_abort(link->ap, link);
778dbd82616STejun Heo }
779dbd82616STejun Heo 
780dbd82616STejun Heo /**
781dbd82616STejun Heo  *	ata_port_abort - abort all qc's on the port
782dbd82616STejun Heo  *	@ap: ATA port to abort qc's for
783dbd82616STejun Heo  *
784dbd82616STejun Heo  *	Abort all active qc's of @ap and schedule EH.
785dbd82616STejun Heo  *
786dbd82616STejun Heo  *	LOCKING:
787dbd82616STejun Heo  *	spin_lock_irqsave(host_set lock)
788dbd82616STejun Heo  *
789dbd82616STejun Heo  *	RETURNS:
790dbd82616STejun Heo  *	Number of aborted qc's.
791dbd82616STejun Heo  */
792dbd82616STejun Heo int ata_port_abort(struct ata_port *ap)
793dbd82616STejun Heo {
794dbd82616STejun Heo 	return ata_do_link_abort(ap, NULL);
795dbd82616STejun Heo }
796dbd82616STejun Heo 
797dbd82616STejun Heo /**
798c6fd2807SJeff Garzik  *	__ata_port_freeze - freeze port
799c6fd2807SJeff Garzik  *	@ap: ATA port to freeze
800c6fd2807SJeff Garzik  *
801c6fd2807SJeff Garzik  *	This function is called when HSM violation or some other
802c6fd2807SJeff Garzik  *	condition disrupts normal operation of the port.  Frozen port
803c6fd2807SJeff Garzik  *	is not allowed to perform any operation until the port is
804c6fd2807SJeff Garzik  *	thawed, which usually follows a successful reset.
805c6fd2807SJeff Garzik  *
806c6fd2807SJeff Garzik  *	ap->ops->freeze() callback can be used for freezing the port
807c6fd2807SJeff Garzik  *	hardware-wise (e.g. mask interrupt and stop DMA engine).  If a
808c6fd2807SJeff Garzik  *	port cannot be frozen hardware-wise, the interrupt handler
809c6fd2807SJeff Garzik  *	must ack and clear interrupts unconditionally while the port
810c6fd2807SJeff Garzik  *	is frozen.
811c6fd2807SJeff Garzik  *
812c6fd2807SJeff Garzik  *	LOCKING:
813cca3974eSJeff Garzik  *	spin_lock_irqsave(host lock)
814c6fd2807SJeff Garzik  */
815c6fd2807SJeff Garzik static void __ata_port_freeze(struct ata_port *ap)
816c6fd2807SJeff Garzik {
817c6fd2807SJeff Garzik 	WARN_ON(!ap->ops->error_handler);
818c6fd2807SJeff Garzik 
819c6fd2807SJeff Garzik 	if (ap->ops->freeze)
820c6fd2807SJeff Garzik 		ap->ops->freeze(ap);
821c6fd2807SJeff Garzik 
822c6fd2807SJeff Garzik 	ap->pflags |= ATA_PFLAG_FROZEN;
823c6fd2807SJeff Garzik 
82444877b4eSTejun Heo 	DPRINTK("ata%u port frozen\n", ap->print_id);
825c6fd2807SJeff Garzik }
826c6fd2807SJeff Garzik 
827c6fd2807SJeff Garzik /**
828c6fd2807SJeff Garzik  *	ata_port_freeze - abort & freeze port
829c6fd2807SJeff Garzik  *	@ap: ATA port to freeze
830c6fd2807SJeff Garzik  *
831c6fd2807SJeff Garzik  *	Abort and freeze @ap.
832c6fd2807SJeff Garzik  *
833c6fd2807SJeff Garzik  *	LOCKING:
834cca3974eSJeff Garzik  *	spin_lock_irqsave(host lock)
835c6fd2807SJeff Garzik  *
836c6fd2807SJeff Garzik  *	RETURNS:
837c6fd2807SJeff Garzik  *	Number of aborted commands.
838c6fd2807SJeff Garzik  */
839c6fd2807SJeff Garzik int ata_port_freeze(struct ata_port *ap)
840c6fd2807SJeff Garzik {
841c6fd2807SJeff Garzik 	int nr_aborted;
842c6fd2807SJeff Garzik 
843c6fd2807SJeff Garzik 	WARN_ON(!ap->ops->error_handler);
844c6fd2807SJeff Garzik 
845c6fd2807SJeff Garzik 	nr_aborted = ata_port_abort(ap);
846c6fd2807SJeff Garzik 	__ata_port_freeze(ap);
847c6fd2807SJeff Garzik 
848c6fd2807SJeff Garzik 	return nr_aborted;
849c6fd2807SJeff Garzik }
850c6fd2807SJeff Garzik 
851c6fd2807SJeff Garzik /**
8527d77b247STejun Heo  *	sata_async_notification - SATA async notification handler
8537d77b247STejun Heo  *	@ap: ATA port where async notification is received
8547d77b247STejun Heo  *
8557d77b247STejun Heo  *	Handler to be called when async notification via SDB FIS is
8567d77b247STejun Heo  *	received.  This function schedules EH if necessary.
8577d77b247STejun Heo  *
8587d77b247STejun Heo  *	LOCKING:
8597d77b247STejun Heo  *	spin_lock_irqsave(host lock)
8607d77b247STejun Heo  *
8617d77b247STejun Heo  *	RETURNS:
8627d77b247STejun Heo  *	1 if EH is scheduled, 0 otherwise.
8637d77b247STejun Heo  */
8647d77b247STejun Heo int sata_async_notification(struct ata_port *ap)
8657d77b247STejun Heo {
8667d77b247STejun Heo 	u32 sntf;
8677d77b247STejun Heo 	int rc;
8687d77b247STejun Heo 
8697d77b247STejun Heo 	if (!(ap->flags & ATA_FLAG_AN))
8707d77b247STejun Heo 		return 0;
8717d77b247STejun Heo 
8727d77b247STejun Heo 	rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
8737d77b247STejun Heo 	if (rc == 0)
8747d77b247STejun Heo 		sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
8757d77b247STejun Heo 
8767d77b247STejun Heo 	if (!ap->nr_pmp_links || rc) {
8777d77b247STejun Heo 		/* PMP is not attached or SNTF is not available */
8787d77b247STejun Heo 		if (!ap->nr_pmp_links) {
8797d77b247STejun Heo 			/* PMP is not attached.  Check whether ATAPI
8807d77b247STejun Heo 			 * AN is configured.  If so, notify media
8817d77b247STejun Heo 			 * change.
8827d77b247STejun Heo 			 */
8837d77b247STejun Heo 			struct ata_device *dev = ap->link.device;
8847d77b247STejun Heo 
8857d77b247STejun Heo 			if ((dev->class == ATA_DEV_ATAPI) &&
8867d77b247STejun Heo 			    (dev->flags & ATA_DFLAG_AN))
8877d77b247STejun Heo 				ata_scsi_media_change_notify(dev);
8887d77b247STejun Heo 			return 0;
8897d77b247STejun Heo 		} else {
8907d77b247STejun Heo 			/* PMP is attached but SNTF is not available.
8917d77b247STejun Heo 			 * ATAPI async media change notification is
8927d77b247STejun Heo 			 * not used.  The PMP must be reporting PHY
8937d77b247STejun Heo 			 * status change, schedule EH.
8947d77b247STejun Heo 			 */
8957d77b247STejun Heo 			ata_port_schedule_eh(ap);
8967d77b247STejun Heo 			return 1;
8977d77b247STejun Heo 		}
8987d77b247STejun Heo 	} else {
8997d77b247STejun Heo 		/* PMP is attached and SNTF is available */
9007d77b247STejun Heo 		struct ata_link *link;
9017d77b247STejun Heo 
9027d77b247STejun Heo 		/* check and notify ATAPI AN */
9037d77b247STejun Heo 		ata_port_for_each_link(link, ap) {
9047d77b247STejun Heo 			if (!(sntf & (1 << link->pmp)))
9057d77b247STejun Heo 				continue;
9067d77b247STejun Heo 
9077d77b247STejun Heo 			if ((link->device->class == ATA_DEV_ATAPI) &&
9087d77b247STejun Heo 			    (link->device->flags & ATA_DFLAG_AN))
9097d77b247STejun Heo 				ata_scsi_media_change_notify(link->device);
9107d77b247STejun Heo 		}
9117d77b247STejun Heo 
9127d77b247STejun Heo 		/* If PMP is reporting that PHY status of some
9137d77b247STejun Heo 		 * downstream ports has changed, schedule EH.
9147d77b247STejun Heo 		 */
9157d77b247STejun Heo 		if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
9167d77b247STejun Heo 			ata_port_schedule_eh(ap);
9177d77b247STejun Heo 			return 1;
9187d77b247STejun Heo 		}
9197d77b247STejun Heo 
9207d77b247STejun Heo 		return 0;
9217d77b247STejun Heo 	}
9227d77b247STejun Heo }
9237d77b247STejun Heo 
9247d77b247STejun Heo /**
925c6fd2807SJeff Garzik  *	ata_eh_freeze_port - EH helper to freeze port
926c6fd2807SJeff Garzik  *	@ap: ATA port to freeze
927c6fd2807SJeff Garzik  *
928c6fd2807SJeff Garzik  *	Freeze @ap.
929c6fd2807SJeff Garzik  *
930c6fd2807SJeff Garzik  *	LOCKING:
931c6fd2807SJeff Garzik  *	None.
932c6fd2807SJeff Garzik  */
933c6fd2807SJeff Garzik void ata_eh_freeze_port(struct ata_port *ap)
934c6fd2807SJeff Garzik {
935c6fd2807SJeff Garzik 	unsigned long flags;
936c6fd2807SJeff Garzik 
937c6fd2807SJeff Garzik 	if (!ap->ops->error_handler)
938c6fd2807SJeff Garzik 		return;
939c6fd2807SJeff Garzik 
940c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
941c6fd2807SJeff Garzik 	__ata_port_freeze(ap);
942c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
943c6fd2807SJeff Garzik }
944c6fd2807SJeff Garzik 
945c6fd2807SJeff Garzik /**
946c6fd2807SJeff Garzik  *	ata_port_thaw_port - EH helper to thaw port
947c6fd2807SJeff Garzik  *	@ap: ATA port to thaw
948c6fd2807SJeff Garzik  *
949c6fd2807SJeff Garzik  *	Thaw frozen port @ap.
950c6fd2807SJeff Garzik  *
951c6fd2807SJeff Garzik  *	LOCKING:
952c6fd2807SJeff Garzik  *	None.
953c6fd2807SJeff Garzik  */
954c6fd2807SJeff Garzik void ata_eh_thaw_port(struct ata_port *ap)
955c6fd2807SJeff Garzik {
956c6fd2807SJeff Garzik 	unsigned long flags;
957c6fd2807SJeff Garzik 
958c6fd2807SJeff Garzik 	if (!ap->ops->error_handler)
959c6fd2807SJeff Garzik 		return;
960c6fd2807SJeff Garzik 
961c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
962c6fd2807SJeff Garzik 
963c6fd2807SJeff Garzik 	ap->pflags &= ~ATA_PFLAG_FROZEN;
964c6fd2807SJeff Garzik 
965c6fd2807SJeff Garzik 	if (ap->ops->thaw)
966c6fd2807SJeff Garzik 		ap->ops->thaw(ap);
967c6fd2807SJeff Garzik 
968c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
969c6fd2807SJeff Garzik 
97044877b4eSTejun Heo 	DPRINTK("ata%u port thawed\n", ap->print_id);
971c6fd2807SJeff Garzik }
972c6fd2807SJeff Garzik 
973c6fd2807SJeff Garzik static void ata_eh_scsidone(struct scsi_cmnd *scmd)
974c6fd2807SJeff Garzik {
975c6fd2807SJeff Garzik 	/* nada */
976c6fd2807SJeff Garzik }
977c6fd2807SJeff Garzik 
978c6fd2807SJeff Garzik static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
979c6fd2807SJeff Garzik {
980c6fd2807SJeff Garzik 	struct ata_port *ap = qc->ap;
981c6fd2807SJeff Garzik 	struct scsi_cmnd *scmd = qc->scsicmd;
982c6fd2807SJeff Garzik 	unsigned long flags;
983c6fd2807SJeff Garzik 
984c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
985c6fd2807SJeff Garzik 	qc->scsidone = ata_eh_scsidone;
986c6fd2807SJeff Garzik 	__ata_qc_complete(qc);
987c6fd2807SJeff Garzik 	WARN_ON(ata_tag_valid(qc->tag));
988c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
989c6fd2807SJeff Garzik 
990c6fd2807SJeff Garzik 	scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
991c6fd2807SJeff Garzik }
992c6fd2807SJeff Garzik 
993c6fd2807SJeff Garzik /**
994c6fd2807SJeff Garzik  *	ata_eh_qc_complete - Complete an active ATA command from EH
995c6fd2807SJeff Garzik  *	@qc: Command to complete
996c6fd2807SJeff Garzik  *
997c6fd2807SJeff Garzik  *	Indicate to the mid and upper layers that an ATA command has
998c6fd2807SJeff Garzik  *	completed.  To be used from EH.
999c6fd2807SJeff Garzik  */
1000c6fd2807SJeff Garzik void ata_eh_qc_complete(struct ata_queued_cmd *qc)
1001c6fd2807SJeff Garzik {
1002c6fd2807SJeff Garzik 	struct scsi_cmnd *scmd = qc->scsicmd;
1003c6fd2807SJeff Garzik 	scmd->retries = scmd->allowed;
1004c6fd2807SJeff Garzik 	__ata_eh_qc_complete(qc);
1005c6fd2807SJeff Garzik }
1006c6fd2807SJeff Garzik 
1007c6fd2807SJeff Garzik /**
1008c6fd2807SJeff Garzik  *	ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
1009c6fd2807SJeff Garzik  *	@qc: Command to retry
1010c6fd2807SJeff Garzik  *
1011c6fd2807SJeff Garzik  *	Indicate to the mid and upper layers that an ATA command
1012c6fd2807SJeff Garzik  *	should be retried.  To be used from EH.
1013c6fd2807SJeff Garzik  *
1014c6fd2807SJeff Garzik  *	SCSI midlayer limits the number of retries to scmd->allowed.
1015c6fd2807SJeff Garzik  *	scmd->retries is decremented for commands which get retried
1016c6fd2807SJeff Garzik  *	due to unrelated failures (qc->err_mask is zero).
1017c6fd2807SJeff Garzik  */
1018c6fd2807SJeff Garzik void ata_eh_qc_retry(struct ata_queued_cmd *qc)
1019c6fd2807SJeff Garzik {
1020c6fd2807SJeff Garzik 	struct scsi_cmnd *scmd = qc->scsicmd;
1021c6fd2807SJeff Garzik 	if (!qc->err_mask && scmd->retries)
1022c6fd2807SJeff Garzik 		scmd->retries--;
1023c6fd2807SJeff Garzik 	__ata_eh_qc_complete(qc);
1024c6fd2807SJeff Garzik }
1025c6fd2807SJeff Garzik 
1026c6fd2807SJeff Garzik /**
1027c6fd2807SJeff Garzik  *	ata_eh_detach_dev - detach ATA device
1028c6fd2807SJeff Garzik  *	@dev: ATA device to detach
1029c6fd2807SJeff Garzik  *
1030c6fd2807SJeff Garzik  *	Detach @dev.
1031c6fd2807SJeff Garzik  *
1032c6fd2807SJeff Garzik  *	LOCKING:
1033c6fd2807SJeff Garzik  *	None.
1034c6fd2807SJeff Garzik  */
1035fb7fd614STejun Heo void ata_eh_detach_dev(struct ata_device *dev)
1036c6fd2807SJeff Garzik {
1037f58229f8STejun Heo 	struct ata_link *link = dev->link;
1038f58229f8STejun Heo 	struct ata_port *ap = link->ap;
1039c6fd2807SJeff Garzik 	unsigned long flags;
1040c6fd2807SJeff Garzik 
1041c6fd2807SJeff Garzik 	ata_dev_disable(dev);
1042c6fd2807SJeff Garzik 
1043c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
1044c6fd2807SJeff Garzik 
1045c6fd2807SJeff Garzik 	dev->flags &= ~ATA_DFLAG_DETACH;
1046c6fd2807SJeff Garzik 
1047c6fd2807SJeff Garzik 	if (ata_scsi_offline_dev(dev)) {
1048c6fd2807SJeff Garzik 		dev->flags |= ATA_DFLAG_DETACHED;
1049c6fd2807SJeff Garzik 		ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
1050c6fd2807SJeff Garzik 	}
1051c6fd2807SJeff Garzik 
1052c6fd2807SJeff Garzik 	/* clear per-dev EH actions */
1053f58229f8STejun Heo 	ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
1054f58229f8STejun Heo 	ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
1055c6fd2807SJeff Garzik 
1056c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
1057c6fd2807SJeff Garzik }
1058c6fd2807SJeff Garzik 
1059c6fd2807SJeff Garzik /**
1060c6fd2807SJeff Garzik  *	ata_eh_about_to_do - about to perform eh_action
1061955e57dfSTejun Heo  *	@link: target ATA link
1062c6fd2807SJeff Garzik  *	@dev: target ATA dev for per-dev action (can be NULL)
1063c6fd2807SJeff Garzik  *	@action: action about to be performed
1064c6fd2807SJeff Garzik  *
1065c6fd2807SJeff Garzik  *	Called just before performing EH actions to clear related bits
1066955e57dfSTejun Heo  *	in @link->eh_info such that eh actions are not unnecessarily
1067955e57dfSTejun Heo  *	repeated.
1068c6fd2807SJeff Garzik  *
1069c6fd2807SJeff Garzik  *	LOCKING:
1070c6fd2807SJeff Garzik  *	None.
1071c6fd2807SJeff Garzik  */
1072fb7fd614STejun Heo void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
1073c6fd2807SJeff Garzik 			unsigned int action)
1074c6fd2807SJeff Garzik {
1075955e57dfSTejun Heo 	struct ata_port *ap = link->ap;
1076955e57dfSTejun Heo 	struct ata_eh_info *ehi = &link->eh_info;
1077955e57dfSTejun Heo 	struct ata_eh_context *ehc = &link->eh_context;
1078c6fd2807SJeff Garzik 	unsigned long flags;
1079c6fd2807SJeff Garzik 
1080c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
1081c6fd2807SJeff Garzik 
1082955e57dfSTejun Heo 	ata_eh_clear_action(link, dev, ehi, action);
1083c6fd2807SJeff Garzik 
1084c6fd2807SJeff Garzik 	if (!(ehc->i.flags & ATA_EHI_QUIET))
1085c6fd2807SJeff Garzik 		ap->pflags |= ATA_PFLAG_RECOVERED;
1086c6fd2807SJeff Garzik 
1087c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
1088c6fd2807SJeff Garzik }
1089c6fd2807SJeff Garzik 
1090c6fd2807SJeff Garzik /**
1091c6fd2807SJeff Garzik  *	ata_eh_done - EH action complete
1092c6fd2807SJeff Garzik *	@ap: target ATA port
1093c6fd2807SJeff Garzik  *	@dev: target ATA dev for per-dev action (can be NULL)
1094c6fd2807SJeff Garzik  *	@action: action just completed
1095c6fd2807SJeff Garzik  *
1096c6fd2807SJeff Garzik  *	Called right after performing EH actions to clear related bits
1097955e57dfSTejun Heo  *	in @link->eh_context.
1098c6fd2807SJeff Garzik  *
1099c6fd2807SJeff Garzik  *	LOCKING:
1100c6fd2807SJeff Garzik  *	None.
1101c6fd2807SJeff Garzik  */
1102fb7fd614STejun Heo void ata_eh_done(struct ata_link *link, struct ata_device *dev,
1103c6fd2807SJeff Garzik 		 unsigned int action)
1104c6fd2807SJeff Garzik {
1105955e57dfSTejun Heo 	struct ata_eh_context *ehc = &link->eh_context;
11069af5c9c9STejun Heo 
1107955e57dfSTejun Heo 	ata_eh_clear_action(link, dev, &ehc->i, action);
1108c6fd2807SJeff Garzik }
1109c6fd2807SJeff Garzik 
1110c6fd2807SJeff Garzik /**
1111c6fd2807SJeff Garzik  *	ata_err_string - convert err_mask to descriptive string
1112c6fd2807SJeff Garzik  *	@err_mask: error mask to convert to string
1113c6fd2807SJeff Garzik  *
1114c6fd2807SJeff Garzik  *	Convert @err_mask to descriptive string.  Errors are
1115c6fd2807SJeff Garzik  *	prioritized according to severity and only the most severe
1116c6fd2807SJeff Garzik  *	error is reported.
1117c6fd2807SJeff Garzik  *
1118c6fd2807SJeff Garzik  *	LOCKING:
1119c6fd2807SJeff Garzik  *	None.
1120c6fd2807SJeff Garzik  *
1121c6fd2807SJeff Garzik  *	RETURNS:
1122c6fd2807SJeff Garzik  *	Descriptive string for @err_mask
1123c6fd2807SJeff Garzik  */
1124c6fd2807SJeff Garzik static const char *ata_err_string(unsigned int err_mask)
1125c6fd2807SJeff Garzik {
1126c6fd2807SJeff Garzik 	if (err_mask & AC_ERR_HOST_BUS)
1127c6fd2807SJeff Garzik 		return "host bus error";
1128c6fd2807SJeff Garzik 	if (err_mask & AC_ERR_ATA_BUS)
1129c6fd2807SJeff Garzik 		return "ATA bus error";
1130c6fd2807SJeff Garzik 	if (err_mask & AC_ERR_TIMEOUT)
1131c6fd2807SJeff Garzik 		return "timeout";
1132c6fd2807SJeff Garzik 	if (err_mask & AC_ERR_HSM)
1133c6fd2807SJeff Garzik 		return "HSM violation";
1134c6fd2807SJeff Garzik 	if (err_mask & AC_ERR_SYSTEM)
1135c6fd2807SJeff Garzik 		return "internal error";
1136c6fd2807SJeff Garzik 	if (err_mask & AC_ERR_MEDIA)
1137c6fd2807SJeff Garzik 		return "media error";
1138c6fd2807SJeff Garzik 	if (err_mask & AC_ERR_INVALID)
1139c6fd2807SJeff Garzik 		return "invalid argument";
1140c6fd2807SJeff Garzik 	if (err_mask & AC_ERR_DEV)
1141c6fd2807SJeff Garzik 		return "device error";
1142c6fd2807SJeff Garzik 	return "unknown error";
1143c6fd2807SJeff Garzik }
1144c6fd2807SJeff Garzik 
1145c6fd2807SJeff Garzik /**
1146c6fd2807SJeff Garzik  *	ata_read_log_page - read a specific log page
1147c6fd2807SJeff Garzik  *	@dev: target device
1148c6fd2807SJeff Garzik  *	@page: page to read
1149c6fd2807SJeff Garzik  *	@buf: buffer to store read page
1150c6fd2807SJeff Garzik  *	@sectors: number of sectors to read
1151c6fd2807SJeff Garzik  *
1152c6fd2807SJeff Garzik  *	Read log page using READ_LOG_EXT command.
1153c6fd2807SJeff Garzik  *
1154c6fd2807SJeff Garzik  *	LOCKING:
1155c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
1156c6fd2807SJeff Garzik  *
1157c6fd2807SJeff Garzik  *	RETURNS:
1158c6fd2807SJeff Garzik  *	0 on success, AC_ERR_* mask otherwise.
1159c6fd2807SJeff Garzik  */
1160c6fd2807SJeff Garzik static unsigned int ata_read_log_page(struct ata_device *dev,
1161c6fd2807SJeff Garzik 				      u8 page, void *buf, unsigned int sectors)
1162c6fd2807SJeff Garzik {
1163c6fd2807SJeff Garzik 	struct ata_taskfile tf;
1164c6fd2807SJeff Garzik 	unsigned int err_mask;
1165c6fd2807SJeff Garzik 
1166c6fd2807SJeff Garzik 	DPRINTK("read log page - page %d\n", page);
1167c6fd2807SJeff Garzik 
1168c6fd2807SJeff Garzik 	ata_tf_init(dev, &tf);
1169c6fd2807SJeff Garzik 	tf.command = ATA_CMD_READ_LOG_EXT;
1170c6fd2807SJeff Garzik 	tf.lbal = page;
1171c6fd2807SJeff Garzik 	tf.nsect = sectors;
1172c6fd2807SJeff Garzik 	tf.hob_nsect = sectors >> 8;
1173c6fd2807SJeff Garzik 	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
1174c6fd2807SJeff Garzik 	tf.protocol = ATA_PROT_PIO;
1175c6fd2807SJeff Garzik 
1176c6fd2807SJeff Garzik 	err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
11772b789108STejun Heo 				     buf, sectors * ATA_SECT_SIZE, 0);
1178c6fd2807SJeff Garzik 
1179c6fd2807SJeff Garzik 	DPRINTK("EXIT, err_mask=%x\n", err_mask);
1180c6fd2807SJeff Garzik 	return err_mask;
1181c6fd2807SJeff Garzik }
1182c6fd2807SJeff Garzik 
1183c6fd2807SJeff Garzik /**
1184c6fd2807SJeff Garzik  *	ata_eh_read_log_10h - Read log page 10h for NCQ error details
1185c6fd2807SJeff Garzik  *	@dev: Device to read log page 10h from
1186c6fd2807SJeff Garzik  *	@tag: Resulting tag of the failed command
1187c6fd2807SJeff Garzik  *	@tf: Resulting taskfile registers of the failed command
1188c6fd2807SJeff Garzik  *
1189c6fd2807SJeff Garzik  *	Read log page 10h to obtain NCQ error details and clear error
1190c6fd2807SJeff Garzik  *	condition.
1191c6fd2807SJeff Garzik  *
1192c6fd2807SJeff Garzik  *	LOCKING:
1193c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
1194c6fd2807SJeff Garzik  *
1195c6fd2807SJeff Garzik  *	RETURNS:
1196c6fd2807SJeff Garzik  *	0 on success, -errno otherwise.
1197c6fd2807SJeff Garzik  */
1198c6fd2807SJeff Garzik static int ata_eh_read_log_10h(struct ata_device *dev,
1199c6fd2807SJeff Garzik 			       int *tag, struct ata_taskfile *tf)
1200c6fd2807SJeff Garzik {
12019af5c9c9STejun Heo 	u8 *buf = dev->link->ap->sector_buf;
1202c6fd2807SJeff Garzik 	unsigned int err_mask;
1203c6fd2807SJeff Garzik 	u8 csum;
1204c6fd2807SJeff Garzik 	int i;
1205c6fd2807SJeff Garzik 
1206c6fd2807SJeff Garzik 	err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1);
1207c6fd2807SJeff Garzik 	if (err_mask)
1208c6fd2807SJeff Garzik 		return -EIO;
1209c6fd2807SJeff Garzik 
1210c6fd2807SJeff Garzik 	csum = 0;
1211c6fd2807SJeff Garzik 	for (i = 0; i < ATA_SECT_SIZE; i++)
1212c6fd2807SJeff Garzik 		csum += buf[i];
1213c6fd2807SJeff Garzik 	if (csum)
1214c6fd2807SJeff Garzik 		ata_dev_printk(dev, KERN_WARNING,
1215c6fd2807SJeff Garzik 			       "invalid checksum 0x%x on log page 10h\n", csum);
1216c6fd2807SJeff Garzik 
1217c6fd2807SJeff Garzik 	if (buf[0] & 0x80)
1218c6fd2807SJeff Garzik 		return -ENOENT;
1219c6fd2807SJeff Garzik 
1220c6fd2807SJeff Garzik 	*tag = buf[0] & 0x1f;
1221c6fd2807SJeff Garzik 
1222c6fd2807SJeff Garzik 	tf->command = buf[2];
1223c6fd2807SJeff Garzik 	tf->feature = buf[3];
1224c6fd2807SJeff Garzik 	tf->lbal = buf[4];
1225c6fd2807SJeff Garzik 	tf->lbam = buf[5];
1226c6fd2807SJeff Garzik 	tf->lbah = buf[6];
1227c6fd2807SJeff Garzik 	tf->device = buf[7];
1228c6fd2807SJeff Garzik 	tf->hob_lbal = buf[8];
1229c6fd2807SJeff Garzik 	tf->hob_lbam = buf[9];
1230c6fd2807SJeff Garzik 	tf->hob_lbah = buf[10];
1231c6fd2807SJeff Garzik 	tf->nsect = buf[12];
1232c6fd2807SJeff Garzik 	tf->hob_nsect = buf[13];
1233c6fd2807SJeff Garzik 
1234c6fd2807SJeff Garzik 	return 0;
1235c6fd2807SJeff Garzik }
1236c6fd2807SJeff Garzik 
1237c6fd2807SJeff Garzik /**
1238c6fd2807SJeff Garzik  *	atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
1239c6fd2807SJeff Garzik  *	@dev: device to perform REQUEST_SENSE to
1240c6fd2807SJeff Garzik  *	@sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
1241c6fd2807SJeff Garzik  *
1242c6fd2807SJeff Garzik  *	Perform ATAPI REQUEST_SENSE after the device reported CHECK
1243c6fd2807SJeff Garzik  *	SENSE.  This function is EH helper.
1244c6fd2807SJeff Garzik  *
1245c6fd2807SJeff Garzik  *	LOCKING:
1246c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
1247c6fd2807SJeff Garzik  *
1248c6fd2807SJeff Garzik  *	RETURNS:
1249c6fd2807SJeff Garzik  *	0 on success, AC_ERR_* mask on failure
1250c6fd2807SJeff Garzik  */
125156287768SAlbert Lee static unsigned int atapi_eh_request_sense(struct ata_queued_cmd *qc)
1252c6fd2807SJeff Garzik {
125356287768SAlbert Lee 	struct ata_device *dev = qc->dev;
125456287768SAlbert Lee 	unsigned char *sense_buf = qc->scsicmd->sense_buffer;
12559af5c9c9STejun Heo 	struct ata_port *ap = dev->link->ap;
1256c6fd2807SJeff Garzik 	struct ata_taskfile tf;
1257c6fd2807SJeff Garzik 	u8 cdb[ATAPI_CDB_LEN];
1258c6fd2807SJeff Garzik 
1259c6fd2807SJeff Garzik 	DPRINTK("ATAPI request sense\n");
1260c6fd2807SJeff Garzik 
1261c6fd2807SJeff Garzik 	/* FIXME: is this needed? */
1262c6fd2807SJeff Garzik 	memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
1263c6fd2807SJeff Garzik 
126456287768SAlbert Lee 	/* initialize sense_buf with the error register,
126556287768SAlbert Lee 	 * for the case where they are -not- overwritten
126656287768SAlbert Lee 	 */
1267c6fd2807SJeff Garzik 	sense_buf[0] = 0x70;
126856287768SAlbert Lee 	sense_buf[2] = qc->result_tf.feature >> 4;
126956287768SAlbert Lee 
127056287768SAlbert Lee 	/* some devices time out if garbage left in tf */
127156287768SAlbert Lee 	ata_tf_init(dev, &tf);
1272c6fd2807SJeff Garzik 
1273c6fd2807SJeff Garzik 	memset(cdb, 0, ATAPI_CDB_LEN);
1274c6fd2807SJeff Garzik 	cdb[0] = REQUEST_SENSE;
1275c6fd2807SJeff Garzik 	cdb[4] = SCSI_SENSE_BUFFERSIZE;
1276c6fd2807SJeff Garzik 
1277c6fd2807SJeff Garzik 	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1278c6fd2807SJeff Garzik 	tf.command = ATA_CMD_PACKET;
1279c6fd2807SJeff Garzik 
1280c6fd2807SJeff Garzik 	/* is it pointless to prefer PIO for "safety reasons"? */
1281c6fd2807SJeff Garzik 	if (ap->flags & ATA_FLAG_PIO_DMA) {
12820dc36888STejun Heo 		tf.protocol = ATAPI_PROT_DMA;
1283c6fd2807SJeff Garzik 		tf.feature |= ATAPI_PKT_DMA;
1284c6fd2807SJeff Garzik 	} else {
12850dc36888STejun Heo 		tf.protocol = ATAPI_PROT_PIO;
1286f2dfc1a1STejun Heo 		tf.lbam = SCSI_SENSE_BUFFERSIZE;
1287f2dfc1a1STejun Heo 		tf.lbah = 0;
1288c6fd2807SJeff Garzik 	}
1289c6fd2807SJeff Garzik 
1290c6fd2807SJeff Garzik 	return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
12912b789108STejun Heo 				 sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
1292c6fd2807SJeff Garzik }
1293c6fd2807SJeff Garzik 
1294c6fd2807SJeff Garzik /**
1295c6fd2807SJeff Garzik  *	ata_eh_analyze_serror - analyze SError for a failed port
12960260731fSTejun Heo  *	@link: ATA link to analyze SError for
1297c6fd2807SJeff Garzik  *
1298c6fd2807SJeff Garzik  *	Analyze SError if available and further determine cause of
1299c6fd2807SJeff Garzik  *	failure.
1300c6fd2807SJeff Garzik  *
1301c6fd2807SJeff Garzik  *	LOCKING:
1302c6fd2807SJeff Garzik  *	None.
1303c6fd2807SJeff Garzik  */
13040260731fSTejun Heo static void ata_eh_analyze_serror(struct ata_link *link)
1305c6fd2807SJeff Garzik {
13060260731fSTejun Heo 	struct ata_eh_context *ehc = &link->eh_context;
1307c6fd2807SJeff Garzik 	u32 serror = ehc->i.serror;
1308c6fd2807SJeff Garzik 	unsigned int err_mask = 0, action = 0;
1309f9df58cbSTejun Heo 	u32 hotplug_mask;
1310c6fd2807SJeff Garzik 
1311c6fd2807SJeff Garzik 	if (serror & SERR_PERSISTENT) {
1312c6fd2807SJeff Garzik 		err_mask |= AC_ERR_ATA_BUS;
1313cf480626STejun Heo 		action |= ATA_EH_RESET;
1314c6fd2807SJeff Garzik 	}
1315c6fd2807SJeff Garzik 	if (serror &
1316c6fd2807SJeff Garzik 	    (SERR_DATA_RECOVERED | SERR_COMM_RECOVERED | SERR_DATA)) {
1317c6fd2807SJeff Garzik 		err_mask |= AC_ERR_ATA_BUS;
1318cf480626STejun Heo 		action |= ATA_EH_RESET;
1319c6fd2807SJeff Garzik 	}
1320c6fd2807SJeff Garzik 	if (serror & SERR_PROTOCOL) {
1321c6fd2807SJeff Garzik 		err_mask |= AC_ERR_HSM;
1322cf480626STejun Heo 		action |= ATA_EH_RESET;
1323c6fd2807SJeff Garzik 	}
1324c6fd2807SJeff Garzik 	if (serror & SERR_INTERNAL) {
1325c6fd2807SJeff Garzik 		err_mask |= AC_ERR_SYSTEM;
1326cf480626STejun Heo 		action |= ATA_EH_RESET;
1327c6fd2807SJeff Garzik 	}
1328f9df58cbSTejun Heo 
1329f9df58cbSTejun Heo 	/* Determine whether a hotplug event has occurred.  Both
1330f9df58cbSTejun Heo 	 * SError.N/X are considered hotplug events for enabled or
1331f9df58cbSTejun Heo 	 * host links.  For disabled PMP links, only N bit is
1332f9df58cbSTejun Heo 	 * considered as X bit is left at 1 for link plugging.
1333f9df58cbSTejun Heo 	 */
1334f9df58cbSTejun Heo 	hotplug_mask = 0;
1335f9df58cbSTejun Heo 
1336f9df58cbSTejun Heo 	if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
1337f9df58cbSTejun Heo 		hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
1338f9df58cbSTejun Heo 	else
1339f9df58cbSTejun Heo 		hotplug_mask = SERR_PHYRDY_CHG;
1340f9df58cbSTejun Heo 
1341f9df58cbSTejun Heo 	if (serror & hotplug_mask)
1342c6fd2807SJeff Garzik 		ata_ehi_hotplugged(&ehc->i);
1343c6fd2807SJeff Garzik 
1344c6fd2807SJeff Garzik 	ehc->i.err_mask |= err_mask;
1345c6fd2807SJeff Garzik 	ehc->i.action |= action;
1346c6fd2807SJeff Garzik }
1347c6fd2807SJeff Garzik 
1348c6fd2807SJeff Garzik /**
1349c6fd2807SJeff Garzik  *	ata_eh_analyze_ncq_error - analyze NCQ error
13500260731fSTejun Heo  *	@link: ATA link to analyze NCQ error for
1351c6fd2807SJeff Garzik  *
1352c6fd2807SJeff Garzik  *	Read log page 10h, determine the offending qc and acquire
1353c6fd2807SJeff Garzik  *	error status TF.  For NCQ device errors, all LLDDs have to do
1354c6fd2807SJeff Garzik  *	is setting AC_ERR_DEV in ehi->err_mask.  This function takes
1355c6fd2807SJeff Garzik  *	care of the rest.
1356c6fd2807SJeff Garzik  *
1357c6fd2807SJeff Garzik  *	LOCKING:
1358c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
1359c6fd2807SJeff Garzik  */
13600260731fSTejun Heo static void ata_eh_analyze_ncq_error(struct ata_link *link)
1361c6fd2807SJeff Garzik {
13620260731fSTejun Heo 	struct ata_port *ap = link->ap;
13630260731fSTejun Heo 	struct ata_eh_context *ehc = &link->eh_context;
13640260731fSTejun Heo 	struct ata_device *dev = link->device;
1365c6fd2807SJeff Garzik 	struct ata_queued_cmd *qc;
1366c6fd2807SJeff Garzik 	struct ata_taskfile tf;
1367c6fd2807SJeff Garzik 	int tag, rc;
1368c6fd2807SJeff Garzik 
1369c6fd2807SJeff Garzik 	/* if frozen, we can't do much */
1370c6fd2807SJeff Garzik 	if (ap->pflags & ATA_PFLAG_FROZEN)
1371c6fd2807SJeff Garzik 		return;
1372c6fd2807SJeff Garzik 
1373c6fd2807SJeff Garzik 	/* is it NCQ device error? */
13740260731fSTejun Heo 	if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
1375c6fd2807SJeff Garzik 		return;
1376c6fd2807SJeff Garzik 
1377c6fd2807SJeff Garzik 	/* has LLDD analyzed already? */
1378c6fd2807SJeff Garzik 	for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1379c6fd2807SJeff Garzik 		qc = __ata_qc_from_tag(ap, tag);
1380c6fd2807SJeff Garzik 
1381c6fd2807SJeff Garzik 		if (!(qc->flags & ATA_QCFLAG_FAILED))
1382c6fd2807SJeff Garzik 			continue;
1383c6fd2807SJeff Garzik 
1384c6fd2807SJeff Garzik 		if (qc->err_mask)
1385c6fd2807SJeff Garzik 			return;
1386c6fd2807SJeff Garzik 	}
1387c6fd2807SJeff Garzik 
1388c6fd2807SJeff Garzik 	/* okay, this error is ours */
1389c6fd2807SJeff Garzik 	rc = ata_eh_read_log_10h(dev, &tag, &tf);
1390c6fd2807SJeff Garzik 	if (rc) {
13910260731fSTejun Heo 		ata_link_printk(link, KERN_ERR, "failed to read log page 10h "
1392c6fd2807SJeff Garzik 				"(errno=%d)\n", rc);
1393c6fd2807SJeff Garzik 		return;
1394c6fd2807SJeff Garzik 	}
1395c6fd2807SJeff Garzik 
13960260731fSTejun Heo 	if (!(link->sactive & (1 << tag))) {
13970260731fSTejun Heo 		ata_link_printk(link, KERN_ERR, "log page 10h reported "
1398c6fd2807SJeff Garzik 				"inactive tag %d\n", tag);
1399c6fd2807SJeff Garzik 		return;
1400c6fd2807SJeff Garzik 	}
1401c6fd2807SJeff Garzik 
1402c6fd2807SJeff Garzik 	/* we've got the perpetrator, condemn it */
1403c6fd2807SJeff Garzik 	qc = __ata_qc_from_tag(ap, tag);
1404c6fd2807SJeff Garzik 	memcpy(&qc->result_tf, &tf, sizeof(tf));
14055335b729STejun Heo 	qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
1406c6fd2807SJeff Garzik 	ehc->i.err_mask &= ~AC_ERR_DEV;
1407c6fd2807SJeff Garzik }
1408c6fd2807SJeff Garzik 
1409c6fd2807SJeff Garzik /**
1410c6fd2807SJeff Garzik  *	ata_eh_analyze_tf - analyze taskfile of a failed qc
1411c6fd2807SJeff Garzik  *	@qc: qc to analyze
1412c6fd2807SJeff Garzik  *	@tf: Taskfile registers to analyze
1413c6fd2807SJeff Garzik  *
1414c6fd2807SJeff Garzik  *	Analyze taskfile of @qc and further determine cause of
1415c6fd2807SJeff Garzik  *	failure.  This function also requests ATAPI sense data if
1416c6fd2807SJeff Garzik  *	avaliable.
1417c6fd2807SJeff Garzik  *
1418c6fd2807SJeff Garzik  *	LOCKING:
1419c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
1420c6fd2807SJeff Garzik  *
1421c6fd2807SJeff Garzik  *	RETURNS:
1422c6fd2807SJeff Garzik  *	Determined recovery action
1423c6fd2807SJeff Garzik  */
1424c6fd2807SJeff Garzik static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
1425c6fd2807SJeff Garzik 				      const struct ata_taskfile *tf)
1426c6fd2807SJeff Garzik {
1427c6fd2807SJeff Garzik 	unsigned int tmp, action = 0;
1428c6fd2807SJeff Garzik 	u8 stat = tf->command, err = tf->feature;
1429c6fd2807SJeff Garzik 
1430c6fd2807SJeff Garzik 	if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
1431c6fd2807SJeff Garzik 		qc->err_mask |= AC_ERR_HSM;
1432cf480626STejun Heo 		return ATA_EH_RESET;
1433c6fd2807SJeff Garzik 	}
1434c6fd2807SJeff Garzik 
1435a51d644aSTejun Heo 	if (stat & (ATA_ERR | ATA_DF))
1436a51d644aSTejun Heo 		qc->err_mask |= AC_ERR_DEV;
1437a51d644aSTejun Heo 	else
1438c6fd2807SJeff Garzik 		return 0;
1439c6fd2807SJeff Garzik 
1440c6fd2807SJeff Garzik 	switch (qc->dev->class) {
1441c6fd2807SJeff Garzik 	case ATA_DEV_ATA:
1442c6fd2807SJeff Garzik 		if (err & ATA_ICRC)
1443c6fd2807SJeff Garzik 			qc->err_mask |= AC_ERR_ATA_BUS;
1444c6fd2807SJeff Garzik 		if (err & ATA_UNC)
1445c6fd2807SJeff Garzik 			qc->err_mask |= AC_ERR_MEDIA;
1446c6fd2807SJeff Garzik 		if (err & ATA_IDNF)
1447c6fd2807SJeff Garzik 			qc->err_mask |= AC_ERR_INVALID;
1448c6fd2807SJeff Garzik 		break;
1449c6fd2807SJeff Garzik 
1450c6fd2807SJeff Garzik 	case ATA_DEV_ATAPI:
1451a569a30dSTejun Heo 		if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
145256287768SAlbert Lee 			tmp = atapi_eh_request_sense(qc);
1453c6fd2807SJeff Garzik 			if (!tmp) {
1454a569a30dSTejun Heo 				/* ATA_QCFLAG_SENSE_VALID is used to
1455a569a30dSTejun Heo 				 * tell atapi_qc_complete() that sense
1456a569a30dSTejun Heo 				 * data is already valid.
1457c6fd2807SJeff Garzik 				 *
1458c6fd2807SJeff Garzik 				 * TODO: interpret sense data and set
1459c6fd2807SJeff Garzik 				 * appropriate err_mask.
1460c6fd2807SJeff Garzik 				 */
1461c6fd2807SJeff Garzik 				qc->flags |= ATA_QCFLAG_SENSE_VALID;
1462c6fd2807SJeff Garzik 			} else
1463c6fd2807SJeff Garzik 				qc->err_mask |= tmp;
1464c6fd2807SJeff Garzik 		}
1465a569a30dSTejun Heo 	}
1466c6fd2807SJeff Garzik 
1467c6fd2807SJeff Garzik 	if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
1468cf480626STejun Heo 		action |= ATA_EH_RESET;
1469c6fd2807SJeff Garzik 
1470c6fd2807SJeff Garzik 	return action;
1471c6fd2807SJeff Garzik }
1472c6fd2807SJeff Garzik 
147376326ac1STejun Heo static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
147476326ac1STejun Heo 				   int *xfer_ok)
1475c6fd2807SJeff Garzik {
147676326ac1STejun Heo 	int base = 0;
147776326ac1STejun Heo 
147876326ac1STejun Heo 	if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
147976326ac1STejun Heo 		*xfer_ok = 1;
148076326ac1STejun Heo 
148176326ac1STejun Heo 	if (!*xfer_ok)
148275f9cafcSTejun Heo 		base = ATA_ECAT_DUBIOUS_NONE;
148376326ac1STejun Heo 
14847d47e8d4STejun Heo 	if (err_mask & AC_ERR_ATA_BUS)
148576326ac1STejun Heo 		return base + ATA_ECAT_ATA_BUS;
1486c6fd2807SJeff Garzik 
14877d47e8d4STejun Heo 	if (err_mask & AC_ERR_TIMEOUT)
148876326ac1STejun Heo 		return base + ATA_ECAT_TOUT_HSM;
14897d47e8d4STejun Heo 
14903884f7b0STejun Heo 	if (eflags & ATA_EFLAG_IS_IO) {
14917d47e8d4STejun Heo 		if (err_mask & AC_ERR_HSM)
149276326ac1STejun Heo 			return base + ATA_ECAT_TOUT_HSM;
14937d47e8d4STejun Heo 		if ((err_mask &
14947d47e8d4STejun Heo 		     (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
149576326ac1STejun Heo 			return base + ATA_ECAT_UNK_DEV;
1496c6fd2807SJeff Garzik 	}
1497c6fd2807SJeff Garzik 
1498c6fd2807SJeff Garzik 	return 0;
1499c6fd2807SJeff Garzik }
1500c6fd2807SJeff Garzik 
15017d47e8d4STejun Heo struct speed_down_verdict_arg {
1502c6fd2807SJeff Garzik 	u64 since;
150376326ac1STejun Heo 	int xfer_ok;
15043884f7b0STejun Heo 	int nr_errors[ATA_ECAT_NR];
1505c6fd2807SJeff Garzik };
1506c6fd2807SJeff Garzik 
15077d47e8d4STejun Heo static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
1508c6fd2807SJeff Garzik {
15097d47e8d4STejun Heo 	struct speed_down_verdict_arg *arg = void_arg;
151076326ac1STejun Heo 	int cat;
1511c6fd2807SJeff Garzik 
1512c6fd2807SJeff Garzik 	if (ent->timestamp < arg->since)
1513c6fd2807SJeff Garzik 		return -1;
1514c6fd2807SJeff Garzik 
151576326ac1STejun Heo 	cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
151676326ac1STejun Heo 				      &arg->xfer_ok);
15177d47e8d4STejun Heo 	arg->nr_errors[cat]++;
151876326ac1STejun Heo 
1519c6fd2807SJeff Garzik 	return 0;
1520c6fd2807SJeff Garzik }
1521c6fd2807SJeff Garzik 
1522c6fd2807SJeff Garzik /**
15237d47e8d4STejun Heo  *	ata_eh_speed_down_verdict - Determine speed down verdict
1524c6fd2807SJeff Garzik  *	@dev: Device of interest
1525c6fd2807SJeff Garzik  *
1526c6fd2807SJeff Garzik  *	This function examines error ring of @dev and determines
15277d47e8d4STejun Heo  *	whether NCQ needs to be turned off, transfer speed should be
15287d47e8d4STejun Heo  *	stepped down, or falling back to PIO is necessary.
1529c6fd2807SJeff Garzik  *
15303884f7b0STejun Heo  *	ECAT_ATA_BUS	: ATA_BUS error for any command
1531c6fd2807SJeff Garzik  *
15323884f7b0STejun Heo  *	ECAT_TOUT_HSM	: TIMEOUT for any command or HSM violation for
15333884f7b0STejun Heo  *			  IO commands
15347d47e8d4STejun Heo  *
15353884f7b0STejun Heo  *	ECAT_UNK_DEV	: Unknown DEV error for IO commands
1536c6fd2807SJeff Garzik  *
153776326ac1STejun Heo  *	ECAT_DUBIOUS_*	: Identical to above three but occurred while
153876326ac1STejun Heo  *			  data transfer hasn't been verified.
153976326ac1STejun Heo  *
15403884f7b0STejun Heo  *	Verdicts are
15417d47e8d4STejun Heo  *
15423884f7b0STejun Heo  *	NCQ_OFF		: Turn off NCQ.
15437d47e8d4STejun Heo  *
15443884f7b0STejun Heo  *	SPEED_DOWN	: Speed down transfer speed but don't fall back
15453884f7b0STejun Heo  *			  to PIO.
15463884f7b0STejun Heo  *
15473884f7b0STejun Heo  *	FALLBACK_TO_PIO	: Fall back to PIO.
15483884f7b0STejun Heo  *
15493884f7b0STejun Heo  *	Even if multiple verdicts are returned, only one action is
155076326ac1STejun Heo  *	taken per error.  An action triggered by non-DUBIOUS errors
155176326ac1STejun Heo  *	clears ering, while one triggered by DUBIOUS_* errors doesn't.
155276326ac1STejun Heo  *	This is to expedite speed down decisions right after device is
155376326ac1STejun Heo  *	initially configured.
15543884f7b0STejun Heo  *
155576326ac1STejun Heo  *	The followings are speed down rules.  #1 and #2 deal with
155676326ac1STejun Heo  *	DUBIOUS errors.
155776326ac1STejun Heo  *
155876326ac1STejun Heo  *	1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors
155976326ac1STejun Heo  *	   occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO.
156076326ac1STejun Heo  *
156176326ac1STejun Heo  *	2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors
156276326ac1STejun Heo  *	   occurred during last 5 mins, NCQ_OFF.
156376326ac1STejun Heo  *
156476326ac1STejun Heo  *	3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
15653884f7b0STejun Heo  *	   ocurred during last 5 mins, FALLBACK_TO_PIO
15663884f7b0STejun Heo  *
156776326ac1STejun Heo  *	4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
15683884f7b0STejun Heo  *	   during last 10 mins, NCQ_OFF.
15693884f7b0STejun Heo  *
157076326ac1STejun Heo  *	5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6
15713884f7b0STejun Heo  *	   UNK_DEV errors occurred during last 10 mins, SPEED_DOWN.
15727d47e8d4STejun Heo  *
1573c6fd2807SJeff Garzik  *	LOCKING:
1574c6fd2807SJeff Garzik  *	Inherited from caller.
1575c6fd2807SJeff Garzik  *
1576c6fd2807SJeff Garzik  *	RETURNS:
15777d47e8d4STejun Heo  *	OR of ATA_EH_SPDN_* flags.
1578c6fd2807SJeff Garzik  */
15797d47e8d4STejun Heo static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
1580c6fd2807SJeff Garzik {
15817d47e8d4STejun Heo 	const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
15827d47e8d4STejun Heo 	u64 j64 = get_jiffies_64();
15837d47e8d4STejun Heo 	struct speed_down_verdict_arg arg;
15847d47e8d4STejun Heo 	unsigned int verdict = 0;
1585c6fd2807SJeff Garzik 
15863884f7b0STejun Heo 	/* scan past 5 mins of error history */
15873884f7b0STejun Heo 	memset(&arg, 0, sizeof(arg));
15883884f7b0STejun Heo 	arg.since = j64 - min(j64, j5mins);
15893884f7b0STejun Heo 	ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
15903884f7b0STejun Heo 
159176326ac1STejun Heo 	if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
159276326ac1STejun Heo 	    arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
159376326ac1STejun Heo 		verdict |= ATA_EH_SPDN_SPEED_DOWN |
159476326ac1STejun Heo 			ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
159576326ac1STejun Heo 
159676326ac1STejun Heo 	if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
159776326ac1STejun Heo 	    arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
159876326ac1STejun Heo 		verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
159976326ac1STejun Heo 
16003884f7b0STejun Heo 	if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
16013884f7b0STejun Heo 	    arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1602663f99b8STejun Heo 	    arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
16033884f7b0STejun Heo 		verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
16043884f7b0STejun Heo 
16057d47e8d4STejun Heo 	/* scan past 10 mins of error history */
1606c6fd2807SJeff Garzik 	memset(&arg, 0, sizeof(arg));
16077d47e8d4STejun Heo 	arg.since = j64 - min(j64, j10mins);
16087d47e8d4STejun Heo 	ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1609c6fd2807SJeff Garzik 
16103884f7b0STejun Heo 	if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
16113884f7b0STejun Heo 	    arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
16127d47e8d4STejun Heo 		verdict |= ATA_EH_SPDN_NCQ_OFF;
16133884f7b0STejun Heo 
16143884f7b0STejun Heo 	if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
16153884f7b0STejun Heo 	    arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
1616663f99b8STejun Heo 	    arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
16177d47e8d4STejun Heo 		verdict |= ATA_EH_SPDN_SPEED_DOWN;
1618c6fd2807SJeff Garzik 
16197d47e8d4STejun Heo 	return verdict;
1620c6fd2807SJeff Garzik }
1621c6fd2807SJeff Garzik 
1622c6fd2807SJeff Garzik /**
1623c6fd2807SJeff Garzik  *	ata_eh_speed_down - record error and speed down if necessary
1624c6fd2807SJeff Garzik  *	@dev: Failed device
16253884f7b0STejun Heo  *	@eflags: mask of ATA_EFLAG_* flags
1626c6fd2807SJeff Garzik  *	@err_mask: err_mask of the error
1627c6fd2807SJeff Garzik  *
1628c6fd2807SJeff Garzik  *	Record error and examine error history to determine whether
1629c6fd2807SJeff Garzik  *	adjusting transmission speed is necessary.  It also sets
1630c6fd2807SJeff Garzik  *	transmission limits appropriately if such adjustment is
1631c6fd2807SJeff Garzik  *	necessary.
1632c6fd2807SJeff Garzik  *
1633c6fd2807SJeff Garzik  *	LOCKING:
1634c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
1635c6fd2807SJeff Garzik  *
1636c6fd2807SJeff Garzik  *	RETURNS:
16377d47e8d4STejun Heo  *	Determined recovery action.
1638c6fd2807SJeff Garzik  */
16393884f7b0STejun Heo static unsigned int ata_eh_speed_down(struct ata_device *dev,
16403884f7b0STejun Heo 				unsigned int eflags, unsigned int err_mask)
1641c6fd2807SJeff Garzik {
16423884f7b0STejun Heo 	struct ata_link *link = dev->link;
164376326ac1STejun Heo 	int xfer_ok = 0;
16447d47e8d4STejun Heo 	unsigned int verdict;
16457d47e8d4STejun Heo 	unsigned int action = 0;
16467d47e8d4STejun Heo 
16477d47e8d4STejun Heo 	/* don't bother if Cat-0 error */
164876326ac1STejun Heo 	if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
1649c6fd2807SJeff Garzik 		return 0;
1650c6fd2807SJeff Garzik 
1651c6fd2807SJeff Garzik 	/* record error and determine whether speed down is necessary */
16523884f7b0STejun Heo 	ata_ering_record(&dev->ering, eflags, err_mask);
16537d47e8d4STejun Heo 	verdict = ata_eh_speed_down_verdict(dev);
1654c6fd2807SJeff Garzik 
16557d47e8d4STejun Heo 	/* turn off NCQ? */
16567d47e8d4STejun Heo 	if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
16577d47e8d4STejun Heo 	    (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
16587d47e8d4STejun Heo 			   ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
16597d47e8d4STejun Heo 		dev->flags |= ATA_DFLAG_NCQ_OFF;
16607d47e8d4STejun Heo 		ata_dev_printk(dev, KERN_WARNING,
16617d47e8d4STejun Heo 			       "NCQ disabled due to excessive errors\n");
16627d47e8d4STejun Heo 		goto done;
16637d47e8d4STejun Heo 	}
1664c6fd2807SJeff Garzik 
16657d47e8d4STejun Heo 	/* speed down? */
16667d47e8d4STejun Heo 	if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
1667c6fd2807SJeff Garzik 		/* speed down SATA link speed if possible */
16683884f7b0STejun Heo 		if (sata_down_spd_limit(link) == 0) {
1669cf480626STejun Heo 			action |= ATA_EH_RESET;
16707d47e8d4STejun Heo 			goto done;
16717d47e8d4STejun Heo 		}
1672c6fd2807SJeff Garzik 
1673c6fd2807SJeff Garzik 		/* lower transfer mode */
16747d47e8d4STejun Heo 		if (dev->spdn_cnt < 2) {
16757d47e8d4STejun Heo 			static const int dma_dnxfer_sel[] =
16767d47e8d4STejun Heo 				{ ATA_DNXFER_DMA, ATA_DNXFER_40C };
16777d47e8d4STejun Heo 			static const int pio_dnxfer_sel[] =
16787d47e8d4STejun Heo 				{ ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
16797d47e8d4STejun Heo 			int sel;
1680c6fd2807SJeff Garzik 
16817d47e8d4STejun Heo 			if (dev->xfer_shift != ATA_SHIFT_PIO)
16827d47e8d4STejun Heo 				sel = dma_dnxfer_sel[dev->spdn_cnt];
16837d47e8d4STejun Heo 			else
16847d47e8d4STejun Heo 				sel = pio_dnxfer_sel[dev->spdn_cnt];
16857d47e8d4STejun Heo 
16867d47e8d4STejun Heo 			dev->spdn_cnt++;
16877d47e8d4STejun Heo 
16887d47e8d4STejun Heo 			if (ata_down_xfermask_limit(dev, sel) == 0) {
1689cf480626STejun Heo 				action |= ATA_EH_RESET;
16907d47e8d4STejun Heo 				goto done;
16917d47e8d4STejun Heo 			}
16927d47e8d4STejun Heo 		}
16937d47e8d4STejun Heo 	}
16947d47e8d4STejun Heo 
16957d47e8d4STejun Heo 	/* Fall back to PIO?  Slowing down to PIO is meaningless for
1696663f99b8STejun Heo 	 * SATA ATA devices.  Consider it only for PATA and SATAPI.
16977d47e8d4STejun Heo 	 */
16987d47e8d4STejun Heo 	if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
1699663f99b8STejun Heo 	    (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) &&
17007d47e8d4STejun Heo 	    (dev->xfer_shift != ATA_SHIFT_PIO)) {
17017d47e8d4STejun Heo 		if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
17027d47e8d4STejun Heo 			dev->spdn_cnt = 0;
1703cf480626STejun Heo 			action |= ATA_EH_RESET;
17047d47e8d4STejun Heo 			goto done;
17057d47e8d4STejun Heo 		}
17067d47e8d4STejun Heo 	}
17077d47e8d4STejun Heo 
1708c6fd2807SJeff Garzik 	return 0;
17097d47e8d4STejun Heo  done:
17107d47e8d4STejun Heo 	/* device has been slowed down, blow error history */
171176326ac1STejun Heo 	if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS))
17127d47e8d4STejun Heo 		ata_ering_clear(&dev->ering);
17137d47e8d4STejun Heo 	return action;
1714c6fd2807SJeff Garzik }
1715c6fd2807SJeff Garzik 
1716c6fd2807SJeff Garzik /**
17179b1e2658STejun Heo  *	ata_eh_link_autopsy - analyze error and determine recovery action
17189b1e2658STejun Heo  *	@link: host link to perform autopsy on
1719c6fd2807SJeff Garzik  *
17200260731fSTejun Heo  *	Analyze why @link failed and determine which recovery actions
17210260731fSTejun Heo  *	are needed.  This function also sets more detailed AC_ERR_*
17220260731fSTejun Heo  *	values and fills sense data for ATAPI CHECK SENSE.
1723c6fd2807SJeff Garzik  *
1724c6fd2807SJeff Garzik  *	LOCKING:
1725c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
1726c6fd2807SJeff Garzik  */
17279b1e2658STejun Heo static void ata_eh_link_autopsy(struct ata_link *link)
1728c6fd2807SJeff Garzik {
17290260731fSTejun Heo 	struct ata_port *ap = link->ap;
1730936fd732STejun Heo 	struct ata_eh_context *ehc = &link->eh_context;
1731dfcc173dSTejun Heo 	struct ata_device *dev;
17323884f7b0STejun Heo 	unsigned int all_err_mask = 0, eflags = 0;
17333884f7b0STejun Heo 	int tag;
1734c6fd2807SJeff Garzik 	u32 serror;
1735c6fd2807SJeff Garzik 	int rc;
1736c6fd2807SJeff Garzik 
1737c6fd2807SJeff Garzik 	DPRINTK("ENTER\n");
1738c6fd2807SJeff Garzik 
1739c6fd2807SJeff Garzik 	if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
1740c6fd2807SJeff Garzik 		return;
1741c6fd2807SJeff Garzik 
1742c6fd2807SJeff Garzik 	/* obtain and analyze SError */
1743936fd732STejun Heo 	rc = sata_scr_read(link, SCR_ERROR, &serror);
1744c6fd2807SJeff Garzik 	if (rc == 0) {
1745c6fd2807SJeff Garzik 		ehc->i.serror |= serror;
17460260731fSTejun Heo 		ata_eh_analyze_serror(link);
17474e57c517STejun Heo 	} else if (rc != -EOPNOTSUPP) {
1748cf480626STejun Heo 		/* SError read failed, force reset and probing */
1749b558edddSTejun Heo 		ehc->i.probe_mask |= ATA_ALL_DEVICES;
1750cf480626STejun Heo 		ehc->i.action |= ATA_EH_RESET;
17514e57c517STejun Heo 		ehc->i.err_mask |= AC_ERR_OTHER;
17524e57c517STejun Heo 	}
1753c6fd2807SJeff Garzik 
1754c6fd2807SJeff Garzik 	/* analyze NCQ failure */
17550260731fSTejun Heo 	ata_eh_analyze_ncq_error(link);
1756c6fd2807SJeff Garzik 
1757c6fd2807SJeff Garzik 	/* any real error trumps AC_ERR_OTHER */
1758c6fd2807SJeff Garzik 	if (ehc->i.err_mask & ~AC_ERR_OTHER)
1759c6fd2807SJeff Garzik 		ehc->i.err_mask &= ~AC_ERR_OTHER;
1760c6fd2807SJeff Garzik 
1761c6fd2807SJeff Garzik 	all_err_mask |= ehc->i.err_mask;
1762c6fd2807SJeff Garzik 
1763c6fd2807SJeff Garzik 	for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1764c6fd2807SJeff Garzik 		struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1765c6fd2807SJeff Garzik 
17660260731fSTejun Heo 		if (!(qc->flags & ATA_QCFLAG_FAILED) || qc->dev->link != link)
1767c6fd2807SJeff Garzik 			continue;
1768c6fd2807SJeff Garzik 
1769c6fd2807SJeff Garzik 		/* inherit upper level err_mask */
1770c6fd2807SJeff Garzik 		qc->err_mask |= ehc->i.err_mask;
1771c6fd2807SJeff Garzik 
1772c6fd2807SJeff Garzik 		/* analyze TF */
1773c6fd2807SJeff Garzik 		ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
1774c6fd2807SJeff Garzik 
1775c6fd2807SJeff Garzik 		/* DEV errors are probably spurious in case of ATA_BUS error */
1776c6fd2807SJeff Garzik 		if (qc->err_mask & AC_ERR_ATA_BUS)
1777c6fd2807SJeff Garzik 			qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
1778c6fd2807SJeff Garzik 					  AC_ERR_INVALID);
1779c6fd2807SJeff Garzik 
1780c6fd2807SJeff Garzik 		/* any real error trumps unknown error */
1781c6fd2807SJeff Garzik 		if (qc->err_mask & ~AC_ERR_OTHER)
1782c6fd2807SJeff Garzik 			qc->err_mask &= ~AC_ERR_OTHER;
1783c6fd2807SJeff Garzik 
1784c6fd2807SJeff Garzik 		/* SENSE_VALID trumps dev/unknown error and revalidation */
1785f90f0828STejun Heo 		if (qc->flags & ATA_QCFLAG_SENSE_VALID)
1786c6fd2807SJeff Garzik 			qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
1787c6fd2807SJeff Garzik 
178803faab78STejun Heo 		/* determine whether the command is worth retrying */
178903faab78STejun Heo 		if (!(qc->err_mask & AC_ERR_INVALID) &&
179003faab78STejun Heo 		    ((qc->flags & ATA_QCFLAG_IO) || qc->err_mask != AC_ERR_DEV))
179103faab78STejun Heo 			qc->flags |= ATA_QCFLAG_RETRY;
179203faab78STejun Heo 
1793c6fd2807SJeff Garzik 		/* accumulate error info */
1794c6fd2807SJeff Garzik 		ehc->i.dev = qc->dev;
1795c6fd2807SJeff Garzik 		all_err_mask |= qc->err_mask;
1796c6fd2807SJeff Garzik 		if (qc->flags & ATA_QCFLAG_IO)
17973884f7b0STejun Heo 			eflags |= ATA_EFLAG_IS_IO;
1798c6fd2807SJeff Garzik 	}
1799c6fd2807SJeff Garzik 
1800c6fd2807SJeff Garzik 	/* enforce default EH actions */
1801c6fd2807SJeff Garzik 	if (ap->pflags & ATA_PFLAG_FROZEN ||
1802c6fd2807SJeff Garzik 	    all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
1803cf480626STejun Heo 		ehc->i.action |= ATA_EH_RESET;
18043884f7b0STejun Heo 	else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) ||
18053884f7b0STejun Heo 		 (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV)))
1806c6fd2807SJeff Garzik 		ehc->i.action |= ATA_EH_REVALIDATE;
1807c6fd2807SJeff Garzik 
1808dfcc173dSTejun Heo 	/* If we have offending qcs and the associated failed device,
1809dfcc173dSTejun Heo 	 * perform per-dev EH action only on the offending device.
1810dfcc173dSTejun Heo 	 */
1811c6fd2807SJeff Garzik 	if (ehc->i.dev) {
1812c6fd2807SJeff Garzik 		ehc->i.dev_action[ehc->i.dev->devno] |=
1813c6fd2807SJeff Garzik 			ehc->i.action & ATA_EH_PERDEV_MASK;
1814c6fd2807SJeff Garzik 		ehc->i.action &= ~ATA_EH_PERDEV_MASK;
1815c6fd2807SJeff Garzik 	}
1816c6fd2807SJeff Garzik 
18172695e366STejun Heo 	/* propagate timeout to host link */
18182695e366STejun Heo 	if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link))
18192695e366STejun Heo 		ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT;
18202695e366STejun Heo 
18212695e366STejun Heo 	/* record error and consider speeding down */
1822dfcc173dSTejun Heo 	dev = ehc->i.dev;
18232695e366STejun Heo 	if (!dev && ((ata_link_max_devices(link) == 1 &&
18242695e366STejun Heo 		      ata_dev_enabled(link->device))))
1825dfcc173dSTejun Heo 	    dev = link->device;
1826dfcc173dSTejun Heo 
182776326ac1STejun Heo 	if (dev) {
182876326ac1STejun Heo 		if (dev->flags & ATA_DFLAG_DUBIOUS_XFER)
182976326ac1STejun Heo 			eflags |= ATA_EFLAG_DUBIOUS_XFER;
18303884f7b0STejun Heo 		ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask);
183176326ac1STejun Heo 	}
1832dfcc173dSTejun Heo 
1833c6fd2807SJeff Garzik 	DPRINTK("EXIT\n");
1834c6fd2807SJeff Garzik }
1835c6fd2807SJeff Garzik 
1836c6fd2807SJeff Garzik /**
18379b1e2658STejun Heo  *	ata_eh_autopsy - analyze error and determine recovery action
18389b1e2658STejun Heo  *	@ap: host port to perform autopsy on
18399b1e2658STejun Heo  *
18409b1e2658STejun Heo  *	Analyze all links of @ap and determine why they failed and
18419b1e2658STejun Heo  *	which recovery actions are needed.
18429b1e2658STejun Heo  *
18439b1e2658STejun Heo  *	LOCKING:
18449b1e2658STejun Heo  *	Kernel thread context (may sleep).
18459b1e2658STejun Heo  */
1846fb7fd614STejun Heo void ata_eh_autopsy(struct ata_port *ap)
18479b1e2658STejun Heo {
18489b1e2658STejun Heo 	struct ata_link *link;
18499b1e2658STejun Heo 
18502695e366STejun Heo 	ata_port_for_each_link(link, ap)
18519b1e2658STejun Heo 		ata_eh_link_autopsy(link);
18522695e366STejun Heo 
18532695e366STejun Heo 	/* Autopsy of fanout ports can affect host link autopsy.
18542695e366STejun Heo 	 * Perform host link autopsy last.
18552695e366STejun Heo 	 */
18562695e366STejun Heo 	if (ap->nr_pmp_links)
18572695e366STejun Heo 		ata_eh_link_autopsy(&ap->link);
18589b1e2658STejun Heo }
18599b1e2658STejun Heo 
18609b1e2658STejun Heo /**
18619b1e2658STejun Heo  *	ata_eh_link_report - report error handling to user
18620260731fSTejun Heo  *	@link: ATA link EH is going on
1863c6fd2807SJeff Garzik  *
1864c6fd2807SJeff Garzik  *	Report EH to user.
1865c6fd2807SJeff Garzik  *
1866c6fd2807SJeff Garzik  *	LOCKING:
1867c6fd2807SJeff Garzik  *	None.
1868c6fd2807SJeff Garzik  */
18699b1e2658STejun Heo static void ata_eh_link_report(struct ata_link *link)
1870c6fd2807SJeff Garzik {
18710260731fSTejun Heo 	struct ata_port *ap = link->ap;
18720260731fSTejun Heo 	struct ata_eh_context *ehc = &link->eh_context;
1873c6fd2807SJeff Garzik 	const char *frozen, *desc;
1874a1e10f7eSTejun Heo 	char tries_buf[6];
1875c6fd2807SJeff Garzik 	int tag, nr_failed = 0;
1876c6fd2807SJeff Garzik 
187794ff3d54STejun Heo 	if (ehc->i.flags & ATA_EHI_QUIET)
187894ff3d54STejun Heo 		return;
187994ff3d54STejun Heo 
1880c6fd2807SJeff Garzik 	desc = NULL;
1881c6fd2807SJeff Garzik 	if (ehc->i.desc[0] != '\0')
1882c6fd2807SJeff Garzik 		desc = ehc->i.desc;
1883c6fd2807SJeff Garzik 
1884c6fd2807SJeff Garzik 	for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1885c6fd2807SJeff Garzik 		struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1886c6fd2807SJeff Garzik 
1887e027bd36STejun Heo 		if (!(qc->flags & ATA_QCFLAG_FAILED) || qc->dev->link != link ||
1888e027bd36STejun Heo 		    ((qc->flags & ATA_QCFLAG_QUIET) &&
1889e027bd36STejun Heo 		     qc->err_mask == AC_ERR_DEV))
1890c6fd2807SJeff Garzik 			continue;
1891c6fd2807SJeff Garzik 		if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
1892c6fd2807SJeff Garzik 			continue;
1893c6fd2807SJeff Garzik 
1894c6fd2807SJeff Garzik 		nr_failed++;
1895c6fd2807SJeff Garzik 	}
1896c6fd2807SJeff Garzik 
1897c6fd2807SJeff Garzik 	if (!nr_failed && !ehc->i.err_mask)
1898c6fd2807SJeff Garzik 		return;
1899c6fd2807SJeff Garzik 
1900c6fd2807SJeff Garzik 	frozen = "";
1901c6fd2807SJeff Garzik 	if (ap->pflags & ATA_PFLAG_FROZEN)
1902c6fd2807SJeff Garzik 		frozen = " frozen";
1903c6fd2807SJeff Garzik 
1904a1e10f7eSTejun Heo 	memset(tries_buf, 0, sizeof(tries_buf));
1905a1e10f7eSTejun Heo 	if (ap->eh_tries < ATA_EH_MAX_TRIES)
1906a1e10f7eSTejun Heo 		snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
1907a1e10f7eSTejun Heo 			 ap->eh_tries);
1908a1e10f7eSTejun Heo 
1909c6fd2807SJeff Garzik 	if (ehc->i.dev) {
1910c6fd2807SJeff Garzik 		ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x "
1911a1e10f7eSTejun Heo 			       "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
1912a1e10f7eSTejun Heo 			       ehc->i.err_mask, link->sactive, ehc->i.serror,
1913a1e10f7eSTejun Heo 			       ehc->i.action, frozen, tries_buf);
1914c6fd2807SJeff Garzik 		if (desc)
1915b64bbc39STejun Heo 			ata_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc);
1916c6fd2807SJeff Garzik 	} else {
19170260731fSTejun Heo 		ata_link_printk(link, KERN_ERR, "exception Emask 0x%x "
1918a1e10f7eSTejun Heo 				"SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
1919a1e10f7eSTejun Heo 				ehc->i.err_mask, link->sactive, ehc->i.serror,
1920a1e10f7eSTejun Heo 				ehc->i.action, frozen, tries_buf);
1921c6fd2807SJeff Garzik 		if (desc)
19220260731fSTejun Heo 			ata_link_printk(link, KERN_ERR, "%s\n", desc);
1923c6fd2807SJeff Garzik 	}
1924c6fd2807SJeff Garzik 
19251333e194SRobert Hancock 	if (ehc->i.serror)
19261333e194SRobert Hancock 		ata_port_printk(ap, KERN_ERR,
19271333e194SRobert Hancock 		  "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
19281333e194SRobert Hancock 		  ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
19291333e194SRobert Hancock 		  ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
19301333e194SRobert Hancock 		  ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
19311333e194SRobert Hancock 		  ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
19321333e194SRobert Hancock 		  ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
19331333e194SRobert Hancock 		  ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
19341333e194SRobert Hancock 		  ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
19351333e194SRobert Hancock 		  ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
19361333e194SRobert Hancock 		  ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
19371333e194SRobert Hancock 		  ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
19381333e194SRobert Hancock 		  ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
19391333e194SRobert Hancock 		  ehc->i.serror & SERR_CRC ? "BadCRC " : "",
19401333e194SRobert Hancock 		  ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
19411333e194SRobert Hancock 		  ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
19421333e194SRobert Hancock 		  ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
19431333e194SRobert Hancock 		  ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
19441333e194SRobert Hancock 		  ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
19451333e194SRobert Hancock 
1946c6fd2807SJeff Garzik 	for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1947c6fd2807SJeff Garzik 		struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
19488a937581STejun Heo 		struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
1949abb6a889STejun Heo 		const u8 *cdb = qc->cdb;
1950abb6a889STejun Heo 		char data_buf[20] = "";
1951abb6a889STejun Heo 		char cdb_buf[70] = "";
1952c6fd2807SJeff Garzik 
19530260731fSTejun Heo 		if (!(qc->flags & ATA_QCFLAG_FAILED) ||
19540260731fSTejun Heo 		    qc->dev->link != link || !qc->err_mask)
1955c6fd2807SJeff Garzik 			continue;
1956c6fd2807SJeff Garzik 
1957abb6a889STejun Heo 		if (qc->dma_dir != DMA_NONE) {
1958abb6a889STejun Heo 			static const char *dma_str[] = {
1959abb6a889STejun Heo 				[DMA_BIDIRECTIONAL]	= "bidi",
1960abb6a889STejun Heo 				[DMA_TO_DEVICE]		= "out",
1961abb6a889STejun Heo 				[DMA_FROM_DEVICE]	= "in",
1962abb6a889STejun Heo 			};
1963abb6a889STejun Heo 			static const char *prot_str[] = {
1964abb6a889STejun Heo 				[ATA_PROT_PIO]		= "pio",
1965abb6a889STejun Heo 				[ATA_PROT_DMA]		= "dma",
1966abb6a889STejun Heo 				[ATA_PROT_NCQ]		= "ncq",
19670dc36888STejun Heo 				[ATAPI_PROT_PIO]	= "pio",
19680dc36888STejun Heo 				[ATAPI_PROT_DMA]	= "dma",
1969abb6a889STejun Heo 			};
1970abb6a889STejun Heo 
1971abb6a889STejun Heo 			snprintf(data_buf, sizeof(data_buf), " %s %u %s",
1972abb6a889STejun Heo 				 prot_str[qc->tf.protocol], qc->nbytes,
1973abb6a889STejun Heo 				 dma_str[qc->dma_dir]);
1974abb6a889STejun Heo 		}
1975abb6a889STejun Heo 
1976e39eec13SJeff Garzik 		if (ata_is_atapi(qc->tf.protocol))
1977abb6a889STejun Heo 			snprintf(cdb_buf, sizeof(cdb_buf),
1978abb6a889STejun Heo 				 "cdb %02x %02x %02x %02x %02x %02x %02x %02x  "
1979abb6a889STejun Heo 				 "%02x %02x %02x %02x %02x %02x %02x %02x\n         ",
1980abb6a889STejun Heo 				 cdb[0], cdb[1], cdb[2], cdb[3],
1981abb6a889STejun Heo 				 cdb[4], cdb[5], cdb[6], cdb[7],
1982abb6a889STejun Heo 				 cdb[8], cdb[9], cdb[10], cdb[11],
1983abb6a889STejun Heo 				 cdb[12], cdb[13], cdb[14], cdb[15]);
1984abb6a889STejun Heo 
19858a937581STejun Heo 		ata_dev_printk(qc->dev, KERN_ERR,
19868a937581STejun Heo 			"cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
1987abb6a889STejun Heo 			"tag %d%s\n         %s"
19888a937581STejun Heo 			"res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
19895335b729STejun Heo 			"Emask 0x%x (%s)%s\n",
19908a937581STejun Heo 			cmd->command, cmd->feature, cmd->nsect,
19918a937581STejun Heo 			cmd->lbal, cmd->lbam, cmd->lbah,
19928a937581STejun Heo 			cmd->hob_feature, cmd->hob_nsect,
19938a937581STejun Heo 			cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
1994abb6a889STejun Heo 			cmd->device, qc->tag, data_buf, cdb_buf,
19958a937581STejun Heo 			res->command, res->feature, res->nsect,
19968a937581STejun Heo 			res->lbal, res->lbam, res->lbah,
19978a937581STejun Heo 			res->hob_feature, res->hob_nsect,
19988a937581STejun Heo 			res->hob_lbal, res->hob_lbam, res->hob_lbah,
19995335b729STejun Heo 			res->device, qc->err_mask, ata_err_string(qc->err_mask),
20005335b729STejun Heo 			qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
20011333e194SRobert Hancock 
20021333e194SRobert Hancock 		if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
20031333e194SRobert Hancock 				    ATA_ERR)) {
20041333e194SRobert Hancock 			if (res->command & ATA_BUSY)
20051333e194SRobert Hancock 				ata_dev_printk(qc->dev, KERN_ERR,
20061333e194SRobert Hancock 				  "status: { Busy }\n");
20071333e194SRobert Hancock 			else
20081333e194SRobert Hancock 				ata_dev_printk(qc->dev, KERN_ERR,
20091333e194SRobert Hancock 				  "status: { %s%s%s%s}\n",
20101333e194SRobert Hancock 				  res->command & ATA_DRDY ? "DRDY " : "",
20111333e194SRobert Hancock 				  res->command & ATA_DF ? "DF " : "",
20121333e194SRobert Hancock 				  res->command & ATA_DRQ ? "DRQ " : "",
20131333e194SRobert Hancock 				  res->command & ATA_ERR ? "ERR " : "");
20141333e194SRobert Hancock 		}
20151333e194SRobert Hancock 
20161333e194SRobert Hancock 		if (cmd->command != ATA_CMD_PACKET &&
20171333e194SRobert Hancock 		    (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
20181333e194SRobert Hancock 				     ATA_ABORTED)))
20191333e194SRobert Hancock 			ata_dev_printk(qc->dev, KERN_ERR,
20201333e194SRobert Hancock 			  "error: { %s%s%s%s}\n",
20211333e194SRobert Hancock 			  res->feature & ATA_ICRC ? "ICRC " : "",
20221333e194SRobert Hancock 			  res->feature & ATA_UNC ? "UNC " : "",
20231333e194SRobert Hancock 			  res->feature & ATA_IDNF ? "IDNF " : "",
20241333e194SRobert Hancock 			  res->feature & ATA_ABORTED ? "ABRT " : "");
2025c6fd2807SJeff Garzik 	}
2026c6fd2807SJeff Garzik }
2027c6fd2807SJeff Garzik 
20289b1e2658STejun Heo /**
20299b1e2658STejun Heo  *	ata_eh_report - report error handling to user
20309b1e2658STejun Heo  *	@ap: ATA port to report EH about
20319b1e2658STejun Heo  *
20329b1e2658STejun Heo  *	Report EH to user.
20339b1e2658STejun Heo  *
20349b1e2658STejun Heo  *	LOCKING:
20359b1e2658STejun Heo  *	None.
20369b1e2658STejun Heo  */
2037fb7fd614STejun Heo void ata_eh_report(struct ata_port *ap)
20389b1e2658STejun Heo {
20399b1e2658STejun Heo 	struct ata_link *link;
20409b1e2658STejun Heo 
20419b1e2658STejun Heo 	__ata_port_for_each_link(link, ap)
20429b1e2658STejun Heo 		ata_eh_link_report(link);
20439b1e2658STejun Heo }
20449b1e2658STejun Heo 
2045cc0680a5STejun Heo static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
2046d4b2bab4STejun Heo 			unsigned int *classes, unsigned long deadline)
2047c6fd2807SJeff Garzik {
2048f58229f8STejun Heo 	struct ata_device *dev;
2049f58229f8STejun Heo 	int rc;
2050c6fd2807SJeff Garzik 
2051cc0680a5STejun Heo 	ata_link_for_each_dev(dev, link)
2052f58229f8STejun Heo 		classes[dev->devno] = ATA_DEV_UNKNOWN;
2053c6fd2807SJeff Garzik 
2054cc0680a5STejun Heo 	rc = reset(link, classes, deadline);
2055c6fd2807SJeff Garzik 	if (rc)
2056c6fd2807SJeff Garzik 		return rc;
2057c6fd2807SJeff Garzik 
2058*305d2a1aSTejun Heo 	/* convert all ATA_DEV_UNKNOWN to ATA_DEV_NONE */
2059cc0680a5STejun Heo 	ata_link_for_each_dev(dev, link)
2060f58229f8STejun Heo 		if (classes[dev->devno] == ATA_DEV_UNKNOWN)
2061f58229f8STejun Heo 			classes[dev->devno] = ATA_DEV_NONE;
2062c6fd2807SJeff Garzik 
2063c6fd2807SJeff Garzik 	return 0;
2064c6fd2807SJeff Garzik }
2065c6fd2807SJeff Garzik 
2066ae791c05STejun Heo static int ata_eh_followup_srst_needed(struct ata_link *link,
2067ae791c05STejun Heo 				       int rc, int classify,
2068c6fd2807SJeff Garzik 				       const unsigned int *classes)
2069c6fd2807SJeff Garzik {
2070ae791c05STejun Heo 	if (link->flags & ATA_LFLAG_NO_SRST)
2071ae791c05STejun Heo 		return 0;
2072*305d2a1aSTejun Heo 	if (rc == -EAGAIN) {
2073*305d2a1aSTejun Heo 		if (classify)
2074c6fd2807SJeff Garzik 			return 1;
2075*305d2a1aSTejun Heo 		rc = 0;
2076*305d2a1aSTejun Heo 	}
2077c6fd2807SJeff Garzik 	if (rc != 0)
2078c6fd2807SJeff Garzik 		return 0;
20793495de73STejun Heo 	if ((link->ap->flags & ATA_FLAG_PMP) && ata_is_host_link(link))
20803495de73STejun Heo 		return 1;
2081c6fd2807SJeff Garzik 	return 0;
2082c6fd2807SJeff Garzik }
2083c6fd2807SJeff Garzik 
2084fb7fd614STejun Heo int ata_eh_reset(struct ata_link *link, int classify,
2085c6fd2807SJeff Garzik 		 ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
2086c6fd2807SJeff Garzik 		 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
2087c6fd2807SJeff Garzik {
2088416dc9edSTejun Heo 	const int max_tries = ARRAY_SIZE(ata_eh_reset_timeouts);
2089afaa5c37STejun Heo 	struct ata_port *ap = link->ap;
2090936fd732STejun Heo 	struct ata_eh_context *ehc = &link->eh_context;
2091c6fd2807SJeff Garzik 	unsigned int *classes = ehc->classes;
2092416dc9edSTejun Heo 	unsigned int lflags = link->flags;
2093c6fd2807SJeff Garzik 	int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
209431daabdaSTejun Heo 	int try = 0;
2095f58229f8STejun Heo 	struct ata_device *dev;
2096416dc9edSTejun Heo 	unsigned long deadline, now;
2097c6fd2807SJeff Garzik 	ata_reset_fn_t reset;
2098afaa5c37STejun Heo 	unsigned long flags;
2099416dc9edSTejun Heo 	u32 sstatus;
2100f58229f8STejun Heo 	int rc;
2101c6fd2807SJeff Garzik 
2102c6fd2807SJeff Garzik 	/* about to reset */
2103afaa5c37STejun Heo 	spin_lock_irqsave(ap->lock, flags);
2104afaa5c37STejun Heo 	ap->pflags |= ATA_PFLAG_RESETTING;
2105afaa5c37STejun Heo 	spin_unlock_irqrestore(ap->lock, flags);
2106afaa5c37STejun Heo 
2107cf480626STejun Heo 	ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
2108c6fd2807SJeff Garzik 
2109cdeab114STejun Heo 	ata_link_for_each_dev(dev, link) {
2110cdeab114STejun Heo 		/* If we issue an SRST then an ATA drive (not ATAPI)
2111cdeab114STejun Heo 		 * may change configuration and be in PIO0 timing. If
2112cdeab114STejun Heo 		 * we do a hard reset (or are coming from power on)
2113cdeab114STejun Heo 		 * this is true for ATA or ATAPI. Until we've set a
2114cdeab114STejun Heo 		 * suitable controller mode we should not touch the
2115cdeab114STejun Heo 		 * bus as we may be talking too fast.
2116cdeab114STejun Heo 		 */
2117cdeab114STejun Heo 		dev->pio_mode = XFER_PIO_0;
2118cdeab114STejun Heo 
2119cdeab114STejun Heo 		/* If the controller has a pio mode setup function
2120cdeab114STejun Heo 		 * then use it to set the chipset to rights. Don't
2121cdeab114STejun Heo 		 * touch the DMA setup as that will be dealt with when
2122cdeab114STejun Heo 		 * configuring devices.
2123cdeab114STejun Heo 		 */
2124cdeab114STejun Heo 		if (ap->ops->set_piomode)
2125cdeab114STejun Heo 			ap->ops->set_piomode(ap, dev);
2126cdeab114STejun Heo 	}
2127cdeab114STejun Heo 
2128eec59f76STejun Heo 	if (!softreset && !hardreset) {
2129eec59f76STejun Heo 		if (verbose)
2130eec59f76STejun Heo 			ata_link_printk(link, KERN_INFO, "no reset method "
2131eec59f76STejun Heo 					"available, skipping reset\n");
2132eec59f76STejun Heo 		if (!(lflags & ATA_LFLAG_ASSUME_CLASS))
2133eec59f76STejun Heo 			lflags |= ATA_LFLAG_ASSUME_ATA;
2134eec59f76STejun Heo 		goto done;
2135eec59f76STejun Heo 	}
2136eec59f76STejun Heo 
2137cf480626STejun Heo 	/* prefer hardreset */
2138cf480626STejun Heo 	ehc->i.action &= ~ATA_EH_RESET;
2139cf480626STejun Heo 	if (hardreset) {
2140cf480626STejun Heo 		reset = hardreset;
2141cf480626STejun Heo 		ehc->i.action = ATA_EH_HARDRESET;
2142cf480626STejun Heo 	} else {
2143cf480626STejun Heo 		reset = softreset;
2144cf480626STejun Heo 		ehc->i.action = ATA_EH_SOFTRESET;
2145cf480626STejun Heo 	}
2146c6fd2807SJeff Garzik 
2147c6fd2807SJeff Garzik 	if (prereset) {
2148cc0680a5STejun Heo 		rc = prereset(link, jiffies + ATA_EH_PRERESET_TIMEOUT);
2149c6fd2807SJeff Garzik 		if (rc) {
2150c961922bSAlan Cox 			if (rc == -ENOENT) {
2151cc0680a5STejun Heo 				ata_link_printk(link, KERN_DEBUG,
21524aa9ab67STejun Heo 						"port disabled. ignoring.\n");
2153cf480626STejun Heo 				ehc->i.action &= ~ATA_EH_RESET;
21544aa9ab67STejun Heo 
2155936fd732STejun Heo 				ata_link_for_each_dev(dev, link)
2156f58229f8STejun Heo 					classes[dev->devno] = ATA_DEV_NONE;
21574aa9ab67STejun Heo 
21584aa9ab67STejun Heo 				rc = 0;
2159c961922bSAlan Cox 			} else
2160cc0680a5STejun Heo 				ata_link_printk(link, KERN_ERR,
2161c6fd2807SJeff Garzik 					"prereset failed (errno=%d)\n", rc);
2162fccb6ea5STejun Heo 			goto out;
2163c6fd2807SJeff Garzik 		}
2164c6fd2807SJeff Garzik 	}
2165c6fd2807SJeff Garzik 
2166cf480626STejun Heo 	/* prereset() might have cleared ATA_EH_RESET */
2167cf480626STejun Heo 	if (!(ehc->i.action & ATA_EH_RESET)) {
2168c6fd2807SJeff Garzik 		/* prereset told us not to reset, bang classes and return */
2169936fd732STejun Heo 		ata_link_for_each_dev(dev, link)
2170f58229f8STejun Heo 			classes[dev->devno] = ATA_DEV_NONE;
2171fccb6ea5STejun Heo 		rc = 0;
2172fccb6ea5STejun Heo 		goto out;
2173c6fd2807SJeff Garzik 	}
2174c6fd2807SJeff Garzik 
2175c6fd2807SJeff Garzik  retry:
217631daabdaSTejun Heo 	deadline = jiffies + ata_eh_reset_timeouts[try++];
217731daabdaSTejun Heo 
2178c6fd2807SJeff Garzik 	/* shut up during boot probing */
2179c6fd2807SJeff Garzik 	if (verbose)
2180cc0680a5STejun Heo 		ata_link_printk(link, KERN_INFO, "%s resetting link\n",
2181c6fd2807SJeff Garzik 				reset == softreset ? "soft" : "hard");
2182c6fd2807SJeff Garzik 
2183c6fd2807SJeff Garzik 	/* mark that this EH session started with reset */
21840d64a233STejun Heo 	if (reset == hardreset)
21850d64a233STejun Heo 		ehc->i.flags |= ATA_EHI_DID_HARDRESET;
21860d64a233STejun Heo 	else
21870d64a233STejun Heo 		ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
2188c6fd2807SJeff Garzik 
2189cc0680a5STejun Heo 	rc = ata_do_reset(link, reset, classes, deadline);
2190c6fd2807SJeff Garzik 
2191c6fd2807SJeff Garzik 	if (reset == hardreset &&
2192ae791c05STejun Heo 	    ata_eh_followup_srst_needed(link, rc, classify, classes)) {
2193c6fd2807SJeff Garzik 		/* okay, let's do follow-up softreset */
2194c6fd2807SJeff Garzik 		reset = softreset;
2195c6fd2807SJeff Garzik 
2196c6fd2807SJeff Garzik 		if (!reset) {
2197cc0680a5STejun Heo 			ata_link_printk(link, KERN_ERR,
2198c6fd2807SJeff Garzik 					"follow-up softreset required "
2199c6fd2807SJeff Garzik 					"but no softreset avaliable\n");
2200fccb6ea5STejun Heo 			rc = -EINVAL;
220108cf69d0STejun Heo 			goto fail;
2202c6fd2807SJeff Garzik 		}
2203c6fd2807SJeff Garzik 
2204cf480626STejun Heo 		ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
2205cc0680a5STejun Heo 		rc = ata_do_reset(link, reset, classes, deadline);
2206c6fd2807SJeff Garzik 	}
2207c6fd2807SJeff Garzik 
2208416dc9edSTejun Heo 	/* -EAGAIN can happen if we skipped followup SRST */
2209416dc9edSTejun Heo 	if (rc && rc != -EAGAIN)
2210416dc9edSTejun Heo 		goto fail;
2211008a7896STejun Heo 
221208cf69d0STejun Heo 	/* was classification successful? */
221308cf69d0STejun Heo 	if (classify && classes[0] == ATA_DEV_UNKNOWN &&
221408cf69d0STejun Heo 	    !(lflags & ATA_LFLAG_ASSUME_CLASS)) {
221508cf69d0STejun Heo 		if (try < max_tries) {
221608cf69d0STejun Heo 			ata_link_printk(link, KERN_WARNING,
221708cf69d0STejun Heo 					"classification failed\n");
221808cf69d0STejun Heo 			rc = -EINVAL;
221908cf69d0STejun Heo 			goto fail;
222008cf69d0STejun Heo 		}
222108cf69d0STejun Heo 
222208cf69d0STejun Heo 		ata_link_printk(link, KERN_WARNING,
222308cf69d0STejun Heo 				"classfication failed, assuming ATA\n");
222408cf69d0STejun Heo 		lflags |= ATA_LFLAG_ASSUME_ATA;
222508cf69d0STejun Heo 	}
222608cf69d0STejun Heo 
2227eec59f76STejun Heo  done:
2228ae791c05STejun Heo 	ata_link_for_each_dev(dev, link) {
2229416dc9edSTejun Heo 		/* After the reset, the device state is PIO 0 and the
2230416dc9edSTejun Heo 		 * controller state is undefined.  Reset also wakes up
2231416dc9edSTejun Heo 		 * drives from sleeping mode.
2232c6fd2807SJeff Garzik 		 */
2233f58229f8STejun Heo 		dev->pio_mode = XFER_PIO_0;
2234054a5fbaSTejun Heo 		dev->flags &= ~ATA_DFLAG_SLEEPING;
2235c6fd2807SJeff Garzik 
2236ae791c05STejun Heo 		if (ata_link_offline(link))
2237ae791c05STejun Heo 			continue;
2238ae791c05STejun Heo 
22394ccd3329STejun Heo 		/* apply class override */
2240416dc9edSTejun Heo 		if (lflags & ATA_LFLAG_ASSUME_ATA)
2241ae791c05STejun Heo 			classes[dev->devno] = ATA_DEV_ATA;
2242416dc9edSTejun Heo 		else if (lflags & ATA_LFLAG_ASSUME_SEMB)
2243ae791c05STejun Heo 			classes[dev->devno] = ATA_DEV_SEMB_UNSUP; /* not yet */
2244ae791c05STejun Heo 	}
2245ae791c05STejun Heo 
2246008a7896STejun Heo 	/* record current link speed */
2247936fd732STejun Heo 	if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
2248936fd732STejun Heo 		link->sata_spd = (sstatus >> 4) & 0xf;
2249008a7896STejun Heo 
2250c6fd2807SJeff Garzik 	if (postreset)
2251cc0680a5STejun Heo 		postreset(link, classes);
2252c6fd2807SJeff Garzik 
2253c6fd2807SJeff Garzik 	/* reset successful, schedule revalidation */
2254cf480626STejun Heo 	ata_eh_done(link, NULL, ATA_EH_RESET);
2255c6fd2807SJeff Garzik 	ehc->i.action |= ATA_EH_REVALIDATE;
2256416dc9edSTejun Heo 
2257416dc9edSTejun Heo 	rc = 0;
2258fccb6ea5STejun Heo  out:
2259fccb6ea5STejun Heo 	/* clear hotplug flag */
2260fccb6ea5STejun Heo 	ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
2261afaa5c37STejun Heo 
2262afaa5c37STejun Heo 	spin_lock_irqsave(ap->lock, flags);
2263afaa5c37STejun Heo 	ap->pflags &= ~ATA_PFLAG_RESETTING;
2264afaa5c37STejun Heo 	spin_unlock_irqrestore(ap->lock, flags);
2265afaa5c37STejun Heo 
2266c6fd2807SJeff Garzik 	return rc;
2267416dc9edSTejun Heo 
2268416dc9edSTejun Heo  fail:
22695958e302STejun Heo 	/* if SCR isn't accessible on a fan-out port, PMP needs to be reset */
22705958e302STejun Heo 	if (!ata_is_host_link(link) &&
22715958e302STejun Heo 	    sata_scr_read(link, SCR_STATUS, &sstatus))
22725958e302STejun Heo 		rc = -ERESTART;
22735958e302STejun Heo 
2274416dc9edSTejun Heo 	if (rc == -ERESTART || try >= max_tries)
2275416dc9edSTejun Heo 		goto out;
2276416dc9edSTejun Heo 
2277416dc9edSTejun Heo 	now = jiffies;
2278416dc9edSTejun Heo 	if (time_before(now, deadline)) {
2279416dc9edSTejun Heo 		unsigned long delta = deadline - now;
2280416dc9edSTejun Heo 
2281416dc9edSTejun Heo 		ata_link_printk(link, KERN_WARNING, "reset failed "
2282416dc9edSTejun Heo 				"(errno=%d), retrying in %u secs\n",
2283416dc9edSTejun Heo 				rc, (jiffies_to_msecs(delta) + 999) / 1000);
2284416dc9edSTejun Heo 
2285416dc9edSTejun Heo 		while (delta)
2286416dc9edSTejun Heo 			delta = schedule_timeout_uninterruptible(delta);
2287416dc9edSTejun Heo 	}
2288416dc9edSTejun Heo 
2289416dc9edSTejun Heo 	if (rc == -EPIPE || try == max_tries - 1)
2290416dc9edSTejun Heo 		sata_down_spd_limit(link);
2291416dc9edSTejun Heo 	if (hardreset)
2292416dc9edSTejun Heo 		reset = hardreset;
2293416dc9edSTejun Heo 	goto retry;
2294c6fd2807SJeff Garzik }
2295c6fd2807SJeff Garzik 
22960260731fSTejun Heo static int ata_eh_revalidate_and_attach(struct ata_link *link,
2297c6fd2807SJeff Garzik 					struct ata_device **r_failed_dev)
2298c6fd2807SJeff Garzik {
22990260731fSTejun Heo 	struct ata_port *ap = link->ap;
23000260731fSTejun Heo 	struct ata_eh_context *ehc = &link->eh_context;
2301c6fd2807SJeff Garzik 	struct ata_device *dev;
23028c3c52a8STejun Heo 	unsigned int new_mask = 0;
2303c6fd2807SJeff Garzik 	unsigned long flags;
2304f58229f8STejun Heo 	int rc = 0;
2305c6fd2807SJeff Garzik 
2306c6fd2807SJeff Garzik 	DPRINTK("ENTER\n");
2307c6fd2807SJeff Garzik 
23088c3c52a8STejun Heo 	/* For PATA drive side cable detection to work, IDENTIFY must
23098c3c52a8STejun Heo 	 * be done backwards such that PDIAG- is released by the slave
23108c3c52a8STejun Heo 	 * device before the master device is identified.
23118c3c52a8STejun Heo 	 */
23120260731fSTejun Heo 	ata_link_for_each_dev_reverse(dev, link) {
2313f58229f8STejun Heo 		unsigned int action = ata_eh_dev_action(dev);
2314f58229f8STejun Heo 		unsigned int readid_flags = 0;
2315c6fd2807SJeff Garzik 
2316bff04647STejun Heo 		if (ehc->i.flags & ATA_EHI_DID_RESET)
2317bff04647STejun Heo 			readid_flags |= ATA_READID_POSTRESET;
2318bff04647STejun Heo 
23199666f400STejun Heo 		if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
2320633273a3STejun Heo 			WARN_ON(dev->class == ATA_DEV_PMP);
2321633273a3STejun Heo 
23220260731fSTejun Heo 			if (ata_link_offline(link)) {
2323c6fd2807SJeff Garzik 				rc = -EIO;
23248c3c52a8STejun Heo 				goto err;
2325c6fd2807SJeff Garzik 			}
2326c6fd2807SJeff Garzik 
23270260731fSTejun Heo 			ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
2328422c9daaSTejun Heo 			rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
2329422c9daaSTejun Heo 						readid_flags);
2330c6fd2807SJeff Garzik 			if (rc)
23318c3c52a8STejun Heo 				goto err;
2332c6fd2807SJeff Garzik 
23330260731fSTejun Heo 			ata_eh_done(link, dev, ATA_EH_REVALIDATE);
2334c6fd2807SJeff Garzik 
2335baa1e78aSTejun Heo 			/* Configuration may have changed, reconfigure
2336baa1e78aSTejun Heo 			 * transfer mode.
2337baa1e78aSTejun Heo 			 */
2338baa1e78aSTejun Heo 			ehc->i.flags |= ATA_EHI_SETMODE;
2339baa1e78aSTejun Heo 
2340c6fd2807SJeff Garzik 			/* schedule the scsi_rescan_device() here */
2341c6fd2807SJeff Garzik 			queue_work(ata_aux_wq, &(ap->scsi_rescan_task));
2342c6fd2807SJeff Garzik 		} else if (dev->class == ATA_DEV_UNKNOWN &&
2343c6fd2807SJeff Garzik 			   ehc->tries[dev->devno] &&
2344c6fd2807SJeff Garzik 			   ata_class_enabled(ehc->classes[dev->devno])) {
2345c6fd2807SJeff Garzik 			dev->class = ehc->classes[dev->devno];
2346c6fd2807SJeff Garzik 
2347633273a3STejun Heo 			if (dev->class == ATA_DEV_PMP)
2348633273a3STejun Heo 				rc = sata_pmp_attach(dev);
2349633273a3STejun Heo 			else
2350633273a3STejun Heo 				rc = ata_dev_read_id(dev, &dev->class,
2351633273a3STejun Heo 						     readid_flags, dev->id);
23528c3c52a8STejun Heo 			switch (rc) {
23538c3c52a8STejun Heo 			case 0:
2354f58229f8STejun Heo 				new_mask |= 1 << dev->devno;
23558c3c52a8STejun Heo 				break;
23568c3c52a8STejun Heo 			case -ENOENT:
235755a8e2c8STejun Heo 				/* IDENTIFY was issued to non-existent
235855a8e2c8STejun Heo 				 * device.  No need to reset.  Just
235955a8e2c8STejun Heo 				 * thaw and kill the device.
236055a8e2c8STejun Heo 				 */
236155a8e2c8STejun Heo 				ata_eh_thaw_port(ap);
236255a8e2c8STejun Heo 				dev->class = ATA_DEV_UNKNOWN;
2363c6fd2807SJeff Garzik 				break;
23648c3c52a8STejun Heo 			default:
23658c3c52a8STejun Heo 				dev->class = ATA_DEV_UNKNOWN;
23668c3c52a8STejun Heo 				goto err;
23678c3c52a8STejun Heo 			}
23688c3c52a8STejun Heo 		}
2369c6fd2807SJeff Garzik 	}
2370c6fd2807SJeff Garzik 
2371c1c4e8d5STejun Heo 	/* PDIAG- should have been released, ask cable type if post-reset */
237233267325STejun Heo 	if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) {
237333267325STejun Heo 		if (ap->ops->cable_detect)
2374c1c4e8d5STejun Heo 			ap->cbl = ap->ops->cable_detect(ap);
237533267325STejun Heo 		ata_force_cbl(ap);
237633267325STejun Heo 	}
2377c1c4e8d5STejun Heo 
23788c3c52a8STejun Heo 	/* Configure new devices forward such that user doesn't see
23798c3c52a8STejun Heo 	 * device detection messages backwards.
23808c3c52a8STejun Heo 	 */
23810260731fSTejun Heo 	ata_link_for_each_dev(dev, link) {
2382633273a3STejun Heo 		if (!(new_mask & (1 << dev->devno)) ||
2383633273a3STejun Heo 		    dev->class == ATA_DEV_PMP)
23848c3c52a8STejun Heo 			continue;
23858c3c52a8STejun Heo 
23868c3c52a8STejun Heo 		ehc->i.flags |= ATA_EHI_PRINTINFO;
23878c3c52a8STejun Heo 		rc = ata_dev_configure(dev);
23888c3c52a8STejun Heo 		ehc->i.flags &= ~ATA_EHI_PRINTINFO;
23898c3c52a8STejun Heo 		if (rc)
23908c3c52a8STejun Heo 			goto err;
23918c3c52a8STejun Heo 
2392c6fd2807SJeff Garzik 		spin_lock_irqsave(ap->lock, flags);
2393c6fd2807SJeff Garzik 		ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
2394c6fd2807SJeff Garzik 		spin_unlock_irqrestore(ap->lock, flags);
2395baa1e78aSTejun Heo 
239655a8e2c8STejun Heo 		/* new device discovered, configure xfermode */
2397baa1e78aSTejun Heo 		ehc->i.flags |= ATA_EHI_SETMODE;
2398c6fd2807SJeff Garzik 	}
2399c6fd2807SJeff Garzik 
24008c3c52a8STejun Heo 	return 0;
24018c3c52a8STejun Heo 
24028c3c52a8STejun Heo  err:
2403c6fd2807SJeff Garzik 	*r_failed_dev = dev;
24048c3c52a8STejun Heo 	DPRINTK("EXIT rc=%d\n", rc);
2405c6fd2807SJeff Garzik 	return rc;
2406c6fd2807SJeff Garzik }
2407c6fd2807SJeff Garzik 
24086f1d1e3aSTejun Heo /**
24096f1d1e3aSTejun Heo  *	ata_set_mode - Program timings and issue SET FEATURES - XFER
24106f1d1e3aSTejun Heo  *	@link: link on which timings will be programmed
24116f1d1e3aSTejun Heo  *	@r_failed_dev: out paramter for failed device
24126f1d1e3aSTejun Heo  *
24136f1d1e3aSTejun Heo  *	Set ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
24146f1d1e3aSTejun Heo  *	ata_set_mode() fails, pointer to the failing device is
24156f1d1e3aSTejun Heo  *	returned in @r_failed_dev.
24166f1d1e3aSTejun Heo  *
24176f1d1e3aSTejun Heo  *	LOCKING:
24186f1d1e3aSTejun Heo  *	PCI/etc. bus probe sem.
24196f1d1e3aSTejun Heo  *
24206f1d1e3aSTejun Heo  *	RETURNS:
24216f1d1e3aSTejun Heo  *	0 on success, negative errno otherwise
24226f1d1e3aSTejun Heo  */
24236f1d1e3aSTejun Heo int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
24246f1d1e3aSTejun Heo {
24256f1d1e3aSTejun Heo 	struct ata_port *ap = link->ap;
242600115e0fSTejun Heo 	struct ata_device *dev;
242700115e0fSTejun Heo 	int rc;
24286f1d1e3aSTejun Heo 
242976326ac1STejun Heo 	/* if data transfer is verified, clear DUBIOUS_XFER on ering top */
243076326ac1STejun Heo 	ata_link_for_each_dev(dev, link) {
243176326ac1STejun Heo 		if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) {
243276326ac1STejun Heo 			struct ata_ering_entry *ent;
243376326ac1STejun Heo 
243476326ac1STejun Heo 			ent = ata_ering_top(&dev->ering);
243576326ac1STejun Heo 			if (ent)
243676326ac1STejun Heo 				ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER;
243776326ac1STejun Heo 		}
243876326ac1STejun Heo 	}
243976326ac1STejun Heo 
24406f1d1e3aSTejun Heo 	/* has private set_mode? */
24416f1d1e3aSTejun Heo 	if (ap->ops->set_mode)
244200115e0fSTejun Heo 		rc = ap->ops->set_mode(link, r_failed_dev);
244300115e0fSTejun Heo 	else
244400115e0fSTejun Heo 		rc = ata_do_set_mode(link, r_failed_dev);
244500115e0fSTejun Heo 
244600115e0fSTejun Heo 	/* if transfer mode has changed, set DUBIOUS_XFER on device */
244700115e0fSTejun Heo 	ata_link_for_each_dev(dev, link) {
244800115e0fSTejun Heo 		struct ata_eh_context *ehc = &link->eh_context;
244900115e0fSTejun Heo 		u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno];
245000115e0fSTejun Heo 		u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno));
245100115e0fSTejun Heo 
245200115e0fSTejun Heo 		if (dev->xfer_mode != saved_xfer_mode ||
245300115e0fSTejun Heo 		    ata_ncq_enabled(dev) != saved_ncq)
245400115e0fSTejun Heo 			dev->flags |= ATA_DFLAG_DUBIOUS_XFER;
245500115e0fSTejun Heo 	}
245600115e0fSTejun Heo 
245700115e0fSTejun Heo 	return rc;
24586f1d1e3aSTejun Heo }
24596f1d1e3aSTejun Heo 
24600260731fSTejun Heo static int ata_link_nr_enabled(struct ata_link *link)
2461c6fd2807SJeff Garzik {
2462f58229f8STejun Heo 	struct ata_device *dev;
2463f58229f8STejun Heo 	int cnt = 0;
2464c6fd2807SJeff Garzik 
24650260731fSTejun Heo 	ata_link_for_each_dev(dev, link)
2466f58229f8STejun Heo 		if (ata_dev_enabled(dev))
2467c6fd2807SJeff Garzik 			cnt++;
2468c6fd2807SJeff Garzik 	return cnt;
2469c6fd2807SJeff Garzik }
2470c6fd2807SJeff Garzik 
24710260731fSTejun Heo static int ata_link_nr_vacant(struct ata_link *link)
2472c6fd2807SJeff Garzik {
2473f58229f8STejun Heo 	struct ata_device *dev;
2474f58229f8STejun Heo 	int cnt = 0;
2475c6fd2807SJeff Garzik 
24760260731fSTejun Heo 	ata_link_for_each_dev(dev, link)
2477f58229f8STejun Heo 		if (dev->class == ATA_DEV_UNKNOWN)
2478c6fd2807SJeff Garzik 			cnt++;
2479c6fd2807SJeff Garzik 	return cnt;
2480c6fd2807SJeff Garzik }
2481c6fd2807SJeff Garzik 
24820260731fSTejun Heo static int ata_eh_skip_recovery(struct ata_link *link)
2483c6fd2807SJeff Garzik {
2484672b2d65STejun Heo 	struct ata_port *ap = link->ap;
24850260731fSTejun Heo 	struct ata_eh_context *ehc = &link->eh_context;
2486f58229f8STejun Heo 	struct ata_device *dev;
2487c6fd2807SJeff Garzik 
2488f9df58cbSTejun Heo 	/* skip disabled links */
2489f9df58cbSTejun Heo 	if (link->flags & ATA_LFLAG_DISABLED)
2490f9df58cbSTejun Heo 		return 1;
2491f9df58cbSTejun Heo 
2492672b2d65STejun Heo 	/* thaw frozen port and recover failed devices */
2493672b2d65STejun Heo 	if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link))
2494672b2d65STejun Heo 		return 0;
2495672b2d65STejun Heo 
2496672b2d65STejun Heo 	/* reset at least once if reset is requested */
2497672b2d65STejun Heo 	if ((ehc->i.action & ATA_EH_RESET) &&
2498672b2d65STejun Heo 	    !(ehc->i.flags & ATA_EHI_DID_RESET))
2499c6fd2807SJeff Garzik 		return 0;
2500c6fd2807SJeff Garzik 
2501c6fd2807SJeff Garzik 	/* skip if class codes for all vacant slots are ATA_DEV_NONE */
25020260731fSTejun Heo 	ata_link_for_each_dev(dev, link) {
2503c6fd2807SJeff Garzik 		if (dev->class == ATA_DEV_UNKNOWN &&
2504c6fd2807SJeff Garzik 		    ehc->classes[dev->devno] != ATA_DEV_NONE)
2505c6fd2807SJeff Garzik 			return 0;
2506c6fd2807SJeff Garzik 	}
2507c6fd2807SJeff Garzik 
2508c6fd2807SJeff Garzik 	return 1;
2509c6fd2807SJeff Garzik }
2510c6fd2807SJeff Garzik 
251102c05a27STejun Heo static int ata_eh_schedule_probe(struct ata_device *dev)
251202c05a27STejun Heo {
251302c05a27STejun Heo 	struct ata_eh_context *ehc = &dev->link->eh_context;
251402c05a27STejun Heo 
251502c05a27STejun Heo 	if (!(ehc->i.probe_mask & (1 << dev->devno)) ||
251602c05a27STejun Heo 	    (ehc->did_probe_mask & (1 << dev->devno)))
251702c05a27STejun Heo 		return 0;
251802c05a27STejun Heo 
251902c05a27STejun Heo 	ata_eh_detach_dev(dev);
252002c05a27STejun Heo 	ata_dev_init(dev);
252102c05a27STejun Heo 	ehc->did_probe_mask |= (1 << dev->devno);
2522cf480626STejun Heo 	ehc->i.action |= ATA_EH_RESET;
252300115e0fSTejun Heo 	ehc->saved_xfer_mode[dev->devno] = 0;
252400115e0fSTejun Heo 	ehc->saved_ncq_enabled &= ~(1 << dev->devno);
252502c05a27STejun Heo 
252602c05a27STejun Heo 	return 1;
252702c05a27STejun Heo }
252802c05a27STejun Heo 
25299b1e2658STejun Heo static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
2530fee7ca72STejun Heo {
25319af5c9c9STejun Heo 	struct ata_eh_context *ehc = &dev->link->eh_context;
2532fee7ca72STejun Heo 
2533fee7ca72STejun Heo 	ehc->tries[dev->devno]--;
2534fee7ca72STejun Heo 
2535fee7ca72STejun Heo 	switch (err) {
2536fee7ca72STejun Heo 	case -ENODEV:
2537fee7ca72STejun Heo 		/* device missing or wrong IDENTIFY data, schedule probing */
2538fee7ca72STejun Heo 		ehc->i.probe_mask |= (1 << dev->devno);
2539fee7ca72STejun Heo 	case -EINVAL:
2540fee7ca72STejun Heo 		/* give it just one more chance */
2541fee7ca72STejun Heo 		ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
2542fee7ca72STejun Heo 	case -EIO:
25434fb4615bSTejun Heo 		if (ehc->tries[dev->devno] == 1 && dev->pio_mode > XFER_PIO_0) {
2544fee7ca72STejun Heo 			/* This is the last chance, better to slow
2545fee7ca72STejun Heo 			 * down than lose it.
2546fee7ca72STejun Heo 			 */
2547936fd732STejun Heo 			sata_down_spd_limit(dev->link);
2548fee7ca72STejun Heo 			ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
2549fee7ca72STejun Heo 		}
2550fee7ca72STejun Heo 	}
2551fee7ca72STejun Heo 
2552fee7ca72STejun Heo 	if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
2553fee7ca72STejun Heo 		/* disable device if it has used up all its chances */
2554fee7ca72STejun Heo 		ata_dev_disable(dev);
2555fee7ca72STejun Heo 
2556fee7ca72STejun Heo 		/* detach if offline */
2557936fd732STejun Heo 		if (ata_link_offline(dev->link))
2558fee7ca72STejun Heo 			ata_eh_detach_dev(dev);
2559fee7ca72STejun Heo 
256002c05a27STejun Heo 		/* schedule probe if necessary */
256102c05a27STejun Heo 		if (ata_eh_schedule_probe(dev))
2562fee7ca72STejun Heo 			ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
25639b1e2658STejun Heo 
25649b1e2658STejun Heo 		return 1;
2565fee7ca72STejun Heo 	} else {
2566cf480626STejun Heo 		ehc->i.action |= ATA_EH_RESET;
25679b1e2658STejun Heo 		return 0;
2568fee7ca72STejun Heo 	}
2569fee7ca72STejun Heo }
2570fee7ca72STejun Heo 
2571c6fd2807SJeff Garzik /**
2572c6fd2807SJeff Garzik  *	ata_eh_recover - recover host port after error
2573c6fd2807SJeff Garzik  *	@ap: host port to recover
2574c6fd2807SJeff Garzik  *	@prereset: prereset method (can be NULL)
2575c6fd2807SJeff Garzik  *	@softreset: softreset method (can be NULL)
2576c6fd2807SJeff Garzik  *	@hardreset: hardreset method (can be NULL)
2577c6fd2807SJeff Garzik  *	@postreset: postreset method (can be NULL)
25789b1e2658STejun Heo  *	@r_failed_link: out parameter for failed link
2579c6fd2807SJeff Garzik  *
2580c6fd2807SJeff Garzik  *	This is the alpha and omega, eum and yang, heart and soul of
2581c6fd2807SJeff Garzik  *	libata exception handling.  On entry, actions required to
25829b1e2658STejun Heo  *	recover each link and hotplug requests are recorded in the
25839b1e2658STejun Heo  *	link's eh_context.  This function executes all the operations
25849b1e2658STejun Heo  *	with appropriate retrials and fallbacks to resurrect failed
2585c6fd2807SJeff Garzik  *	devices, detach goners and greet newcomers.
2586c6fd2807SJeff Garzik  *
2587c6fd2807SJeff Garzik  *	LOCKING:
2588c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
2589c6fd2807SJeff Garzik  *
2590c6fd2807SJeff Garzik  *	RETURNS:
2591c6fd2807SJeff Garzik  *	0 on success, -errno on failure.
2592c6fd2807SJeff Garzik  */
2593fb7fd614STejun Heo int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
2594c6fd2807SJeff Garzik 		   ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
25959b1e2658STejun Heo 		   ata_postreset_fn_t postreset,
25969b1e2658STejun Heo 		   struct ata_link **r_failed_link)
2597c6fd2807SJeff Garzik {
25989b1e2658STejun Heo 	struct ata_link *link;
2599c6fd2807SJeff Garzik 	struct ata_device *dev;
26009b1e2658STejun Heo 	int nr_failed_devs, nr_disabled_devs;
26019b1e2658STejun Heo 	int reset, rc;
2602f9df58cbSTejun Heo 	unsigned long flags;
2603c6fd2807SJeff Garzik 
2604c6fd2807SJeff Garzik 	DPRINTK("ENTER\n");
2605c6fd2807SJeff Garzik 
2606c6fd2807SJeff Garzik 	/* prep for recovery */
26079b1e2658STejun Heo 	ata_port_for_each_link(link, ap) {
26089b1e2658STejun Heo 		struct ata_eh_context *ehc = &link->eh_context;
26099b1e2658STejun Heo 
2610f9df58cbSTejun Heo 		/* re-enable link? */
2611f9df58cbSTejun Heo 		if (ehc->i.action & ATA_EH_ENABLE_LINK) {
2612f9df58cbSTejun Heo 			ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
2613f9df58cbSTejun Heo 			spin_lock_irqsave(ap->lock, flags);
2614f9df58cbSTejun Heo 			link->flags &= ~ATA_LFLAG_DISABLED;
2615f9df58cbSTejun Heo 			spin_unlock_irqrestore(ap->lock, flags);
2616f9df58cbSTejun Heo 			ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
2617f9df58cbSTejun Heo 		}
2618f9df58cbSTejun Heo 
26190260731fSTejun Heo 		ata_link_for_each_dev(dev, link) {
2620fd995f70STejun Heo 			if (link->flags & ATA_LFLAG_NO_RETRY)
2621fd995f70STejun Heo 				ehc->tries[dev->devno] = 1;
2622fd995f70STejun Heo 			else
2623c6fd2807SJeff Garzik 				ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
2624c6fd2807SJeff Garzik 
262579a55b72STejun Heo 			/* collect port action mask recorded in dev actions */
26269b1e2658STejun Heo 			ehc->i.action |= ehc->i.dev_action[dev->devno] &
26279b1e2658STejun Heo 					 ~ATA_EH_PERDEV_MASK;
2628f58229f8STejun Heo 			ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
262979a55b72STejun Heo 
2630c6fd2807SJeff Garzik 			/* process hotplug request */
2631c6fd2807SJeff Garzik 			if (dev->flags & ATA_DFLAG_DETACH)
2632c6fd2807SJeff Garzik 				ata_eh_detach_dev(dev);
2633c6fd2807SJeff Garzik 
263402c05a27STejun Heo 			/* schedule probe if necessary */
263502c05a27STejun Heo 			if (!ata_dev_enabled(dev))
263602c05a27STejun Heo 				ata_eh_schedule_probe(dev);
2637c6fd2807SJeff Garzik 		}
26389b1e2658STejun Heo 	}
2639c6fd2807SJeff Garzik 
2640c6fd2807SJeff Garzik  retry:
2641c6fd2807SJeff Garzik 	rc = 0;
26429b1e2658STejun Heo 	nr_failed_devs = 0;
26439b1e2658STejun Heo 	nr_disabled_devs = 0;
26449b1e2658STejun Heo 	reset = 0;
2645c6fd2807SJeff Garzik 
2646c6fd2807SJeff Garzik 	/* if UNLOADING, finish immediately */
2647c6fd2807SJeff Garzik 	if (ap->pflags & ATA_PFLAG_UNLOADING)
2648c6fd2807SJeff Garzik 		goto out;
2649c6fd2807SJeff Garzik 
26509b1e2658STejun Heo 	/* prep for EH */
26519b1e2658STejun Heo 	ata_port_for_each_link(link, ap) {
26529b1e2658STejun Heo 		struct ata_eh_context *ehc = &link->eh_context;
26539b1e2658STejun Heo 
2654c6fd2807SJeff Garzik 		/* skip EH if possible. */
26550260731fSTejun Heo 		if (ata_eh_skip_recovery(link))
2656c6fd2807SJeff Garzik 			ehc->i.action = 0;
2657c6fd2807SJeff Garzik 
26589b1e2658STejun Heo 		/* do we need to reset? */
2659cf480626STejun Heo 		if (ehc->i.action & ATA_EH_RESET)
26609b1e2658STejun Heo 			reset = 1;
26619b1e2658STejun Heo 
26620260731fSTejun Heo 		ata_link_for_each_dev(dev, link)
2663f58229f8STejun Heo 			ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
26649b1e2658STejun Heo 	}
2665c6fd2807SJeff Garzik 
2666c6fd2807SJeff Garzik 	/* reset */
26679b1e2658STejun Heo 	if (reset) {
2668b06ce3e5STejun Heo 		/* if PMP is attached, this function only deals with
2669b06ce3e5STejun Heo 		 * downstream links, port should stay thawed.
2670b06ce3e5STejun Heo 		 */
2671b06ce3e5STejun Heo 		if (!ap->nr_pmp_links)
2672c6fd2807SJeff Garzik 			ata_eh_freeze_port(ap);
2673c6fd2807SJeff Garzik 
26749b1e2658STejun Heo 		ata_port_for_each_link(link, ap) {
26759b1e2658STejun Heo 			struct ata_eh_context *ehc = &link->eh_context;
26769b1e2658STejun Heo 
2677cf480626STejun Heo 			if (!(ehc->i.action & ATA_EH_RESET))
26789b1e2658STejun Heo 				continue;
26799b1e2658STejun Heo 
26809b1e2658STejun Heo 			rc = ata_eh_reset(link, ata_link_nr_vacant(link),
26819b1e2658STejun Heo 					  prereset, softreset, hardreset,
26829b1e2658STejun Heo 					  postreset);
2683c6fd2807SJeff Garzik 			if (rc) {
26840260731fSTejun Heo 				ata_link_printk(link, KERN_ERR,
2685c6fd2807SJeff Garzik 						"reset failed, giving up\n");
2686c6fd2807SJeff Garzik 				goto out;
2687c6fd2807SJeff Garzik 			}
26889b1e2658STejun Heo 		}
2689c6fd2807SJeff Garzik 
2690b06ce3e5STejun Heo 		if (!ap->nr_pmp_links)
2691c6fd2807SJeff Garzik 			ata_eh_thaw_port(ap);
2692c6fd2807SJeff Garzik 	}
2693c6fd2807SJeff Garzik 
26949b1e2658STejun Heo 	/* the rest */
26959b1e2658STejun Heo 	ata_port_for_each_link(link, ap) {
26969b1e2658STejun Heo 		struct ata_eh_context *ehc = &link->eh_context;
26979b1e2658STejun Heo 
2698c6fd2807SJeff Garzik 		/* revalidate existing devices and attach new ones */
26990260731fSTejun Heo 		rc = ata_eh_revalidate_and_attach(link, &dev);
2700c6fd2807SJeff Garzik 		if (rc)
2701c6fd2807SJeff Garzik 			goto dev_fail;
2702c6fd2807SJeff Garzik 
2703633273a3STejun Heo 		/* if PMP got attached, return, pmp EH will take care of it */
2704633273a3STejun Heo 		if (link->device->class == ATA_DEV_PMP) {
2705633273a3STejun Heo 			ehc->i.action = 0;
2706633273a3STejun Heo 			return 0;
2707633273a3STejun Heo 		}
2708633273a3STejun Heo 
2709baa1e78aSTejun Heo 		/* configure transfer mode if necessary */
2710baa1e78aSTejun Heo 		if (ehc->i.flags & ATA_EHI_SETMODE) {
27110260731fSTejun Heo 			rc = ata_set_mode(link, &dev);
27124ae72a1eSTejun Heo 			if (rc)
2713c6fd2807SJeff Garzik 				goto dev_fail;
2714baa1e78aSTejun Heo 			ehc->i.flags &= ~ATA_EHI_SETMODE;
2715c6fd2807SJeff Garzik 		}
2716c6fd2807SJeff Garzik 
27173ec25ebdSTejun Heo 		if (ehc->i.action & ATA_EH_LPM)
2718ca77329fSKristen Carlson Accardi 			ata_link_for_each_dev(dev, link)
2719ca77329fSKristen Carlson Accardi 				ata_dev_enable_pm(dev, ap->pm_policy);
2720ca77329fSKristen Carlson Accardi 
27219b1e2658STejun Heo 		/* this link is okay now */
27229b1e2658STejun Heo 		ehc->i.flags = 0;
27239b1e2658STejun Heo 		continue;
2724c6fd2807SJeff Garzik 
2725c6fd2807SJeff Garzik dev_fail:
27269b1e2658STejun Heo 		nr_failed_devs++;
27279b1e2658STejun Heo 		if (ata_eh_handle_dev_fail(dev, rc))
27289b1e2658STejun Heo 			nr_disabled_devs++;
2729c6fd2807SJeff Garzik 
2730b06ce3e5STejun Heo 		if (ap->pflags & ATA_PFLAG_FROZEN) {
2731b06ce3e5STejun Heo 			/* PMP reset requires working host port.
2732b06ce3e5STejun Heo 			 * Can't retry if it's frozen.
2733b06ce3e5STejun Heo 			 */
2734b06ce3e5STejun Heo 			if (ap->nr_pmp_links)
2735b06ce3e5STejun Heo 				goto out;
27369b1e2658STejun Heo 			break;
27379b1e2658STejun Heo 		}
2738b06ce3e5STejun Heo 	}
27399b1e2658STejun Heo 
27409b1e2658STejun Heo 	if (nr_failed_devs) {
27419b1e2658STejun Heo 		if (nr_failed_devs != nr_disabled_devs) {
27429b1e2658STejun Heo 			ata_port_printk(ap, KERN_WARNING, "failed to recover "
27439b1e2658STejun Heo 					"some devices, retrying in 5 secs\n");
2744c6fd2807SJeff Garzik 			ssleep(5);
2745c6fd2807SJeff Garzik 		} else {
27469b1e2658STejun Heo 			/* no device left to recover, repeat fast */
2747c6fd2807SJeff Garzik 			msleep(500);
2748c6fd2807SJeff Garzik 		}
2749c6fd2807SJeff Garzik 
2750c6fd2807SJeff Garzik 		goto retry;
27519b1e2658STejun Heo 	}
2752c6fd2807SJeff Garzik 
2753c6fd2807SJeff Garzik  out:
27549b1e2658STejun Heo 	if (rc && r_failed_link)
27559b1e2658STejun Heo 		*r_failed_link = link;
2756c6fd2807SJeff Garzik 
2757c6fd2807SJeff Garzik 	DPRINTK("EXIT, rc=%d\n", rc);
2758c6fd2807SJeff Garzik 	return rc;
2759c6fd2807SJeff Garzik }
2760c6fd2807SJeff Garzik 
2761c6fd2807SJeff Garzik /**
2762c6fd2807SJeff Garzik  *	ata_eh_finish - finish up EH
2763c6fd2807SJeff Garzik  *	@ap: host port to finish EH for
2764c6fd2807SJeff Garzik  *
2765c6fd2807SJeff Garzik  *	Recovery is complete.  Clean up EH states and retry or finish
2766c6fd2807SJeff Garzik  *	failed qcs.
2767c6fd2807SJeff Garzik  *
2768c6fd2807SJeff Garzik  *	LOCKING:
2769c6fd2807SJeff Garzik  *	None.
2770c6fd2807SJeff Garzik  */
2771fb7fd614STejun Heo void ata_eh_finish(struct ata_port *ap)
2772c6fd2807SJeff Garzik {
2773c6fd2807SJeff Garzik 	int tag;
2774c6fd2807SJeff Garzik 
2775c6fd2807SJeff Garzik 	/* retry or finish qcs */
2776c6fd2807SJeff Garzik 	for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2777c6fd2807SJeff Garzik 		struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2778c6fd2807SJeff Garzik 
2779c6fd2807SJeff Garzik 		if (!(qc->flags & ATA_QCFLAG_FAILED))
2780c6fd2807SJeff Garzik 			continue;
2781c6fd2807SJeff Garzik 
2782c6fd2807SJeff Garzik 		if (qc->err_mask) {
2783c6fd2807SJeff Garzik 			/* FIXME: Once EH migration is complete,
2784c6fd2807SJeff Garzik 			 * generate sense data in this function,
2785c6fd2807SJeff Garzik 			 * considering both err_mask and tf.
2786c6fd2807SJeff Garzik 			 */
278703faab78STejun Heo 			if (qc->flags & ATA_QCFLAG_RETRY)
2788c6fd2807SJeff Garzik 				ata_eh_qc_retry(qc);
278903faab78STejun Heo 			else
279003faab78STejun Heo 				ata_eh_qc_complete(qc);
2791c6fd2807SJeff Garzik 		} else {
2792c6fd2807SJeff Garzik 			if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
2793c6fd2807SJeff Garzik 				ata_eh_qc_complete(qc);
2794c6fd2807SJeff Garzik 			} else {
2795c6fd2807SJeff Garzik 				/* feed zero TF to sense generation */
2796c6fd2807SJeff Garzik 				memset(&qc->result_tf, 0, sizeof(qc->result_tf));
2797c6fd2807SJeff Garzik 				ata_eh_qc_retry(qc);
2798c6fd2807SJeff Garzik 			}
2799c6fd2807SJeff Garzik 		}
2800c6fd2807SJeff Garzik 	}
2801da917d69STejun Heo 
2802da917d69STejun Heo 	/* make sure nr_active_links is zero after EH */
2803da917d69STejun Heo 	WARN_ON(ap->nr_active_links);
2804da917d69STejun Heo 	ap->nr_active_links = 0;
2805c6fd2807SJeff Garzik }
2806c6fd2807SJeff Garzik 
2807c6fd2807SJeff Garzik /**
2808c6fd2807SJeff Garzik  *	ata_do_eh - do standard error handling
2809c6fd2807SJeff Garzik  *	@ap: host port to handle error for
2810a1efdabaSTejun Heo  *
2811c6fd2807SJeff Garzik  *	@prereset: prereset method (can be NULL)
2812c6fd2807SJeff Garzik  *	@softreset: softreset method (can be NULL)
2813c6fd2807SJeff Garzik  *	@hardreset: hardreset method (can be NULL)
2814c6fd2807SJeff Garzik  *	@postreset: postreset method (can be NULL)
2815c6fd2807SJeff Garzik  *
2816c6fd2807SJeff Garzik  *	Perform standard error handling sequence.
2817c6fd2807SJeff Garzik  *
2818c6fd2807SJeff Garzik  *	LOCKING:
2819c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
2820c6fd2807SJeff Garzik  */
2821c6fd2807SJeff Garzik void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
2822c6fd2807SJeff Garzik 	       ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
2823c6fd2807SJeff Garzik 	       ata_postreset_fn_t postreset)
2824c6fd2807SJeff Garzik {
28259b1e2658STejun Heo 	struct ata_device *dev;
28269b1e2658STejun Heo 	int rc;
28279b1e2658STejun Heo 
28289b1e2658STejun Heo 	ata_eh_autopsy(ap);
28299b1e2658STejun Heo 	ata_eh_report(ap);
28309b1e2658STejun Heo 
28319b1e2658STejun Heo 	rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
28329b1e2658STejun Heo 			    NULL);
28339b1e2658STejun Heo 	if (rc) {
28349b1e2658STejun Heo 		ata_link_for_each_dev(dev, &ap->link)
28359b1e2658STejun Heo 			ata_dev_disable(dev);
28369b1e2658STejun Heo 	}
28379b1e2658STejun Heo 
2838c6fd2807SJeff Garzik 	ata_eh_finish(ap);
2839c6fd2807SJeff Garzik }
2840c6fd2807SJeff Garzik 
2841a1efdabaSTejun Heo /**
2842a1efdabaSTejun Heo  *	ata_std_error_handler - standard error handler
2843a1efdabaSTejun Heo  *	@ap: host port to handle error for
2844a1efdabaSTejun Heo  *
2845a1efdabaSTejun Heo  *	Standard error handler
2846a1efdabaSTejun Heo  *
2847a1efdabaSTejun Heo  *	LOCKING:
2848a1efdabaSTejun Heo  *	Kernel thread context (may sleep).
2849a1efdabaSTejun Heo  */
2850a1efdabaSTejun Heo void ata_std_error_handler(struct ata_port *ap)
2851a1efdabaSTejun Heo {
2852a1efdabaSTejun Heo 	struct ata_port_operations *ops = ap->ops;
2853a1efdabaSTejun Heo 	ata_reset_fn_t hardreset = ops->hardreset;
2854a1efdabaSTejun Heo 
285557c9efdfSTejun Heo 	/* ignore built-in hardreset if SCR access is not available */
285657c9efdfSTejun Heo 	if (ata_is_builtin_hardreset(hardreset) && !sata_scr_valid(&ap->link))
2857a1efdabaSTejun Heo 		hardreset = NULL;
2858a1efdabaSTejun Heo 
2859a1efdabaSTejun Heo 	ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);
2860a1efdabaSTejun Heo }
2861a1efdabaSTejun Heo 
28626ffa01d8STejun Heo #ifdef CONFIG_PM
2863c6fd2807SJeff Garzik /**
2864c6fd2807SJeff Garzik  *	ata_eh_handle_port_suspend - perform port suspend operation
2865c6fd2807SJeff Garzik  *	@ap: port to suspend
2866c6fd2807SJeff Garzik  *
2867c6fd2807SJeff Garzik  *	Suspend @ap.
2868c6fd2807SJeff Garzik  *
2869c6fd2807SJeff Garzik  *	LOCKING:
2870c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
2871c6fd2807SJeff Garzik  */
2872c6fd2807SJeff Garzik static void ata_eh_handle_port_suspend(struct ata_port *ap)
2873c6fd2807SJeff Garzik {
2874c6fd2807SJeff Garzik 	unsigned long flags;
2875c6fd2807SJeff Garzik 	int rc = 0;
2876c6fd2807SJeff Garzik 
2877c6fd2807SJeff Garzik 	/* are we suspending? */
2878c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
2879c6fd2807SJeff Garzik 	if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
2880c6fd2807SJeff Garzik 	    ap->pm_mesg.event == PM_EVENT_ON) {
2881c6fd2807SJeff Garzik 		spin_unlock_irqrestore(ap->lock, flags);
2882c6fd2807SJeff Garzik 		return;
2883c6fd2807SJeff Garzik 	}
2884c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
2885c6fd2807SJeff Garzik 
2886c6fd2807SJeff Garzik 	WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
2887c6fd2807SJeff Garzik 
288864578a3dSTejun Heo 	/* tell ACPI we're suspending */
288964578a3dSTejun Heo 	rc = ata_acpi_on_suspend(ap);
289064578a3dSTejun Heo 	if (rc)
289164578a3dSTejun Heo 		goto out;
289264578a3dSTejun Heo 
2893c6fd2807SJeff Garzik 	/* suspend */
2894c6fd2807SJeff Garzik 	ata_eh_freeze_port(ap);
2895c6fd2807SJeff Garzik 
2896c6fd2807SJeff Garzik 	if (ap->ops->port_suspend)
2897c6fd2807SJeff Garzik 		rc = ap->ops->port_suspend(ap, ap->pm_mesg);
2898c6fd2807SJeff Garzik 
2899bd3adca5SShaohua Li 	ata_acpi_set_state(ap, PMSG_SUSPEND);
290064578a3dSTejun Heo  out:
2901c6fd2807SJeff Garzik 	/* report result */
2902c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
2903c6fd2807SJeff Garzik 
2904c6fd2807SJeff Garzik 	ap->pflags &= ~ATA_PFLAG_PM_PENDING;
2905c6fd2807SJeff Garzik 	if (rc == 0)
2906c6fd2807SJeff Garzik 		ap->pflags |= ATA_PFLAG_SUSPENDED;
290764578a3dSTejun Heo 	else if (ap->pflags & ATA_PFLAG_FROZEN)
2908c6fd2807SJeff Garzik 		ata_port_schedule_eh(ap);
2909c6fd2807SJeff Garzik 
2910c6fd2807SJeff Garzik 	if (ap->pm_result) {
2911c6fd2807SJeff Garzik 		*ap->pm_result = rc;
2912c6fd2807SJeff Garzik 		ap->pm_result = NULL;
2913c6fd2807SJeff Garzik 	}
2914c6fd2807SJeff Garzik 
2915c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
2916c6fd2807SJeff Garzik 
2917c6fd2807SJeff Garzik 	return;
2918c6fd2807SJeff Garzik }
2919c6fd2807SJeff Garzik 
2920c6fd2807SJeff Garzik /**
2921c6fd2807SJeff Garzik  *	ata_eh_handle_port_resume - perform port resume operation
2922c6fd2807SJeff Garzik  *	@ap: port to resume
2923c6fd2807SJeff Garzik  *
2924c6fd2807SJeff Garzik  *	Resume @ap.
2925c6fd2807SJeff Garzik  *
2926c6fd2807SJeff Garzik  *	LOCKING:
2927c6fd2807SJeff Garzik  *	Kernel thread context (may sleep).
2928c6fd2807SJeff Garzik  */
2929c6fd2807SJeff Garzik static void ata_eh_handle_port_resume(struct ata_port *ap)
2930c6fd2807SJeff Garzik {
2931c6fd2807SJeff Garzik 	unsigned long flags;
29329666f400STejun Heo 	int rc = 0;
2933c6fd2807SJeff Garzik 
2934c6fd2807SJeff Garzik 	/* are we resuming? */
2935c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
2936c6fd2807SJeff Garzik 	if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
2937c6fd2807SJeff Garzik 	    ap->pm_mesg.event != PM_EVENT_ON) {
2938c6fd2807SJeff Garzik 		spin_unlock_irqrestore(ap->lock, flags);
2939c6fd2807SJeff Garzik 		return;
2940c6fd2807SJeff Garzik 	}
2941c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
2942c6fd2807SJeff Garzik 
29439666f400STejun Heo 	WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
2944c6fd2807SJeff Garzik 
2945bd3adca5SShaohua Li 	ata_acpi_set_state(ap, PMSG_ON);
2946bd3adca5SShaohua Li 
2947c6fd2807SJeff Garzik 	if (ap->ops->port_resume)
2948c6fd2807SJeff Garzik 		rc = ap->ops->port_resume(ap);
2949c6fd2807SJeff Garzik 
29506746544cSTejun Heo 	/* tell ACPI that we're resuming */
29516746544cSTejun Heo 	ata_acpi_on_resume(ap);
29526746544cSTejun Heo 
29539666f400STejun Heo 	/* report result */
2954c6fd2807SJeff Garzik 	spin_lock_irqsave(ap->lock, flags);
2955c6fd2807SJeff Garzik 	ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
2956c6fd2807SJeff Garzik 	if (ap->pm_result) {
2957c6fd2807SJeff Garzik 		*ap->pm_result = rc;
2958c6fd2807SJeff Garzik 		ap->pm_result = NULL;
2959c6fd2807SJeff Garzik 	}
2960c6fd2807SJeff Garzik 	spin_unlock_irqrestore(ap->lock, flags);
2961c6fd2807SJeff Garzik }
29626ffa01d8STejun Heo #endif /* CONFIG_PM */
2963