blob: a9b282038000c921eca51f7484866d890dec5d54 [file] [log] [blame]
Tejun Heoece1d632006-04-02 18:51:53 +09001/*
2 * libata-eh.c - libata error handling
3 *
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
6 * on emails.
7 *
8 * Copyright 2006 Tejun Heo <htejun@gmail.com>
9 *
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; see the file COPYING. If not, write to
23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
24 * USA.
25 *
26 *
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
29 *
30 * Hardware documentation available from http://www.t13.org/ and
31 * http://www.sata-io.org/
32 *
33 */
34
Tejun Heoece1d632006-04-02 18:51:53 +090035#include <linux/kernel.h>
Jens Axboe242f9dc2008-09-14 05:55:09 -070036#include <linux/blkdev.h>
Paul Gortmaker38789fd2011-07-17 15:33:58 -040037#include <linux/export.h>
Jeff Garzik28555682007-10-11 17:12:35 -040038#include <linux/pci.h>
Tejun Heoece1d632006-04-02 18:51:53 +090039#include <scsi/scsi.h>
40#include <scsi/scsi_host.h>
41#include <scsi/scsi_eh.h>
42#include <scsi/scsi_device.h>
43#include <scsi/scsi_cmnd.h>
Robert Hancock65211482009-07-14 20:43:39 -060044#include <scsi/scsi_dbg.h>
Jeff Garzikc6fd2802006-08-10 07:31:37 -040045#include "../scsi/scsi_transport_api.h"
Tejun Heoece1d632006-04-02 18:51:53 +090046
47#include <linux/libata.h>
48
49#include "libata.h"
50
Tejun Heo7d47e8d2007-02-02 16:22:31 +090051enum {
Tejun Heo3884f7b2007-11-27 19:28:56 +090052 /* speed down verdicts */
Tejun Heo7d47e8d2007-02-02 16:22:31 +090053 ATA_EH_SPDN_NCQ_OFF = (1 << 0),
54 ATA_EH_SPDN_SPEED_DOWN = (1 << 1),
55 ATA_EH_SPDN_FALLBACK_TO_PIO = (1 << 2),
Tejun Heo76326ac2007-11-27 19:28:59 +090056 ATA_EH_SPDN_KEEP_ERRORS = (1 << 3),
Tejun Heo3884f7b2007-11-27 19:28:56 +090057
58 /* error flags */
59 ATA_EFLAG_IS_IO = (1 << 0),
Tejun Heo76326ac2007-11-27 19:28:59 +090060 ATA_EFLAG_DUBIOUS_XFER = (1 << 1),
Gwendal Grignoud9027472010-05-25 12:31:38 -070061 ATA_EFLAG_OLD_ER = (1 << 31),
Tejun Heo3884f7b2007-11-27 19:28:56 +090062
63 /* error categories */
64 ATA_ECAT_NONE = 0,
65 ATA_ECAT_ATA_BUS = 1,
66 ATA_ECAT_TOUT_HSM = 2,
67 ATA_ECAT_UNK_DEV = 3,
Tejun Heo75f9caf2008-01-03 01:21:14 +090068 ATA_ECAT_DUBIOUS_NONE = 4,
69 ATA_ECAT_DUBIOUS_ATA_BUS = 5,
70 ATA_ECAT_DUBIOUS_TOUT_HSM = 6,
71 ATA_ECAT_DUBIOUS_UNK_DEV = 7,
72 ATA_ECAT_NR = 8,
Tejun Heo7d47e8d2007-02-02 16:22:31 +090073
Tejun Heo87fbc5a2008-05-20 02:17:54 +090074 ATA_EH_CMD_DFL_TIMEOUT = 5000,
75
Tejun Heo0a2c0f52008-05-20 02:17:52 +090076 /* always put at least this amount of time between resets */
77 ATA_EH_RESET_COOL_DOWN = 5000,
78
Tejun Heo341c2c92008-05-20 02:17:51 +090079 /* Waiting in ->prereset can never be reliable. It's
80 * sometimes nice to wait there but it can't be depended upon;
81 * otherwise, we wouldn't be resetting. Just give it enough
82 * time for most drives to spin up.
83 */
84 ATA_EH_PRERESET_TIMEOUT = 10000,
85 ATA_EH_FASTDRAIN_INTERVAL = 3000,
Tejun Heo11fc33d2008-08-30 14:20:01 +020086
87 ATA_EH_UA_TRIES = 5,
Tejun Heoc2c7a892009-01-29 20:31:34 +090088
89 /* probe speed down parameters, see ata_eh_schedule_probe() */
90 ATA_EH_PROBE_TRIAL_INTERVAL = 60000, /* 1 min */
91 ATA_EH_PROBE_TRIALS = 2,
Tejun Heo31daabd2007-02-02 16:50:52 +090092};
93
94/* The following table determines how we sequence resets. Each entry
95 * represents timeout for that try. The first try can be soft or
96 * hardreset. All others are hardreset if available. In most cases
97 * the first reset w/ 10sec timeout should succeed. Following entries
98 * are mostly for error handling, hotplug and retarded devices.
99 */
100static const unsigned long ata_eh_reset_timeouts[] = {
Tejun Heo341c2c92008-05-20 02:17:51 +0900101 10000, /* most drives spin up by 10sec */
102 10000, /* > 99% working drives spin up before 20sec */
103 35000, /* give > 30 secs of idleness for retarded devices */
104 5000, /* and sweet one last chance */
Tejun Heod8af0eb2008-05-20 02:17:53 +0900105 ULONG_MAX, /* > 1 min has elapsed, give up */
Tejun Heo31daabd2007-02-02 16:50:52 +0900106};
107
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900108static const unsigned long ata_eh_identify_timeouts[] = {
109 5000, /* covers > 99% of successes and not too boring on failures */
110 10000, /* combined time till here is enough even for media access */
111 30000, /* for true idiots */
112 ULONG_MAX,
113};
114
Tejun Heo6013efd2009-11-19 15:36:45 +0900115static const unsigned long ata_eh_flush_timeouts[] = {
116 15000, /* be generous with flush */
117 15000, /* ditto */
118 30000, /* and even more generous */
119 ULONG_MAX,
120};
121
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900122static const unsigned long ata_eh_other_timeouts[] = {
123 5000, /* same rationale as identify timeout */
124 10000, /* ditto */
125 /* but no merciful 30sec for other commands, it just isn't worth it */
126 ULONG_MAX,
127};
128
129struct ata_eh_cmd_timeout_ent {
130 const u8 *commands;
131 const unsigned long *timeouts;
132};
133
134/* The following table determines timeouts to use for EH internal
135 * commands. Each table entry is a command class and matches the
136 * commands the entry applies to and the timeout table to use.
137 *
138 * On the retry after a command timed out, the next timeout value from
139 * the table is used. If the table doesn't contain further entries,
140 * the last value is used.
141 *
142 * ehc->cmd_timeout_idx keeps track of which timeout to use per
143 * command class, so if SET_FEATURES times out on the first try, the
144 * next try will use the second timeout value only for that class.
145 */
146#define CMDS(cmds...) (const u8 []){ cmds, 0 }
147static const struct ata_eh_cmd_timeout_ent
148ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = {
149 { .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI),
150 .timeouts = ata_eh_identify_timeouts, },
151 { .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT),
152 .timeouts = ata_eh_other_timeouts, },
153 { .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT),
154 .timeouts = ata_eh_other_timeouts, },
155 { .commands = CMDS(ATA_CMD_SET_FEATURES),
156 .timeouts = ata_eh_other_timeouts, },
157 { .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS),
158 .timeouts = ata_eh_other_timeouts, },
Tejun Heo6013efd2009-11-19 15:36:45 +0900159 { .commands = CMDS(ATA_CMD_FLUSH, ATA_CMD_FLUSH_EXT),
160 .timeouts = ata_eh_flush_timeouts },
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900161};
162#undef CMDS
163
Tejun Heoad9e2762006-05-15 20:58:12 +0900164static void __ata_port_freeze(struct ata_port *ap);
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900165#ifdef CONFIG_PM
Tejun Heo500530f2006-07-03 16:07:27 +0900166static void ata_eh_handle_port_suspend(struct ata_port *ap);
167static void ata_eh_handle_port_resume(struct ata_port *ap);
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900168#else /* CONFIG_PM */
169static void ata_eh_handle_port_suspend(struct ata_port *ap)
170{ }
171
172static void ata_eh_handle_port_resume(struct ata_port *ap)
173{ }
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900174#endif /* CONFIG_PM */
Tejun Heoad9e2762006-05-15 20:58:12 +0900175
Tejun Heob64bbc32007-07-16 14:29:39 +0900176static void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, const char *fmt,
177 va_list args)
178{
179 ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
180 ATA_EH_DESC_LEN - ehi->desc_len,
181 fmt, args);
182}
183
184/**
185 * __ata_ehi_push_desc - push error description without adding separator
186 * @ehi: target EHI
187 * @fmt: printf format string
188 *
189 * Format string according to @fmt and append it to @ehi->desc.
190 *
191 * LOCKING:
192 * spin_lock_irqsave(host lock)
193 */
194void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
195{
196 va_list args;
197
198 va_start(args, fmt);
199 __ata_ehi_pushv_desc(ehi, fmt, args);
200 va_end(args);
201}
202
203/**
204 * ata_ehi_push_desc - push error description with separator
205 * @ehi: target EHI
206 * @fmt: printf format string
207 *
208 * Format string according to @fmt and append it to @ehi->desc.
209 * If @ehi->desc is not empty, ", " is added in-between.
210 *
211 * LOCKING:
212 * spin_lock_irqsave(host lock)
213 */
214void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
215{
216 va_list args;
217
218 if (ehi->desc_len)
219 __ata_ehi_push_desc(ehi, ", ");
220
221 va_start(args, fmt);
222 __ata_ehi_pushv_desc(ehi, fmt, args);
223 va_end(args);
224}
225
226/**
227 * ata_ehi_clear_desc - clean error description
228 * @ehi: target EHI
229 *
230 * Clear @ehi->desc.
231 *
232 * LOCKING:
233 * spin_lock_irqsave(host lock)
234 */
235void ata_ehi_clear_desc(struct ata_eh_info *ehi)
236{
237 ehi->desc[0] = '\0';
238 ehi->desc_len = 0;
239}
240
Tejun Heocbcdd872007-08-18 13:14:55 +0900241/**
242 * ata_port_desc - append port description
243 * @ap: target ATA port
244 * @fmt: printf format string
245 *
246 * Format string according to @fmt and append it to port
247 * description. If port description is not empty, " " is added
248 * in-between. This function is to be used while initializing
249 * ata_host. The description is printed on host registration.
250 *
251 * LOCKING:
252 * None.
253 */
254void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
255{
256 va_list args;
257
258 WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
259
260 if (ap->link.eh_info.desc_len)
261 __ata_ehi_push_desc(&ap->link.eh_info, " ");
262
263 va_start(args, fmt);
264 __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
265 va_end(args);
266}
267
268#ifdef CONFIG_PCI
269
270/**
271 * ata_port_pbar_desc - append PCI BAR description
272 * @ap: target ATA port
273 * @bar: target PCI BAR
274 * @offset: offset into PCI BAR
275 * @name: name of the area
276 *
277 * If @offset is negative, this function formats a string which
278 * contains the name, address, size and type of the BAR and
279 * appends it to the port description. If @offset is zero or
280 * positive, only name and offsetted address is appended.
281 *
282 * LOCKING:
283 * None.
284 */
285void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
286 const char *name)
287{
288 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
289 char *type = "";
290 unsigned long long start, len;
291
292 if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
293 type = "m";
294 else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
295 type = "i";
296
297 start = (unsigned long long)pci_resource_start(pdev, bar);
298 len = (unsigned long long)pci_resource_len(pdev, bar);
299
300 if (offset < 0)
301 ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
302 else
Andrew Mortone6a73ab2007-12-13 16:01:37 -0800303 ata_port_desc(ap, "%s 0x%llx", name,
304 start + (unsigned long long)offset);
Tejun Heocbcdd872007-08-18 13:14:55 +0900305}
306
307#endif /* CONFIG_PCI */
308
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900309static int ata_lookup_timeout_table(u8 cmd)
310{
311 int i;
312
313 for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) {
314 const u8 *cur;
315
316 for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++)
317 if (*cur == cmd)
318 return i;
319 }
320
321 return -1;
322}
323
324/**
325 * ata_internal_cmd_timeout - determine timeout for an internal command
326 * @dev: target device
327 * @cmd: internal command to be issued
328 *
329 * Determine timeout for internal command @cmd for @dev.
330 *
331 * LOCKING:
332 * EH context.
333 *
334 * RETURNS:
335 * Determined timeout.
336 */
337unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd)
338{
339 struct ata_eh_context *ehc = &dev->link->eh_context;
340 int ent = ata_lookup_timeout_table(cmd);
341 int idx;
342
343 if (ent < 0)
344 return ATA_EH_CMD_DFL_TIMEOUT;
345
346 idx = ehc->cmd_timeout_idx[dev->devno][ent];
347 return ata_eh_cmd_timeout_table[ent].timeouts[idx];
348}
349
350/**
351 * ata_internal_cmd_timed_out - notification for internal command timeout
352 * @dev: target device
353 * @cmd: internal command which timed out
354 *
355 * Notify EH that internal command @cmd for @dev timed out. This
356 * function should be called only for commands whose timeouts are
357 * determined using ata_internal_cmd_timeout().
358 *
359 * LOCKING:
360 * EH context.
361 */
362void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd)
363{
364 struct ata_eh_context *ehc = &dev->link->eh_context;
365 int ent = ata_lookup_timeout_table(cmd);
366 int idx;
367
368 if (ent < 0)
369 return;
370
371 idx = ehc->cmd_timeout_idx[dev->devno][ent];
372 if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX)
373 ehc->cmd_timeout_idx[dev->devno][ent]++;
374}
375
Tejun Heo3884f7b2007-11-27 19:28:56 +0900376static void ata_ering_record(struct ata_ering *ering, unsigned int eflags,
Tejun Heo0c247c52006-05-15 20:58:19 +0900377 unsigned int err_mask)
378{
379 struct ata_ering_entry *ent;
380
381 WARN_ON(!err_mask);
382
383 ering->cursor++;
384 ering->cursor %= ATA_ERING_SIZE;
385
386 ent = &ering->ring[ering->cursor];
Tejun Heo3884f7b2007-11-27 19:28:56 +0900387 ent->eflags = eflags;
Tejun Heo0c247c52006-05-15 20:58:19 +0900388 ent->err_mask = err_mask;
389 ent->timestamp = get_jiffies_64();
390}
391
Tejun Heo76326ac2007-11-27 19:28:59 +0900392static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
393{
394 struct ata_ering_entry *ent = &ering->ring[ering->cursor];
395
396 if (ent->err_mask)
397 return ent;
398 return NULL;
399}
400
Gwendal Grignoud9027472010-05-25 12:31:38 -0700401int ata_ering_map(struct ata_ering *ering,
402 int (*map_fn)(struct ata_ering_entry *, void *),
403 void *arg)
Tejun Heo0c247c52006-05-15 20:58:19 +0900404{
405 int idx, rc = 0;
406 struct ata_ering_entry *ent;
407
408 idx = ering->cursor;
409 do {
410 ent = &ering->ring[idx];
411 if (!ent->err_mask)
412 break;
413 rc = map_fn(ent, arg);
414 if (rc)
415 break;
416 idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
417 } while (idx != ering->cursor);
418
419 return rc;
420}
421
Gwendal Grignoud9027472010-05-25 12:31:38 -0700422int ata_ering_clear_cb(struct ata_ering_entry *ent, void *void_arg)
423{
424 ent->eflags |= ATA_EFLAG_OLD_ER;
425 return 0;
426}
427
428static void ata_ering_clear(struct ata_ering *ering)
429{
430 ata_ering_map(ering, ata_ering_clear_cb, NULL);
431}
432
Tejun Heo64f65ca2006-06-24 20:30:18 +0900433static unsigned int ata_eh_dev_action(struct ata_device *dev)
434{
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900435 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heo64f65ca2006-06-24 20:30:18 +0900436
437 return ehc->i.action | ehc->i.dev_action[dev->devno];
438}
439
Tejun Heof58229f2007-08-06 18:36:23 +0900440static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
Tejun Heoaf181c22006-06-24 20:30:18 +0900441 struct ata_eh_info *ehi, unsigned int action)
442{
Tejun Heof58229f2007-08-06 18:36:23 +0900443 struct ata_device *tdev;
Tejun Heoaf181c22006-06-24 20:30:18 +0900444
445 if (!dev) {
446 ehi->action &= ~action;
Tejun Heo1eca4362008-11-03 20:03:17 +0900447 ata_for_each_dev(tdev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +0900448 ehi->dev_action[tdev->devno] &= ~action;
Tejun Heoaf181c22006-06-24 20:30:18 +0900449 } else {
450 /* doesn't make sense for port-wide EH actions */
451 WARN_ON(!(action & ATA_EH_PERDEV_MASK));
452
453 /* break ehi->action into ehi->dev_action */
454 if (ehi->action & action) {
Tejun Heo1eca4362008-11-03 20:03:17 +0900455 ata_for_each_dev(tdev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +0900456 ehi->dev_action[tdev->devno] |=
457 ehi->action & action;
Tejun Heoaf181c22006-06-24 20:30:18 +0900458 ehi->action &= ~action;
459 }
460
461 /* turn off the specified per-dev action */
462 ehi->dev_action[dev->devno] &= ~action;
463 }
464}
465
Tejun Heoece1d632006-04-02 18:51:53 +0900466/**
Tejun Heoc0c362b2010-09-06 17:57:14 +0200467 * ata_eh_acquire - acquire EH ownership
468 * @ap: ATA port to acquire EH ownership for
469 *
470 * Acquire EH ownership for @ap. This is the basic exclusion
471 * mechanism for ports sharing a host. Only one port hanging off
472 * the same host can claim the ownership of EH.
473 *
474 * LOCKING:
475 * EH context.
476 */
477void ata_eh_acquire(struct ata_port *ap)
478{
479 mutex_lock(&ap->host->eh_mutex);
480 WARN_ON_ONCE(ap->host->eh_owner);
481 ap->host->eh_owner = current;
482}
483
484/**
485 * ata_eh_release - release EH ownership
486 * @ap: ATA port to release EH ownership for
487 *
488 * Release EH ownership for @ap if the caller. The caller must
489 * have acquired EH ownership using ata_eh_acquire() previously.
490 *
491 * LOCKING:
492 * EH context.
493 */
494void ata_eh_release(struct ata_port *ap)
495{
496 WARN_ON_ONCE(ap->host->eh_owner != current);
497 ap->host->eh_owner = NULL;
498 mutex_unlock(&ap->host->eh_mutex);
499}
500
501/**
Tejun Heoece1d632006-04-02 18:51:53 +0900502 * ata_scsi_timed_out - SCSI layer time out callback
503 * @cmd: timed out SCSI command
504 *
505 * Handles SCSI layer timeout. We race with normal completion of
506 * the qc for @cmd. If the qc is already gone, we lose and let
507 * the scsi command finish (EH_HANDLED). Otherwise, the qc has
508 * timed out and EH should be invoked. Prevent ata_qc_complete()
509 * from finishing it by setting EH_SCHEDULED and return
510 * EH_NOT_HANDLED.
511 *
Tejun Heoad9e2762006-05-15 20:58:12 +0900512 * TODO: kill this function once old EH is gone.
513 *
Tejun Heoece1d632006-04-02 18:51:53 +0900514 * LOCKING:
515 * Called from timer context
516 *
517 * RETURNS:
518 * EH_HANDLED or EH_NOT_HANDLED
519 */
Jens Axboe242f9dc2008-09-14 05:55:09 -0700520enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
Tejun Heoece1d632006-04-02 18:51:53 +0900521{
522 struct Scsi_Host *host = cmd->device->host;
Jeff Garzik35bb94b2006-04-11 13:12:34 -0400523 struct ata_port *ap = ata_shost_to_port(host);
Tejun Heoece1d632006-04-02 18:51:53 +0900524 unsigned long flags;
525 struct ata_queued_cmd *qc;
Jens Axboe242f9dc2008-09-14 05:55:09 -0700526 enum blk_eh_timer_return ret;
Tejun Heoece1d632006-04-02 18:51:53 +0900527
528 DPRINTK("ENTER\n");
529
Tejun Heoad9e2762006-05-15 20:58:12 +0900530 if (ap->ops->error_handler) {
Jens Axboe242f9dc2008-09-14 05:55:09 -0700531 ret = BLK_EH_NOT_HANDLED;
Tejun Heoad9e2762006-05-15 20:58:12 +0900532 goto out;
533 }
534
Jens Axboe242f9dc2008-09-14 05:55:09 -0700535 ret = BLK_EH_HANDLED;
Jeff Garzikba6a1302006-06-22 23:46:10 -0400536 spin_lock_irqsave(ap->lock, flags);
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900537 qc = ata_qc_from_tag(ap, ap->link.active_tag);
Tejun Heoece1d632006-04-02 18:51:53 +0900538 if (qc) {
539 WARN_ON(qc->scsicmd != cmd);
540 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
541 qc->err_mask |= AC_ERR_TIMEOUT;
Jens Axboe242f9dc2008-09-14 05:55:09 -0700542 ret = BLK_EH_NOT_HANDLED;
Tejun Heoece1d632006-04-02 18:51:53 +0900543 }
Jeff Garzikba6a1302006-06-22 23:46:10 -0400544 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +0900545
Tejun Heoad9e2762006-05-15 20:58:12 +0900546 out:
Tejun Heoece1d632006-04-02 18:51:53 +0900547 DPRINTK("EXIT, ret=%d\n", ret);
548 return ret;
549}
550
Tejun Heoece180d2008-11-03 20:04:37 +0900551static void ata_eh_unload(struct ata_port *ap)
552{
553 struct ata_link *link;
554 struct ata_device *dev;
555 unsigned long flags;
556
557 /* Restore SControl IPM and SPD for the next driver and
558 * disable attached devices.
559 */
560 ata_for_each_link(link, ap, PMP_FIRST) {
561 sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);
562 ata_for_each_dev(dev, link, ALL)
563 ata_dev_disable(dev);
564 }
565
566 /* freeze and set UNLOADED */
567 spin_lock_irqsave(ap->lock, flags);
568
569 ata_port_freeze(ap); /* won't be thawed */
570 ap->pflags &= ~ATA_PFLAG_EH_PENDING; /* clear pending from freeze */
571 ap->pflags |= ATA_PFLAG_UNLOADED;
572
573 spin_unlock_irqrestore(ap->lock, flags);
574}
575
Tejun Heoece1d632006-04-02 18:51:53 +0900576/**
577 * ata_scsi_error - SCSI layer error handler callback
578 * @host: SCSI host on which error occurred
579 *
580 * Handles SCSI-layer-thrown error events.
581 *
582 * LOCKING:
583 * Inherited from SCSI layer (none, can sleep)
584 *
585 * RETURNS:
586 * Zero.
587 */
Jeff Garzik381544b2006-04-11 13:04:39 -0400588void ata_scsi_error(struct Scsi_Host *host)
Tejun Heoece1d632006-04-02 18:51:53 +0900589{
Jeff Garzik35bb94b2006-04-11 13:12:34 -0400590 struct ata_port *ap = ata_shost_to_port(host);
Tejun Heoad9e2762006-05-15 20:58:12 +0900591 unsigned long flags;
James Bottomleyc34aeeb2011-01-23 08:31:14 -0600592 LIST_HEAD(eh_work_q);
Tejun Heoece1d632006-04-02 18:51:53 +0900593
594 DPRINTK("ENTER\n");
595
James Bottomleyc34aeeb2011-01-23 08:31:14 -0600596 spin_lock_irqsave(host->host_lock, flags);
597 list_splice_init(&host->eh_cmd_q, &eh_work_q);
598 spin_unlock_irqrestore(host->host_lock, flags);
599
James Bottomley0e0b494c2011-01-23 09:42:50 -0600600 ata_scsi_cmd_error_handler(host, ap, &eh_work_q);
601
602 /* If we timed raced normal completion and there is nothing to
603 recover nr_timedout == 0 why exactly are we doing error recovery ? */
604 ata_scsi_port_error_handler(host, ap);
605
606 /* finish or retry handled scmd's and clean up */
607 WARN_ON(host->host_failed || !list_empty(&eh_work_q));
608
609 DPRINTK("EXIT\n");
610}
611
612/**
613 * ata_scsi_cmd_error_handler - error callback for a list of commands
614 * @host: scsi host containing the port
615 * @ap: ATA port within the host
616 * @eh_work_q: list of commands to process
617 *
618 * process the given list of commands and return those finished to the
619 * ap->eh_done_q. This function is the first part of the libata error
620 * handler which processes a given list of failed commands.
621 */
622void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap,
623 struct list_head *eh_work_q)
624{
625 int i;
626 unsigned long flags;
627
Tejun Heoc4291372010-05-10 21:41:38 +0200628 /* make sure sff pio task is not running */
629 ata_sff_flush_pio_task(ap);
Tejun Heoece1d632006-04-02 18:51:53 +0900630
Jeff Garzikcca39742006-08-24 03:19:22 -0400631 /* synchronize with host lock and sort out timeouts */
Tejun Heoece1d632006-04-02 18:51:53 +0900632
Tejun Heoad9e2762006-05-15 20:58:12 +0900633 /* For new EH, all qcs are finished in one of three ways -
634 * normal completion, error completion, and SCSI timeout.
Alan Coxc96f1732009-03-24 10:23:46 +0000635 * Both completions can race against SCSI timeout. When normal
Tejun Heoad9e2762006-05-15 20:58:12 +0900636 * completion wins, the qc never reaches EH. When error
637 * completion wins, the qc has ATA_QCFLAG_FAILED set.
638 *
639 * When SCSI timeout wins, things are a bit more complex.
640 * Normal or error completion can occur after the timeout but
641 * before this point. In such cases, both types of
642 * completions are honored. A scmd is determined to have
643 * timed out iff its associated qc is active and not failed.
644 */
645 if (ap->ops->error_handler) {
646 struct scsi_cmnd *scmd, *tmp;
647 int nr_timedout = 0;
Tejun Heoece1d632006-04-02 18:51:53 +0900648
Tejun Heoe30349d2006-07-03 03:02:15 +0900649 spin_lock_irqsave(ap->lock, flags);
Gwendal Grignoud9027472010-05-25 12:31:38 -0700650
Alan Coxc96f1732009-03-24 10:23:46 +0000651 /* This must occur under the ap->lock as we don't want
652 a polled recovery to race the real interrupt handler
Gwendal Grignoud9027472010-05-25 12:31:38 -0700653
Alan Coxc96f1732009-03-24 10:23:46 +0000654 The lost_interrupt handler checks for any completed but
655 non-notified command and completes much like an IRQ handler.
Gwendal Grignoud9027472010-05-25 12:31:38 -0700656
Alan Coxc96f1732009-03-24 10:23:46 +0000657 We then fall into the error recovery code which will treat
658 this as if normal completion won the race */
Tejun Heoad9e2762006-05-15 20:58:12 +0900659
Alan Coxc96f1732009-03-24 10:23:46 +0000660 if (ap->ops->lost_interrupt)
661 ap->ops->lost_interrupt(ap);
Gwendal Grignoud9027472010-05-25 12:31:38 -0700662
James Bottomley0e0b494c2011-01-23 09:42:50 -0600663 list_for_each_entry_safe(scmd, tmp, eh_work_q, eh_entry) {
Tejun Heoad9e2762006-05-15 20:58:12 +0900664 struct ata_queued_cmd *qc;
665
666 for (i = 0; i < ATA_MAX_QUEUE; i++) {
667 qc = __ata_qc_from_tag(ap, i);
668 if (qc->flags & ATA_QCFLAG_ACTIVE &&
669 qc->scsicmd == scmd)
670 break;
671 }
672
673 if (i < ATA_MAX_QUEUE) {
674 /* the scmd has an associated qc */
675 if (!(qc->flags & ATA_QCFLAG_FAILED)) {
676 /* which hasn't failed yet, timeout */
677 qc->err_mask |= AC_ERR_TIMEOUT;
678 qc->flags |= ATA_QCFLAG_FAILED;
679 nr_timedout++;
680 }
681 } else {
682 /* Normal completion occurred after
683 * SCSI timeout but before this point.
684 * Successfully complete it.
685 */
686 scmd->retries = scmd->allowed;
687 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
688 }
689 }
690
691 /* If we have timed out qcs. They belong to EH from
692 * this point but the state of the controller is
693 * unknown. Freeze the port to make sure the IRQ
694 * handler doesn't diddle with those qcs. This must
695 * be done atomically w.r.t. setting QCFLAG_FAILED.
696 */
697 if (nr_timedout)
698 __ata_port_freeze(ap);
699
Tejun Heoe30349d2006-07-03 03:02:15 +0900700 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoa1e10f72007-08-18 13:28:49 +0900701
702 /* initialize eh_tries */
703 ap->eh_tries = ATA_EH_MAX_TRIES;
Tejun Heoad9e2762006-05-15 20:58:12 +0900704 } else
Tejun Heoe30349d2006-07-03 03:02:15 +0900705 spin_unlock_wait(ap->lock);
Gwendal Grignoud9027472010-05-25 12:31:38 -0700706
James Bottomley0e0b494c2011-01-23 09:42:50 -0600707}
708EXPORT_SYMBOL(ata_scsi_cmd_error_handler);
709
710/**
711 * ata_scsi_port_error_handler - recover the port after the commands
712 * @host: SCSI host containing the port
713 * @ap: the ATA port
714 *
715 * Handle the recovery of the port @ap after all the commands
716 * have been recovered.
717 */
718void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap)
719{
720 unsigned long flags;
Tejun Heoad9e2762006-05-15 20:58:12 +0900721
Tejun Heoad9e2762006-05-15 20:58:12 +0900722 /* invoke error handler */
723 if (ap->ops->error_handler) {
Tejun Heocf1b86c2007-08-06 18:36:23 +0900724 struct ata_link *link;
725
Tejun Heoc0c362b2010-09-06 17:57:14 +0200726 /* acquire EH ownership */
727 ata_eh_acquire(ap);
728 repeat:
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900729 /* kill fast drain timer */
730 del_timer_sync(&ap->fastdrain_timer);
731
Tejun Heo500530f2006-07-03 16:07:27 +0900732 /* process port resume request */
733 ata_eh_handle_port_resume(ap);
734
Tejun Heof3e81b12006-05-15 20:58:21 +0900735 /* fetch & clear EH info */
Tejun Heoe30349d2006-07-03 03:02:15 +0900736 spin_lock_irqsave(ap->lock, flags);
Tejun Heof3e81b12006-05-15 20:58:21 +0900737
Tejun Heo1eca4362008-11-03 20:03:17 +0900738 ata_for_each_link(link, ap, HOST_FIRST) {
Tejun Heo00115e02007-11-27 19:28:58 +0900739 struct ata_eh_context *ehc = &link->eh_context;
740 struct ata_device *dev;
741
Tejun Heocf1b86c2007-08-06 18:36:23 +0900742 memset(&link->eh_context, 0, sizeof(link->eh_context));
743 link->eh_context.i = link->eh_info;
744 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heo00115e02007-11-27 19:28:58 +0900745
Tejun Heo1eca4362008-11-03 20:03:17 +0900746 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo00115e02007-11-27 19:28:58 +0900747 int devno = dev->devno;
748
749 ehc->saved_xfer_mode[devno] = dev->xfer_mode;
750 if (ata_ncq_enabled(dev))
751 ehc->saved_ncq_enabled |= 1 << devno;
752 }
Tejun Heocf1b86c2007-08-06 18:36:23 +0900753 }
Tejun Heof3e81b12006-05-15 20:58:21 +0900754
Tejun Heob51e9e52006-06-29 01:29:30 +0900755 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
756 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heoda917d62007-09-23 13:14:12 +0900757 ap->excl_link = NULL; /* don't maintain exclusion over EH */
Tejun Heof3e81b12006-05-15 20:58:21 +0900758
Tejun Heoe30349d2006-07-03 03:02:15 +0900759 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900760
Tejun Heo500530f2006-07-03 16:07:27 +0900761 /* invoke EH, skip if unloading or suspended */
762 if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
Tejun Heo720ba122006-05-31 18:28:13 +0900763 ap->ops->error_handler(ap);
Tejun Heoece180d2008-11-03 20:04:37 +0900764 else {
765 /* if unloading, commence suicide */
766 if ((ap->pflags & ATA_PFLAG_UNLOADING) &&
767 !(ap->pflags & ATA_PFLAG_UNLOADED))
768 ata_eh_unload(ap);
Tejun Heo720ba122006-05-31 18:28:13 +0900769 ata_eh_finish(ap);
Tejun Heoece180d2008-11-03 20:04:37 +0900770 }
Tejun Heoad9e2762006-05-15 20:58:12 +0900771
Tejun Heo500530f2006-07-03 16:07:27 +0900772 /* process port suspend request */
773 ata_eh_handle_port_suspend(ap);
774
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300775 /* Exception might have happened after ->error_handler
Tejun Heoad9e2762006-05-15 20:58:12 +0900776 * recovered the port but before this point. Repeat
777 * EH in such case.
778 */
Tejun Heoe30349d2006-07-03 03:02:15 +0900779 spin_lock_irqsave(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900780
Tejun Heob51e9e52006-06-29 01:29:30 +0900781 if (ap->pflags & ATA_PFLAG_EH_PENDING) {
Tejun Heoa1e10f72007-08-18 13:28:49 +0900782 if (--ap->eh_tries) {
Tejun Heoe30349d2006-07-03 03:02:15 +0900783 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900784 goto repeat;
785 }
Joe Perchesa9a79df2011-04-15 15:51:59 -0700786 ata_port_err(ap,
787 "EH pending after %d tries, giving up\n",
788 ATA_EH_MAX_TRIES);
Tejun Heo914616a2007-06-25 21:47:11 +0900789 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heoad9e2762006-05-15 20:58:12 +0900790 }
791
Tejun Heof3e81b12006-05-15 20:58:21 +0900792 /* this run is complete, make sure EH info is clear */
Tejun Heo1eca4362008-11-03 20:03:17 +0900793 ata_for_each_link(link, ap, HOST_FIRST)
Tejun Heocf1b86c2007-08-06 18:36:23 +0900794 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heof3e81b12006-05-15 20:58:21 +0900795
Tejun Heoe30349d2006-07-03 03:02:15 +0900796 /* Clear host_eh_scheduled while holding ap->lock such
Tejun Heoad9e2762006-05-15 20:58:12 +0900797 * that if exception occurs after this point but
798 * before EH completion, SCSI midlayer will
799 * re-initiate EH.
800 */
801 host->host_eh_scheduled = 0;
802
Tejun Heoe30349d2006-07-03 03:02:15 +0900803 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoc0c362b2010-09-06 17:57:14 +0200804 ata_eh_release(ap);
Tejun Heoad9e2762006-05-15 20:58:12 +0900805 } else {
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900806 WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
Tejun Heoad9e2762006-05-15 20:58:12 +0900807 ap->ops->eng_timeout(ap);
808 }
809
Tejun Heoece1d632006-04-02 18:51:53 +0900810 scsi_eh_flush_done_q(&ap->eh_done_q);
811
Tejun Heoad9e2762006-05-15 20:58:12 +0900812 /* clean up */
Tejun Heoe30349d2006-07-03 03:02:15 +0900813 spin_lock_irqsave(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900814
Tejun Heo1cdaf532006-07-03 16:07:26 +0900815 if (ap->pflags & ATA_PFLAG_LOADING)
Tejun Heob51e9e52006-06-29 01:29:30 +0900816 ap->pflags &= ~ATA_PFLAG_LOADING;
Tejun Heo1cdaf532006-07-03 16:07:26 +0900817 else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
Tejun Heoad72cf92010-07-02 10:03:52 +0200818 schedule_delayed_work(&ap->hotplug_task, 0);
Tejun Heo1cdaf532006-07-03 16:07:26 +0900819
820 if (ap->pflags & ATA_PFLAG_RECOVERED)
Joe Perchesa9a79df2011-04-15 15:51:59 -0700821 ata_port_info(ap, "EH complete\n");
Tejun Heo580b2102006-05-31 18:28:05 +0900822
Tejun Heob51e9e52006-06-29 01:29:30 +0900823 ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
Tejun Heoad9e2762006-05-15 20:58:12 +0900824
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900825 /* tell wait_eh that we're done */
Tejun Heob51e9e52006-06-29 01:29:30 +0900826 ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900827 wake_up_all(&ap->eh_wait_q);
828
Tejun Heoe30349d2006-07-03 03:02:15 +0900829 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +0900830}
James Bottomley0e0b494c2011-01-23 09:42:50 -0600831EXPORT_SYMBOL_GPL(ata_scsi_port_error_handler);
Tejun Heoece1d632006-04-02 18:51:53 +0900832
833/**
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900834 * ata_port_wait_eh - Wait for the currently pending EH to complete
835 * @ap: Port to wait EH for
836 *
837 * Wait until the currently pending EH is complete.
838 *
839 * LOCKING:
840 * Kernel thread context (may sleep).
841 */
842void ata_port_wait_eh(struct ata_port *ap)
843{
844 unsigned long flags;
845 DEFINE_WAIT(wait);
846
847 retry:
Jeff Garzikba6a1302006-06-22 23:46:10 -0400848 spin_lock_irqsave(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900849
Tejun Heob51e9e52006-06-29 01:29:30 +0900850 while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900851 prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
Jeff Garzikba6a1302006-06-22 23:46:10 -0400852 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900853 schedule();
Jeff Garzikba6a1302006-06-22 23:46:10 -0400854 spin_lock_irqsave(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900855 }
Tejun Heo0a1b6222006-06-11 11:01:38 +0900856 finish_wait(&ap->eh_wait_q, &wait);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900857
Jeff Garzikba6a1302006-06-22 23:46:10 -0400858 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900859
860 /* make sure SCSI EH is complete */
Jeff Garzikcca39742006-08-24 03:19:22 -0400861 if (scsi_host_in_recovery(ap->scsi_host)) {
Tejun Heo97750ce2010-09-06 17:56:29 +0200862 ata_msleep(ap, 10);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900863 goto retry;
864 }
865}
866
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900867static int ata_eh_nr_in_flight(struct ata_port *ap)
868{
869 unsigned int tag;
870 int nr = 0;
871
872 /* count only non-internal commands */
873 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
874 if (ata_qc_from_tag(ap, tag))
875 nr++;
876
877 return nr;
878}
879
880void ata_eh_fastdrain_timerfn(unsigned long arg)
881{
882 struct ata_port *ap = (void *)arg;
883 unsigned long flags;
884 int cnt;
885
886 spin_lock_irqsave(ap->lock, flags);
887
888 cnt = ata_eh_nr_in_flight(ap);
889
890 /* are we done? */
891 if (!cnt)
892 goto out_unlock;
893
894 if (cnt == ap->fastdrain_cnt) {
895 unsigned int tag;
896
897 /* No progress during the last interval, tag all
898 * in-flight qcs as timed out and freeze the port.
899 */
900 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
901 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
902 if (qc)
903 qc->err_mask |= AC_ERR_TIMEOUT;
904 }
905
906 ata_port_freeze(ap);
907 } else {
908 /* some qcs have finished, give it another chance */
909 ap->fastdrain_cnt = cnt;
910 ap->fastdrain_timer.expires =
Tejun Heo341c2c92008-05-20 02:17:51 +0900911 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900912 add_timer(&ap->fastdrain_timer);
913 }
914
915 out_unlock:
916 spin_unlock_irqrestore(ap->lock, flags);
917}
918
919/**
920 * ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
921 * @ap: target ATA port
922 * @fastdrain: activate fast drain
923 *
924 * Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
925 * is non-zero and EH wasn't pending before. Fast drain ensures
926 * that EH kicks in in timely manner.
927 *
928 * LOCKING:
929 * spin_lock_irqsave(host lock)
930 */
931static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
932{
933 int cnt;
934
935 /* already scheduled? */
936 if (ap->pflags & ATA_PFLAG_EH_PENDING)
937 return;
938
939 ap->pflags |= ATA_PFLAG_EH_PENDING;
940
941 if (!fastdrain)
942 return;
943
944 /* do we have in-flight qcs? */
945 cnt = ata_eh_nr_in_flight(ap);
946 if (!cnt)
947 return;
948
949 /* activate fast drain */
950 ap->fastdrain_cnt = cnt;
Tejun Heo341c2c92008-05-20 02:17:51 +0900951 ap->fastdrain_timer.expires =
952 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900953 add_timer(&ap->fastdrain_timer);
954}
955
Tejun Heof686bcb2006-05-15 20:58:05 +0900956/**
957 * ata_qc_schedule_eh - schedule qc for error handling
958 * @qc: command to schedule error handling for
959 *
960 * Schedule error handling for @qc. EH will kick in as soon as
961 * other commands are drained.
962 *
963 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400964 * spin_lock_irqsave(host lock)
Tejun Heof686bcb2006-05-15 20:58:05 +0900965 */
966void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
967{
968 struct ata_port *ap = qc->ap;
Tejun Heofa41efd2010-04-15 08:57:37 +0900969 struct request_queue *q = qc->scsicmd->device->request_queue;
970 unsigned long flags;
Tejun Heof686bcb2006-05-15 20:58:05 +0900971
972 WARN_ON(!ap->ops->error_handler);
973
974 qc->flags |= ATA_QCFLAG_FAILED;
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900975 ata_eh_set_pending(ap, 1);
Tejun Heof686bcb2006-05-15 20:58:05 +0900976
977 /* The following will fail if timeout has already expired.
978 * ata_scsi_error() takes care of such scmds on EH entry.
979 * Note that ATA_QCFLAG_FAILED is unconditionally set after
980 * this function completes.
981 */
Tejun Heofa41efd2010-04-15 08:57:37 +0900982 spin_lock_irqsave(q->queue_lock, flags);
Jens Axboe242f9dc2008-09-14 05:55:09 -0700983 blk_abort_request(qc->scsicmd->request);
Tejun Heofa41efd2010-04-15 08:57:37 +0900984 spin_unlock_irqrestore(q->queue_lock, flags);
Tejun Heof686bcb2006-05-15 20:58:05 +0900985}
986
Tejun Heo7b70fc02006-05-15 20:58:07 +0900987/**
988 * ata_port_schedule_eh - schedule error handling without a qc
989 * @ap: ATA port to schedule EH for
990 *
991 * Schedule error handling for @ap. EH will kick in as soon as
992 * all commands are drained.
993 *
994 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400995 * spin_lock_irqsave(host lock)
Tejun Heo7b70fc02006-05-15 20:58:07 +0900996 */
997void ata_port_schedule_eh(struct ata_port *ap)
998{
999 WARN_ON(!ap->ops->error_handler);
1000
Tejun Heof4d6d002007-05-01 11:50:15 +02001001 if (ap->pflags & ATA_PFLAG_INITIALIZING)
1002 return;
1003
Tejun Heo5ddf24c2007-07-16 14:29:41 +09001004 ata_eh_set_pending(ap, 1);
Jeff Garzikcca39742006-08-24 03:19:22 -04001005 scsi_schedule_eh(ap->scsi_host);
Tejun Heo7b70fc02006-05-15 20:58:07 +09001006
1007 DPRINTK("port EH scheduled\n");
1008}
1009
Tejun Heodbd82612007-08-06 18:36:23 +09001010static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
Tejun Heo7b70fc02006-05-15 20:58:07 +09001011{
1012 int tag, nr_aborted = 0;
1013
1014 WARN_ON(!ap->ops->error_handler);
1015
Tejun Heo5ddf24c2007-07-16 14:29:41 +09001016 /* we're gonna abort all commands, no need for fast drain */
1017 ata_eh_set_pending(ap, 0);
1018
Tejun Heo7b70fc02006-05-15 20:58:07 +09001019 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1020 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
1021
Tejun Heodbd82612007-08-06 18:36:23 +09001022 if (qc && (!link || qc->dev->link == link)) {
Tejun Heo7b70fc02006-05-15 20:58:07 +09001023 qc->flags |= ATA_QCFLAG_FAILED;
1024 ata_qc_complete(qc);
1025 nr_aborted++;
1026 }
1027 }
1028
1029 if (!nr_aborted)
1030 ata_port_schedule_eh(ap);
1031
1032 return nr_aborted;
1033}
1034
Tejun Heoe3180492006-05-15 20:58:09 +09001035/**
Tejun Heodbd82612007-08-06 18:36:23 +09001036 * ata_link_abort - abort all qc's on the link
1037 * @link: ATA link to abort qc's for
1038 *
1039 * Abort all active qc's active on @link and schedule EH.
1040 *
1041 * LOCKING:
1042 * spin_lock_irqsave(host lock)
1043 *
1044 * RETURNS:
1045 * Number of aborted qc's.
1046 */
1047int ata_link_abort(struct ata_link *link)
1048{
1049 return ata_do_link_abort(link->ap, link);
1050}
1051
1052/**
1053 * ata_port_abort - abort all qc's on the port
1054 * @ap: ATA port to abort qc's for
1055 *
1056 * Abort all active qc's of @ap and schedule EH.
1057 *
1058 * LOCKING:
1059 * spin_lock_irqsave(host_set lock)
1060 *
1061 * RETURNS:
1062 * Number of aborted qc's.
1063 */
1064int ata_port_abort(struct ata_port *ap)
1065{
1066 return ata_do_link_abort(ap, NULL);
1067}
1068
1069/**
Tejun Heoe3180492006-05-15 20:58:09 +09001070 * __ata_port_freeze - freeze port
1071 * @ap: ATA port to freeze
1072 *
1073 * This function is called when HSM violation or some other
1074 * condition disrupts normal operation of the port. Frozen port
1075 * is not allowed to perform any operation until the port is
1076 * thawed, which usually follows a successful reset.
1077 *
1078 * ap->ops->freeze() callback can be used for freezing the port
1079 * hardware-wise (e.g. mask interrupt and stop DMA engine). If a
1080 * port cannot be frozen hardware-wise, the interrupt handler
1081 * must ack and clear interrupts unconditionally while the port
1082 * is frozen.
1083 *
1084 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001085 * spin_lock_irqsave(host lock)
Tejun Heoe3180492006-05-15 20:58:09 +09001086 */
1087static void __ata_port_freeze(struct ata_port *ap)
1088{
1089 WARN_ON(!ap->ops->error_handler);
1090
1091 if (ap->ops->freeze)
1092 ap->ops->freeze(ap);
1093
Tejun Heob51e9e52006-06-29 01:29:30 +09001094 ap->pflags |= ATA_PFLAG_FROZEN;
Tejun Heoe3180492006-05-15 20:58:09 +09001095
Tejun Heo44877b42007-02-21 01:06:51 +09001096 DPRINTK("ata%u port frozen\n", ap->print_id);
Tejun Heoe3180492006-05-15 20:58:09 +09001097}
1098
1099/**
1100 * ata_port_freeze - abort & freeze port
1101 * @ap: ATA port to freeze
1102 *
Jeff Garzik54c38442009-04-07 19:13:15 -04001103 * Abort and freeze @ap. The freeze operation must be called
1104 * first, because some hardware requires special operations
1105 * before the taskfile registers are accessible.
Tejun Heoe3180492006-05-15 20:58:09 +09001106 *
1107 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001108 * spin_lock_irqsave(host lock)
Tejun Heoe3180492006-05-15 20:58:09 +09001109 *
1110 * RETURNS:
1111 * Number of aborted commands.
1112 */
1113int ata_port_freeze(struct ata_port *ap)
1114{
1115 int nr_aborted;
1116
1117 WARN_ON(!ap->ops->error_handler);
1118
Tejun Heoe3180492006-05-15 20:58:09 +09001119 __ata_port_freeze(ap);
Jeff Garzik54c38442009-04-07 19:13:15 -04001120 nr_aborted = ata_port_abort(ap);
Tejun Heoe3180492006-05-15 20:58:09 +09001121
1122 return nr_aborted;
1123}
1124
1125/**
Tejun Heo7d77b242007-09-23 13:14:13 +09001126 * sata_async_notification - SATA async notification handler
1127 * @ap: ATA port where async notification is received
1128 *
1129 * Handler to be called when async notification via SDB FIS is
1130 * received. This function schedules EH if necessary.
1131 *
1132 * LOCKING:
1133 * spin_lock_irqsave(host lock)
1134 *
1135 * RETURNS:
1136 * 1 if EH is scheduled, 0 otherwise.
1137 */
1138int sata_async_notification(struct ata_port *ap)
1139{
1140 u32 sntf;
1141 int rc;
1142
1143 if (!(ap->flags & ATA_FLAG_AN))
1144 return 0;
1145
1146 rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1147 if (rc == 0)
1148 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1149
Tejun Heo071f44b2008-04-07 22:47:22 +09001150 if (!sata_pmp_attached(ap) || rc) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001151 /* PMP is not attached or SNTF is not available */
Tejun Heo071f44b2008-04-07 22:47:22 +09001152 if (!sata_pmp_attached(ap)) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001153 /* PMP is not attached. Check whether ATAPI
1154 * AN is configured. If so, notify media
1155 * change.
1156 */
1157 struct ata_device *dev = ap->link.device;
1158
1159 if ((dev->class == ATA_DEV_ATAPI) &&
1160 (dev->flags & ATA_DFLAG_AN))
1161 ata_scsi_media_change_notify(dev);
1162 return 0;
1163 } else {
1164 /* PMP is attached but SNTF is not available.
1165 * ATAPI async media change notification is
1166 * not used. The PMP must be reporting PHY
1167 * status change, schedule EH.
1168 */
1169 ata_port_schedule_eh(ap);
1170 return 1;
1171 }
1172 } else {
1173 /* PMP is attached and SNTF is available */
1174 struct ata_link *link;
1175
1176 /* check and notify ATAPI AN */
Tejun Heo1eca4362008-11-03 20:03:17 +09001177 ata_for_each_link(link, ap, EDGE) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001178 if (!(sntf & (1 << link->pmp)))
1179 continue;
1180
1181 if ((link->device->class == ATA_DEV_ATAPI) &&
1182 (link->device->flags & ATA_DFLAG_AN))
1183 ata_scsi_media_change_notify(link->device);
1184 }
1185
1186 /* If PMP is reporting that PHY status of some
1187 * downstream ports has changed, schedule EH.
1188 */
1189 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
1190 ata_port_schedule_eh(ap);
1191 return 1;
1192 }
1193
1194 return 0;
1195 }
1196}
1197
1198/**
Tejun Heoe3180492006-05-15 20:58:09 +09001199 * ata_eh_freeze_port - EH helper to freeze port
1200 * @ap: ATA port to freeze
1201 *
1202 * Freeze @ap.
1203 *
1204 * LOCKING:
1205 * None.
1206 */
1207void ata_eh_freeze_port(struct ata_port *ap)
1208{
1209 unsigned long flags;
1210
1211 if (!ap->ops->error_handler)
1212 return;
1213
Jeff Garzikba6a1302006-06-22 23:46:10 -04001214 spin_lock_irqsave(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001215 __ata_port_freeze(ap);
Jeff Garzikba6a1302006-06-22 23:46:10 -04001216 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001217}
1218
1219/**
1220 * ata_port_thaw_port - EH helper to thaw port
1221 * @ap: ATA port to thaw
1222 *
1223 * Thaw frozen port @ap.
1224 *
1225 * LOCKING:
1226 * None.
1227 */
1228void ata_eh_thaw_port(struct ata_port *ap)
1229{
1230 unsigned long flags;
1231
1232 if (!ap->ops->error_handler)
1233 return;
1234
Jeff Garzikba6a1302006-06-22 23:46:10 -04001235 spin_lock_irqsave(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001236
Tejun Heob51e9e52006-06-29 01:29:30 +09001237 ap->pflags &= ~ATA_PFLAG_FROZEN;
Tejun Heoe3180492006-05-15 20:58:09 +09001238
1239 if (ap->ops->thaw)
1240 ap->ops->thaw(ap);
1241
Jeff Garzikba6a1302006-06-22 23:46:10 -04001242 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001243
Tejun Heo44877b42007-02-21 01:06:51 +09001244 DPRINTK("ata%u port thawed\n", ap->print_id);
Tejun Heoe3180492006-05-15 20:58:09 +09001245}
1246
Tejun Heoece1d632006-04-02 18:51:53 +09001247static void ata_eh_scsidone(struct scsi_cmnd *scmd)
1248{
1249 /* nada */
1250}
1251
1252static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
1253{
1254 struct ata_port *ap = qc->ap;
1255 struct scsi_cmnd *scmd = qc->scsicmd;
1256 unsigned long flags;
1257
Jeff Garzikba6a1302006-06-22 23:46:10 -04001258 spin_lock_irqsave(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +09001259 qc->scsidone = ata_eh_scsidone;
1260 __ata_qc_complete(qc);
1261 WARN_ON(ata_tag_valid(qc->tag));
Jeff Garzikba6a1302006-06-22 23:46:10 -04001262 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +09001263
1264 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
1265}
1266
1267/**
1268 * ata_eh_qc_complete - Complete an active ATA command from EH
1269 * @qc: Command to complete
1270 *
1271 * Indicate to the mid and upper layers that an ATA command has
1272 * completed. To be used from EH.
1273 */
1274void ata_eh_qc_complete(struct ata_queued_cmd *qc)
1275{
1276 struct scsi_cmnd *scmd = qc->scsicmd;
1277 scmd->retries = scmd->allowed;
1278 __ata_eh_qc_complete(qc);
1279}
1280
1281/**
1282 * ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
1283 * @qc: Command to retry
1284 *
1285 * Indicate to the mid and upper layers that an ATA command
1286 * should be retried. To be used from EH.
1287 *
1288 * SCSI midlayer limits the number of retries to scmd->allowed.
1289 * scmd->retries is decremented for commands which get retried
1290 * due to unrelated failures (qc->err_mask is zero).
1291 */
1292void ata_eh_qc_retry(struct ata_queued_cmd *qc)
1293{
1294 struct scsi_cmnd *scmd = qc->scsicmd;
1295 if (!qc->err_mask && scmd->retries)
1296 scmd->retries--;
1297 __ata_eh_qc_complete(qc);
1298}
Tejun Heo022bdb02006-05-15 20:58:22 +09001299
1300/**
Tejun Heo678afac2009-01-29 20:31:30 +09001301 * ata_dev_disable - disable ATA device
1302 * @dev: ATA device to disable
1303 *
1304 * Disable @dev.
1305 *
1306 * Locking:
1307 * EH context.
1308 */
1309void ata_dev_disable(struct ata_device *dev)
1310{
1311 if (!ata_dev_enabled(dev))
1312 return;
1313
1314 if (ata_msg_drv(dev->link->ap))
Joe Perchesa9a79df2011-04-15 15:51:59 -07001315 ata_dev_warn(dev, "disabled\n");
Tejun Heo678afac2009-01-29 20:31:30 +09001316 ata_acpi_on_disable(dev);
1317 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET);
1318 dev->class++;
Tejun Heo99cf6102009-01-29 20:31:32 +09001319
1320 /* From now till the next successful probe, ering is used to
1321 * track probe failures. Clear accumulated device error info.
1322 */
1323 ata_ering_clear(&dev->ering);
Tejun Heo678afac2009-01-29 20:31:30 +09001324}
1325
1326/**
Tejun Heo0ea035a2006-05-31 18:28:01 +09001327 * ata_eh_detach_dev - detach ATA device
1328 * @dev: ATA device to detach
1329 *
1330 * Detach @dev.
1331 *
1332 * LOCKING:
1333 * None.
1334 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001335void ata_eh_detach_dev(struct ata_device *dev)
Tejun Heo0ea035a2006-05-31 18:28:01 +09001336{
Tejun Heof58229f2007-08-06 18:36:23 +09001337 struct ata_link *link = dev->link;
1338 struct ata_port *ap = link->ap;
Tejun Heo90484eb2008-10-26 15:43:03 +09001339 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo0ea035a2006-05-31 18:28:01 +09001340 unsigned long flags;
1341
1342 ata_dev_disable(dev);
1343
Jeff Garzikba6a1302006-06-22 23:46:10 -04001344 spin_lock_irqsave(ap->lock, flags);
Tejun Heo0ea035a2006-05-31 18:28:01 +09001345
1346 dev->flags &= ~ATA_DFLAG_DETACH;
1347
1348 if (ata_scsi_offline_dev(dev)) {
1349 dev->flags |= ATA_DFLAG_DETACHED;
Tejun Heob51e9e52006-06-29 01:29:30 +09001350 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
Tejun Heo0ea035a2006-05-31 18:28:01 +09001351 }
1352
Tejun Heo90484eb2008-10-26 15:43:03 +09001353 /* clear per-dev EH info */
Tejun Heof58229f2007-08-06 18:36:23 +09001354 ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
1355 ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
Tejun Heo90484eb2008-10-26 15:43:03 +09001356 ehc->saved_xfer_mode[dev->devno] = 0;
1357 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
Tejun Heobeb07c12006-06-24 20:30:19 +09001358
Jeff Garzikba6a1302006-06-22 23:46:10 -04001359 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo0ea035a2006-05-31 18:28:01 +09001360}
1361
1362/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001363 * ata_eh_about_to_do - about to perform eh_action
Tejun Heo955e57d2007-08-06 18:36:23 +09001364 * @link: target ATA link
Tejun Heo47005f22006-06-19 18:27:23 +09001365 * @dev: target ATA dev for per-dev action (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09001366 * @action: action about to be performed
1367 *
1368 * Called just before performing EH actions to clear related bits
Tejun Heo955e57d2007-08-06 18:36:23 +09001369 * in @link->eh_info such that eh actions are not unnecessarily
1370 * repeated.
Tejun Heo022bdb02006-05-15 20:58:22 +09001371 *
1372 * LOCKING:
1373 * None.
1374 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001375void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
1376 unsigned int action)
Tejun Heo022bdb02006-05-15 20:58:22 +09001377{
Tejun Heo955e57d2007-08-06 18:36:23 +09001378 struct ata_port *ap = link->ap;
1379 struct ata_eh_info *ehi = &link->eh_info;
1380 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09001381 unsigned long flags;
1382
Jeff Garzikba6a1302006-06-22 23:46:10 -04001383 spin_lock_irqsave(ap->lock, flags);
Tejun Heo1cdaf532006-07-03 16:07:26 +09001384
Tejun Heo955e57d2007-08-06 18:36:23 +09001385 ata_eh_clear_action(link, dev, ehi, action);
Tejun Heo13abf502006-07-10 23:18:46 +09001386
Tejun Heoa568d1d2008-10-21 20:37:21 +09001387 /* About to take EH action, set RECOVERED. Ignore actions on
1388 * slave links as master will do them again.
1389 */
1390 if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link)
Tejun Heo1cdaf532006-07-03 16:07:26 +09001391 ap->pflags |= ATA_PFLAG_RECOVERED;
1392
Jeff Garzikba6a1302006-06-22 23:46:10 -04001393 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo022bdb02006-05-15 20:58:22 +09001394}
1395
1396/**
Tejun Heo47005f22006-06-19 18:27:23 +09001397 * ata_eh_done - EH action complete
Tejun Heo955e57d2007-08-06 18:36:23 +09001398* @ap: target ATA port
Tejun Heo47005f22006-06-19 18:27:23 +09001399 * @dev: target ATA dev for per-dev action (can be NULL)
1400 * @action: action just completed
1401 *
1402 * Called right after performing EH actions to clear related bits
Tejun Heo955e57d2007-08-06 18:36:23 +09001403 * in @link->eh_context.
Tejun Heo47005f22006-06-19 18:27:23 +09001404 *
1405 * LOCKING:
1406 * None.
1407 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001408void ata_eh_done(struct ata_link *link, struct ata_device *dev,
1409 unsigned int action)
Tejun Heo47005f22006-06-19 18:27:23 +09001410{
Tejun Heo955e57d2007-08-06 18:36:23 +09001411 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001412
Tejun Heo955e57d2007-08-06 18:36:23 +09001413 ata_eh_clear_action(link, dev, &ehc->i, action);
Tejun Heo47005f22006-06-19 18:27:23 +09001414}
1415
1416/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001417 * ata_err_string - convert err_mask to descriptive string
1418 * @err_mask: error mask to convert to string
1419 *
1420 * Convert @err_mask to descriptive string. Errors are
1421 * prioritized according to severity and only the most severe
1422 * error is reported.
1423 *
1424 * LOCKING:
1425 * None.
1426 *
1427 * RETURNS:
1428 * Descriptive string for @err_mask
1429 */
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001430static const char *ata_err_string(unsigned int err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09001431{
1432 if (err_mask & AC_ERR_HOST_BUS)
1433 return "host bus error";
1434 if (err_mask & AC_ERR_ATA_BUS)
1435 return "ATA bus error";
1436 if (err_mask & AC_ERR_TIMEOUT)
1437 return "timeout";
1438 if (err_mask & AC_ERR_HSM)
1439 return "HSM violation";
1440 if (err_mask & AC_ERR_SYSTEM)
1441 return "internal error";
1442 if (err_mask & AC_ERR_MEDIA)
1443 return "media error";
1444 if (err_mask & AC_ERR_INVALID)
1445 return "invalid argument";
1446 if (err_mask & AC_ERR_DEV)
1447 return "device error";
1448 return "unknown error";
1449}
1450
1451/**
Tejun Heoe8ee8452006-05-15 21:03:46 +09001452 * ata_read_log_page - read a specific log page
1453 * @dev: target device
1454 * @page: page to read
1455 * @buf: buffer to store read page
1456 * @sectors: number of sectors to read
1457 *
1458 * Read log page using READ_LOG_EXT command.
1459 *
1460 * LOCKING:
1461 * Kernel thread context (may sleep).
1462 *
1463 * RETURNS:
1464 * 0 on success, AC_ERR_* mask otherwise.
1465 */
1466static unsigned int ata_read_log_page(struct ata_device *dev,
1467 u8 page, void *buf, unsigned int sectors)
1468{
1469 struct ata_taskfile tf;
1470 unsigned int err_mask;
1471
1472 DPRINTK("read log page - page %d\n", page);
1473
1474 ata_tf_init(dev, &tf);
1475 tf.command = ATA_CMD_READ_LOG_EXT;
1476 tf.lbal = page;
1477 tf.nsect = sectors;
1478 tf.hob_nsect = sectors >> 8;
1479 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
1480 tf.protocol = ATA_PROT_PIO;
1481
1482 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
Tejun Heo2b789102007-10-09 15:05:44 +09001483 buf, sectors * ATA_SECT_SIZE, 0);
Tejun Heoe8ee8452006-05-15 21:03:46 +09001484
1485 DPRINTK("EXIT, err_mask=%x\n", err_mask);
1486 return err_mask;
1487}
1488
1489/**
1490 * ata_eh_read_log_10h - Read log page 10h for NCQ error details
1491 * @dev: Device to read log page 10h from
1492 * @tag: Resulting tag of the failed command
1493 * @tf: Resulting taskfile registers of the failed command
1494 *
1495 * Read log page 10h to obtain NCQ error details and clear error
1496 * condition.
1497 *
1498 * LOCKING:
1499 * Kernel thread context (may sleep).
1500 *
1501 * RETURNS:
1502 * 0 on success, -errno otherwise.
1503 */
1504static int ata_eh_read_log_10h(struct ata_device *dev,
1505 int *tag, struct ata_taskfile *tf)
1506{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001507 u8 *buf = dev->link->ap->sector_buf;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001508 unsigned int err_mask;
1509 u8 csum;
1510 int i;
1511
1512 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1);
1513 if (err_mask)
1514 return -EIO;
1515
1516 csum = 0;
1517 for (i = 0; i < ATA_SECT_SIZE; i++)
1518 csum += buf[i];
1519 if (csum)
Joe Perchesa9a79df2011-04-15 15:51:59 -07001520 ata_dev_warn(dev, "invalid checksum 0x%x on log page 10h\n",
1521 csum);
Tejun Heoe8ee8452006-05-15 21:03:46 +09001522
1523 if (buf[0] & 0x80)
1524 return -ENOENT;
1525
1526 *tag = buf[0] & 0x1f;
1527
1528 tf->command = buf[2];
1529 tf->feature = buf[3];
1530 tf->lbal = buf[4];
1531 tf->lbam = buf[5];
1532 tf->lbah = buf[6];
1533 tf->device = buf[7];
1534 tf->hob_lbal = buf[8];
1535 tf->hob_lbam = buf[9];
1536 tf->hob_lbah = buf[10];
1537 tf->nsect = buf[12];
1538 tf->hob_nsect = buf[13];
1539
1540 return 0;
1541}
1542
1543/**
Tejun Heo11fc33d2008-08-30 14:20:01 +02001544 * atapi_eh_tur - perform ATAPI TEST_UNIT_READY
1545 * @dev: target ATAPI device
1546 * @r_sense_key: out parameter for sense_key
1547 *
1548 * Perform ATAPI TEST_UNIT_READY.
1549 *
1550 * LOCKING:
1551 * EH context (may sleep).
1552 *
1553 * RETURNS:
1554 * 0 on success, AC_ERR_* mask on failure.
1555 */
1556static unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
1557{
1558 u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 };
1559 struct ata_taskfile tf;
1560 unsigned int err_mask;
1561
1562 ata_tf_init(dev, &tf);
1563
1564 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1565 tf.command = ATA_CMD_PACKET;
1566 tf.protocol = ATAPI_PROT_NODATA;
1567
1568 err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
1569 if (err_mask == AC_ERR_DEV)
1570 *r_sense_key = tf.feature >> 4;
1571 return err_mask;
1572}
1573
1574/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001575 * atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
1576 * @dev: device to perform REQUEST_SENSE to
1577 * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
Tejun Heo3eabddb2008-06-10 18:28:05 +09001578 * @dfl_sense_key: default sense key to use
Tejun Heo022bdb02006-05-15 20:58:22 +09001579 *
1580 * Perform ATAPI REQUEST_SENSE after the device reported CHECK
1581 * SENSE. This function is EH helper.
1582 *
1583 * LOCKING:
1584 * Kernel thread context (may sleep).
1585 *
1586 * RETURNS:
1587 * 0 on success, AC_ERR_* mask on failure
1588 */
Tejun Heo3eabddb2008-06-10 18:28:05 +09001589static unsigned int atapi_eh_request_sense(struct ata_device *dev,
1590 u8 *sense_buf, u8 dfl_sense_key)
Tejun Heo022bdb02006-05-15 20:58:22 +09001591{
Tejun Heo3eabddb2008-06-10 18:28:05 +09001592 u8 cdb[ATAPI_CDB_LEN] =
1593 { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 };
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001594 struct ata_port *ap = dev->link->ap;
Tejun Heo022bdb02006-05-15 20:58:22 +09001595 struct ata_taskfile tf;
Tejun Heo022bdb02006-05-15 20:58:22 +09001596
1597 DPRINTK("ATAPI request sense\n");
1598
Tejun Heo022bdb02006-05-15 20:58:22 +09001599 /* FIXME: is this needed? */
1600 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
1601
Albert Lee56287762007-04-02 11:30:46 +08001602 /* initialize sense_buf with the error register,
1603 * for the case where they are -not- overwritten
1604 */
Tejun Heo022bdb02006-05-15 20:58:22 +09001605 sense_buf[0] = 0x70;
Tejun Heo3eabddb2008-06-10 18:28:05 +09001606 sense_buf[2] = dfl_sense_key;
Albert Lee56287762007-04-02 11:30:46 +08001607
Jeff Garzika617c092007-05-21 20:14:23 -04001608 /* some devices time out if garbage left in tf */
Albert Lee56287762007-04-02 11:30:46 +08001609 ata_tf_init(dev, &tf);
Tejun Heo022bdb02006-05-15 20:58:22 +09001610
Tejun Heo022bdb02006-05-15 20:58:22 +09001611 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1612 tf.command = ATA_CMD_PACKET;
1613
1614 /* is it pointless to prefer PIO for "safety reasons"? */
1615 if (ap->flags & ATA_FLAG_PIO_DMA) {
Tejun Heo0dc36882007-12-18 16:34:43 -05001616 tf.protocol = ATAPI_PROT_DMA;
Tejun Heo022bdb02006-05-15 20:58:22 +09001617 tf.feature |= ATAPI_PKT_DMA;
1618 } else {
Tejun Heo0dc36882007-12-18 16:34:43 -05001619 tf.protocol = ATAPI_PROT_PIO;
Tejun Heof2dfc1a2007-12-12 12:12:46 +09001620 tf.lbam = SCSI_SENSE_BUFFERSIZE;
1621 tf.lbah = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09001622 }
1623
1624 return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
Tejun Heo2b789102007-10-09 15:05:44 +09001625 sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
Tejun Heo022bdb02006-05-15 20:58:22 +09001626}
1627
1628/**
1629 * ata_eh_analyze_serror - analyze SError for a failed port
Tejun Heo02607312007-08-06 18:36:23 +09001630 * @link: ATA link to analyze SError for
Tejun Heo022bdb02006-05-15 20:58:22 +09001631 *
1632 * Analyze SError if available and further determine cause of
1633 * failure.
1634 *
1635 * LOCKING:
1636 * None.
1637 */
Tejun Heo02607312007-08-06 18:36:23 +09001638static void ata_eh_analyze_serror(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09001639{
Tejun Heo02607312007-08-06 18:36:23 +09001640 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09001641 u32 serror = ehc->i.serror;
1642 unsigned int err_mask = 0, action = 0;
Tejun Heof9df58c2007-09-23 13:14:13 +09001643 u32 hotplug_mask;
Tejun Heo022bdb02006-05-15 20:58:22 +09001644
Tejun Heoe0614db2008-05-19 01:15:09 +09001645 if (serror & (SERR_PERSISTENT | SERR_DATA)) {
Tejun Heo022bdb02006-05-15 20:58:22 +09001646 err_mask |= AC_ERR_ATA_BUS;
Tejun Heocf480622008-01-24 00:05:14 +09001647 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001648 }
1649 if (serror & SERR_PROTOCOL) {
1650 err_mask |= AC_ERR_HSM;
Tejun Heocf480622008-01-24 00:05:14 +09001651 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001652 }
1653 if (serror & SERR_INTERNAL) {
1654 err_mask |= AC_ERR_SYSTEM;
Tejun Heocf480622008-01-24 00:05:14 +09001655 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001656 }
Tejun Heof9df58c2007-09-23 13:14:13 +09001657
1658 /* Determine whether a hotplug event has occurred. Both
1659 * SError.N/X are considered hotplug events for enabled or
1660 * host links. For disabled PMP links, only N bit is
1661 * considered as X bit is left at 1 for link plugging.
1662 */
Tejun Heoeb0e85e2011-02-24 19:30:37 +01001663 if (link->lpm_policy > ATA_LPM_MAX_POWER)
Tejun Heo6b7ae952010-09-01 17:50:06 +02001664 hotplug_mask = 0; /* hotplug doesn't work w/ LPM */
1665 else if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
Tejun Heof9df58c2007-09-23 13:14:13 +09001666 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
1667 else
1668 hotplug_mask = SERR_PHYRDY_CHG;
1669
1670 if (serror & hotplug_mask)
Tejun Heo084fe632006-05-31 18:28:03 +09001671 ata_ehi_hotplugged(&ehc->i);
Tejun Heo022bdb02006-05-15 20:58:22 +09001672
1673 ehc->i.err_mask |= err_mask;
1674 ehc->i.action |= action;
1675}
1676
1677/**
Tejun Heoe8ee8452006-05-15 21:03:46 +09001678 * ata_eh_analyze_ncq_error - analyze NCQ error
Tejun Heo02607312007-08-06 18:36:23 +09001679 * @link: ATA link to analyze NCQ error for
Tejun Heoe8ee8452006-05-15 21:03:46 +09001680 *
1681 * Read log page 10h, determine the offending qc and acquire
1682 * error status TF. For NCQ device errors, all LLDDs have to do
1683 * is setting AC_ERR_DEV in ehi->err_mask. This function takes
1684 * care of the rest.
1685 *
1686 * LOCKING:
1687 * Kernel thread context (may sleep).
1688 */
Mark Lord10acf3b2008-05-02 02:14:53 -04001689void ata_eh_analyze_ncq_error(struct ata_link *link)
Tejun Heoe8ee8452006-05-15 21:03:46 +09001690{
Tejun Heo02607312007-08-06 18:36:23 +09001691 struct ata_port *ap = link->ap;
1692 struct ata_eh_context *ehc = &link->eh_context;
1693 struct ata_device *dev = link->device;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001694 struct ata_queued_cmd *qc;
1695 struct ata_taskfile tf;
1696 int tag, rc;
1697
1698 /* if frozen, we can't do much */
Tejun Heob51e9e52006-06-29 01:29:30 +09001699 if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heoe8ee8452006-05-15 21:03:46 +09001700 return;
1701
1702 /* is it NCQ device error? */
Tejun Heo02607312007-08-06 18:36:23 +09001703 if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
Tejun Heoe8ee8452006-05-15 21:03:46 +09001704 return;
1705
1706 /* has LLDD analyzed already? */
1707 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1708 qc = __ata_qc_from_tag(ap, tag);
1709
1710 if (!(qc->flags & ATA_QCFLAG_FAILED))
1711 continue;
1712
1713 if (qc->err_mask)
1714 return;
1715 }
1716
1717 /* okay, this error is ours */
Jeff Garzika09bf4c2010-04-22 21:59:13 -04001718 memset(&tf, 0, sizeof(tf));
Tejun Heoe8ee8452006-05-15 21:03:46 +09001719 rc = ata_eh_read_log_10h(dev, &tag, &tf);
1720 if (rc) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07001721 ata_link_err(link, "failed to read log page 10h (errno=%d)\n",
1722 rc);
Tejun Heoe8ee8452006-05-15 21:03:46 +09001723 return;
1724 }
1725
Tejun Heo02607312007-08-06 18:36:23 +09001726 if (!(link->sactive & (1 << tag))) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07001727 ata_link_err(link, "log page 10h reported inactive tag %d\n",
1728 tag);
Tejun Heoe8ee8452006-05-15 21:03:46 +09001729 return;
1730 }
1731
1732 /* we've got the perpetrator, condemn it */
1733 qc = __ata_qc_from_tag(ap, tag);
1734 memcpy(&qc->result_tf, &tf, sizeof(tf));
Mark Lorda6116c92008-04-23 22:36:25 -04001735 qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
Tejun Heo5335b722007-07-16 14:29:40 +09001736 qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001737 ehc->i.err_mask &= ~AC_ERR_DEV;
1738}
1739
1740/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001741 * ata_eh_analyze_tf - analyze taskfile of a failed qc
1742 * @qc: qc to analyze
1743 * @tf: Taskfile registers to analyze
1744 *
1745 * Analyze taskfile of @qc and further determine cause of
1746 * failure. This function also requests ATAPI sense data if
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001747 * available.
Tejun Heo022bdb02006-05-15 20:58:22 +09001748 *
1749 * LOCKING:
1750 * Kernel thread context (may sleep).
1751 *
1752 * RETURNS:
1753 * Determined recovery action
1754 */
1755static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
1756 const struct ata_taskfile *tf)
1757{
1758 unsigned int tmp, action = 0;
1759 u8 stat = tf->command, err = tf->feature;
1760
1761 if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
1762 qc->err_mask |= AC_ERR_HSM;
Tejun Heocf480622008-01-24 00:05:14 +09001763 return ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001764 }
1765
Tejun Heoa51d6442007-03-20 15:24:11 +09001766 if (stat & (ATA_ERR | ATA_DF))
1767 qc->err_mask |= AC_ERR_DEV;
1768 else
Tejun Heo022bdb02006-05-15 20:58:22 +09001769 return 0;
1770
1771 switch (qc->dev->class) {
1772 case ATA_DEV_ATA:
1773 if (err & ATA_ICRC)
1774 qc->err_mask |= AC_ERR_ATA_BUS;
1775 if (err & ATA_UNC)
1776 qc->err_mask |= AC_ERR_MEDIA;
1777 if (err & ATA_IDNF)
1778 qc->err_mask |= AC_ERR_INVALID;
1779 break;
1780
1781 case ATA_DEV_ATAPI:
Tejun Heoa569a302006-11-21 10:40:51 +09001782 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
Tejun Heo3eabddb2008-06-10 18:28:05 +09001783 tmp = atapi_eh_request_sense(qc->dev,
1784 qc->scsicmd->sense_buffer,
1785 qc->result_tf.feature >> 4);
Tejun Heoa569a302006-11-21 10:40:51 +09001786 if (!tmp) {
1787 /* ATA_QCFLAG_SENSE_VALID is used to
1788 * tell atapi_qc_complete() that sense
1789 * data is already valid.
1790 *
1791 * TODO: interpret sense data and set
1792 * appropriate err_mask.
1793 */
1794 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1795 } else
1796 qc->err_mask |= tmp;
1797 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001798 }
1799
1800 if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
Tejun Heocf480622008-01-24 00:05:14 +09001801 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001802
1803 return action;
1804}
1805
Tejun Heo76326ac2007-11-27 19:28:59 +09001806static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
1807 int *xfer_ok)
Tejun Heo022bdb02006-05-15 20:58:22 +09001808{
Tejun Heo76326ac2007-11-27 19:28:59 +09001809 int base = 0;
1810
1811 if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
1812 *xfer_ok = 1;
1813
1814 if (!*xfer_ok)
Tejun Heo75f9caf2008-01-03 01:21:14 +09001815 base = ATA_ECAT_DUBIOUS_NONE;
Tejun Heo76326ac2007-11-27 19:28:59 +09001816
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001817 if (err_mask & AC_ERR_ATA_BUS)
Tejun Heo76326ac2007-11-27 19:28:59 +09001818 return base + ATA_ECAT_ATA_BUS;
Tejun Heo022bdb02006-05-15 20:58:22 +09001819
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001820 if (err_mask & AC_ERR_TIMEOUT)
Tejun Heo76326ac2007-11-27 19:28:59 +09001821 return base + ATA_ECAT_TOUT_HSM;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001822
Tejun Heo3884f7b2007-11-27 19:28:56 +09001823 if (eflags & ATA_EFLAG_IS_IO) {
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001824 if (err_mask & AC_ERR_HSM)
Tejun Heo76326ac2007-11-27 19:28:59 +09001825 return base + ATA_ECAT_TOUT_HSM;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001826 if ((err_mask &
1827 (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
Tejun Heo76326ac2007-11-27 19:28:59 +09001828 return base + ATA_ECAT_UNK_DEV;
Tejun Heo022bdb02006-05-15 20:58:22 +09001829 }
1830
1831 return 0;
1832}
1833
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001834struct speed_down_verdict_arg {
Tejun Heo022bdb02006-05-15 20:58:22 +09001835 u64 since;
Tejun Heo76326ac2007-11-27 19:28:59 +09001836 int xfer_ok;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001837 int nr_errors[ATA_ECAT_NR];
Tejun Heo022bdb02006-05-15 20:58:22 +09001838};
1839
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001840static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
Tejun Heo022bdb02006-05-15 20:58:22 +09001841{
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001842 struct speed_down_verdict_arg *arg = void_arg;
Tejun Heo76326ac2007-11-27 19:28:59 +09001843 int cat;
Tejun Heo022bdb02006-05-15 20:58:22 +09001844
Gwendal Grignoud9027472010-05-25 12:31:38 -07001845 if ((ent->eflags & ATA_EFLAG_OLD_ER) || (ent->timestamp < arg->since))
Tejun Heo022bdb02006-05-15 20:58:22 +09001846 return -1;
1847
Tejun Heo76326ac2007-11-27 19:28:59 +09001848 cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
1849 &arg->xfer_ok);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001850 arg->nr_errors[cat]++;
Tejun Heo76326ac2007-11-27 19:28:59 +09001851
Tejun Heo022bdb02006-05-15 20:58:22 +09001852 return 0;
1853}
1854
1855/**
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001856 * ata_eh_speed_down_verdict - Determine speed down verdict
Tejun Heo022bdb02006-05-15 20:58:22 +09001857 * @dev: Device of interest
1858 *
1859 * This function examines error ring of @dev and determines
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001860 * whether NCQ needs to be turned off, transfer speed should be
1861 * stepped down, or falling back to PIO is necessary.
Tejun Heo022bdb02006-05-15 20:58:22 +09001862 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001863 * ECAT_ATA_BUS : ATA_BUS error for any command
Tejun Heo022bdb02006-05-15 20:58:22 +09001864 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001865 * ECAT_TOUT_HSM : TIMEOUT for any command or HSM violation for
1866 * IO commands
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001867 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001868 * ECAT_UNK_DEV : Unknown DEV error for IO commands
Tejun Heo022bdb02006-05-15 20:58:22 +09001869 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001870 * ECAT_DUBIOUS_* : Identical to above three but occurred while
1871 * data transfer hasn't been verified.
1872 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001873 * Verdicts are
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001874 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001875 * NCQ_OFF : Turn off NCQ.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001876 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001877 * SPEED_DOWN : Speed down transfer speed but don't fall back
1878 * to PIO.
1879 *
1880 * FALLBACK_TO_PIO : Fall back to PIO.
1881 *
1882 * Even if multiple verdicts are returned, only one action is
Tejun Heo76326ac2007-11-27 19:28:59 +09001883 * taken per error. An action triggered by non-DUBIOUS errors
1884 * clears ering, while one triggered by DUBIOUS_* errors doesn't.
1885 * This is to expedite speed down decisions right after device is
1886 * initially configured.
Tejun Heo3884f7b2007-11-27 19:28:56 +09001887 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001888 * The followings are speed down rules. #1 and #2 deal with
1889 * DUBIOUS errors.
1890 *
1891 * 1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors
1892 * occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO.
1893 *
1894 * 2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors
1895 * occurred during last 5 mins, NCQ_OFF.
1896 *
1897 * 3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001898 * occurred during last 5 mins, FALLBACK_TO_PIO
Tejun Heo3884f7b2007-11-27 19:28:56 +09001899 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001900 * 4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
Tejun Heo3884f7b2007-11-27 19:28:56 +09001901 * during last 10 mins, NCQ_OFF.
1902 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001903 * 5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6
Tejun Heo3884f7b2007-11-27 19:28:56 +09001904 * UNK_DEV errors occurred during last 10 mins, SPEED_DOWN.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001905 *
Tejun Heo022bdb02006-05-15 20:58:22 +09001906 * LOCKING:
1907 * Inherited from caller.
1908 *
1909 * RETURNS:
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001910 * OR of ATA_EH_SPDN_* flags.
Tejun Heo022bdb02006-05-15 20:58:22 +09001911 */
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001912static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
Tejun Heo022bdb02006-05-15 20:58:22 +09001913{
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001914 const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
1915 u64 j64 = get_jiffies_64();
1916 struct speed_down_verdict_arg arg;
1917 unsigned int verdict = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09001918
Tejun Heo3884f7b2007-11-27 19:28:56 +09001919 /* scan past 5 mins of error history */
1920 memset(&arg, 0, sizeof(arg));
1921 arg.since = j64 - min(j64, j5mins);
1922 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1923
Tejun Heo76326ac2007-11-27 19:28:59 +09001924 if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
1925 arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
1926 verdict |= ATA_EH_SPDN_SPEED_DOWN |
1927 ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
1928
1929 if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
1930 arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
1931 verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
1932
Tejun Heo3884f7b2007-11-27 19:28:56 +09001933 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1934 arg.nr_errors[ATA_ECAT_TOUT_HSM] +
Tejun Heo663f99b2007-11-27 19:28:57 +09001935 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
Tejun Heo3884f7b2007-11-27 19:28:56 +09001936 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
1937
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001938 /* scan past 10 mins of error history */
Tejun Heo022bdb02006-05-15 20:58:22 +09001939 memset(&arg, 0, sizeof(arg));
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001940 arg.since = j64 - min(j64, j10mins);
1941 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
Tejun Heo022bdb02006-05-15 20:58:22 +09001942
Tejun Heo3884f7b2007-11-27 19:28:56 +09001943 if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1944 arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001945 verdict |= ATA_EH_SPDN_NCQ_OFF;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001946
1947 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1948 arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
Tejun Heo663f99b2007-11-27 19:28:57 +09001949 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001950 verdict |= ATA_EH_SPDN_SPEED_DOWN;
Tejun Heo022bdb02006-05-15 20:58:22 +09001951
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001952 return verdict;
Tejun Heo022bdb02006-05-15 20:58:22 +09001953}
1954
1955/**
1956 * ata_eh_speed_down - record error and speed down if necessary
1957 * @dev: Failed device
Tejun Heo3884f7b2007-11-27 19:28:56 +09001958 * @eflags: mask of ATA_EFLAG_* flags
Tejun Heo022bdb02006-05-15 20:58:22 +09001959 * @err_mask: err_mask of the error
1960 *
1961 * Record error and examine error history to determine whether
1962 * adjusting transmission speed is necessary. It also sets
1963 * transmission limits appropriately if such adjustment is
1964 * necessary.
1965 *
1966 * LOCKING:
1967 * Kernel thread context (may sleep).
1968 *
1969 * RETURNS:
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001970 * Determined recovery action.
Tejun Heo022bdb02006-05-15 20:58:22 +09001971 */
Tejun Heo3884f7b2007-11-27 19:28:56 +09001972static unsigned int ata_eh_speed_down(struct ata_device *dev,
1973 unsigned int eflags, unsigned int err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09001974{
Tejun Heob1c72912008-07-31 17:02:43 +09001975 struct ata_link *link = ata_dev_phys_link(dev);
Tejun Heo76326ac2007-11-27 19:28:59 +09001976 int xfer_ok = 0;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001977 unsigned int verdict;
1978 unsigned int action = 0;
1979
1980 /* don't bother if Cat-0 error */
Tejun Heo76326ac2007-11-27 19:28:59 +09001981 if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
Tejun Heo022bdb02006-05-15 20:58:22 +09001982 return 0;
1983
1984 /* record error and determine whether speed down is necessary */
Tejun Heo3884f7b2007-11-27 19:28:56 +09001985 ata_ering_record(&dev->ering, eflags, err_mask);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001986 verdict = ata_eh_speed_down_verdict(dev);
Tejun Heo022bdb02006-05-15 20:58:22 +09001987
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001988 /* turn off NCQ? */
1989 if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
1990 (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
1991 ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
1992 dev->flags |= ATA_DFLAG_NCQ_OFF;
Joe Perchesa9a79df2011-04-15 15:51:59 -07001993 ata_dev_warn(dev, "NCQ disabled due to excessive errors\n");
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001994 goto done;
1995 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001996
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001997 /* speed down? */
1998 if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
1999 /* speed down SATA link speed if possible */
Tejun Heoa07d4992009-01-29 20:31:33 +09002000 if (sata_down_spd_limit(link, 0) == 0) {
Tejun Heocf480622008-01-24 00:05:14 +09002001 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09002002 goto done;
2003 }
Tejun Heo022bdb02006-05-15 20:58:22 +09002004
Tejun Heo7d47e8d2007-02-02 16:22:31 +09002005 /* lower transfer mode */
2006 if (dev->spdn_cnt < 2) {
2007 static const int dma_dnxfer_sel[] =
2008 { ATA_DNXFER_DMA, ATA_DNXFER_40C };
2009 static const int pio_dnxfer_sel[] =
2010 { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
2011 int sel;
Tejun Heo022bdb02006-05-15 20:58:22 +09002012
Tejun Heo7d47e8d2007-02-02 16:22:31 +09002013 if (dev->xfer_shift != ATA_SHIFT_PIO)
2014 sel = dma_dnxfer_sel[dev->spdn_cnt];
2015 else
2016 sel = pio_dnxfer_sel[dev->spdn_cnt];
2017
2018 dev->spdn_cnt++;
2019
2020 if (ata_down_xfermask_limit(dev, sel) == 0) {
Tejun Heocf480622008-01-24 00:05:14 +09002021 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09002022 goto done;
2023 }
2024 }
2025 }
2026
2027 /* Fall back to PIO? Slowing down to PIO is meaningless for
Tejun Heo663f99b2007-11-27 19:28:57 +09002028 * SATA ATA devices. Consider it only for PATA and SATAPI.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09002029 */
2030 if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
Tejun Heo663f99b2007-11-27 19:28:57 +09002031 (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) &&
Tejun Heo7d47e8d2007-02-02 16:22:31 +09002032 (dev->xfer_shift != ATA_SHIFT_PIO)) {
2033 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
2034 dev->spdn_cnt = 0;
Tejun Heocf480622008-01-24 00:05:14 +09002035 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09002036 goto done;
2037 }
2038 }
2039
Tejun Heo022bdb02006-05-15 20:58:22 +09002040 return 0;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09002041 done:
2042 /* device has been slowed down, blow error history */
Tejun Heo76326ac2007-11-27 19:28:59 +09002043 if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS))
2044 ata_ering_clear(&dev->ering);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09002045 return action;
Tejun Heo022bdb02006-05-15 20:58:22 +09002046}
2047
2048/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09002049 * ata_eh_link_autopsy - analyze error and determine recovery action
2050 * @link: host link to perform autopsy on
Tejun Heo022bdb02006-05-15 20:58:22 +09002051 *
Tejun Heo02607312007-08-06 18:36:23 +09002052 * Analyze why @link failed and determine which recovery actions
2053 * are needed. This function also sets more detailed AC_ERR_*
2054 * values and fills sense data for ATAPI CHECK SENSE.
Tejun Heo022bdb02006-05-15 20:58:22 +09002055 *
2056 * LOCKING:
2057 * Kernel thread context (may sleep).
2058 */
Tejun Heo9b1e2652007-08-06 18:36:24 +09002059static void ata_eh_link_autopsy(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09002060{
Tejun Heo02607312007-08-06 18:36:23 +09002061 struct ata_port *ap = link->ap;
Tejun Heo936fd732007-08-06 18:36:23 +09002062 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heodfcc1732007-10-31 10:17:05 +09002063 struct ata_device *dev;
Tejun Heo3884f7b2007-11-27 19:28:56 +09002064 unsigned int all_err_mask = 0, eflags = 0;
2065 int tag;
Tejun Heo022bdb02006-05-15 20:58:22 +09002066 u32 serror;
2067 int rc;
2068
2069 DPRINTK("ENTER\n");
2070
Tejun Heo1cdaf532006-07-03 16:07:26 +09002071 if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
2072 return;
2073
Tejun Heo022bdb02006-05-15 20:58:22 +09002074 /* obtain and analyze SError */
Tejun Heo936fd732007-08-06 18:36:23 +09002075 rc = sata_scr_read(link, SCR_ERROR, &serror);
Tejun Heo022bdb02006-05-15 20:58:22 +09002076 if (rc == 0) {
2077 ehc->i.serror |= serror;
Tejun Heo02607312007-08-06 18:36:23 +09002078 ata_eh_analyze_serror(link);
Tejun Heo4e57c512007-07-16 14:29:41 +09002079 } else if (rc != -EOPNOTSUPP) {
Tejun Heocf480622008-01-24 00:05:14 +09002080 /* SError read failed, force reset and probing */
Tejun Heob558edd2008-01-24 00:05:14 +09002081 ehc->i.probe_mask |= ATA_ALL_DEVICES;
Tejun Heocf480622008-01-24 00:05:14 +09002082 ehc->i.action |= ATA_EH_RESET;
Tejun Heo4e57c512007-07-16 14:29:41 +09002083 ehc->i.err_mask |= AC_ERR_OTHER;
2084 }
Tejun Heo022bdb02006-05-15 20:58:22 +09002085
Tejun Heoe8ee8452006-05-15 21:03:46 +09002086 /* analyze NCQ failure */
Tejun Heo02607312007-08-06 18:36:23 +09002087 ata_eh_analyze_ncq_error(link);
Tejun Heoe8ee8452006-05-15 21:03:46 +09002088
Tejun Heo022bdb02006-05-15 20:58:22 +09002089 /* any real error trumps AC_ERR_OTHER */
2090 if (ehc->i.err_mask & ~AC_ERR_OTHER)
2091 ehc->i.err_mask &= ~AC_ERR_OTHER;
2092
2093 all_err_mask |= ehc->i.err_mask;
2094
2095 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2096 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2097
Tejun Heob1c72912008-07-31 17:02:43 +09002098 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2099 ata_dev_phys_link(qc->dev) != link)
Tejun Heo022bdb02006-05-15 20:58:22 +09002100 continue;
2101
2102 /* inherit upper level err_mask */
2103 qc->err_mask |= ehc->i.err_mask;
2104
Tejun Heo022bdb02006-05-15 20:58:22 +09002105 /* analyze TF */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002106 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002107
2108 /* DEV errors are probably spurious in case of ATA_BUS error */
2109 if (qc->err_mask & AC_ERR_ATA_BUS)
2110 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
2111 AC_ERR_INVALID);
2112
2113 /* any real error trumps unknown error */
2114 if (qc->err_mask & ~AC_ERR_OTHER)
2115 qc->err_mask &= ~AC_ERR_OTHER;
2116
2117 /* SENSE_VALID trumps dev/unknown error and revalidation */
Tejun Heof90f0822007-10-26 16:12:41 +09002118 if (qc->flags & ATA_QCFLAG_SENSE_VALID)
Tejun Heo022bdb02006-05-15 20:58:22 +09002119 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
Tejun Heo022bdb02006-05-15 20:58:22 +09002120
Tejun Heo03faab72008-03-27 19:14:24 +09002121 /* determine whether the command is worth retrying */
Tejun Heo534ead72010-01-14 16:18:09 +09002122 if (qc->flags & ATA_QCFLAG_IO ||
2123 (!(qc->err_mask & AC_ERR_INVALID) &&
2124 qc->err_mask != AC_ERR_DEV))
Tejun Heo03faab72008-03-27 19:14:24 +09002125 qc->flags |= ATA_QCFLAG_RETRY;
2126
Tejun Heo022bdb02006-05-15 20:58:22 +09002127 /* accumulate error info */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002128 ehc->i.dev = qc->dev;
Tejun Heo022bdb02006-05-15 20:58:22 +09002129 all_err_mask |= qc->err_mask;
2130 if (qc->flags & ATA_QCFLAG_IO)
Tejun Heo3884f7b2007-11-27 19:28:56 +09002131 eflags |= ATA_EFLAG_IS_IO;
Tejun Heo022bdb02006-05-15 20:58:22 +09002132 }
2133
Tejun Heoa20f33f2006-05-16 12:58:24 +09002134 /* enforce default EH actions */
Tejun Heob51e9e52006-06-29 01:29:30 +09002135 if (ap->pflags & ATA_PFLAG_FROZEN ||
Tejun Heoa20f33f2006-05-16 12:58:24 +09002136 all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
Tejun Heocf480622008-01-24 00:05:14 +09002137 ehc->i.action |= ATA_EH_RESET;
Tejun Heo3884f7b2007-11-27 19:28:56 +09002138 else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) ||
2139 (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV)))
Tejun Heo4528e4d2006-07-08 20:17:26 +09002140 ehc->i.action |= ATA_EH_REVALIDATE;
Tejun Heo022bdb02006-05-15 20:58:22 +09002141
Tejun Heodfcc1732007-10-31 10:17:05 +09002142 /* If we have offending qcs and the associated failed device,
2143 * perform per-dev EH action only on the offending device.
2144 */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002145 if (ehc->i.dev) {
Tejun Heo4528e4d2006-07-08 20:17:26 +09002146 ehc->i.dev_action[ehc->i.dev->devno] |=
2147 ehc->i.action & ATA_EH_PERDEV_MASK;
2148 ehc->i.action &= ~ATA_EH_PERDEV_MASK;
Tejun Heo47005f22006-06-19 18:27:23 +09002149 }
2150
Tejun Heo2695e362008-01-10 13:41:23 +09002151 /* propagate timeout to host link */
2152 if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link))
2153 ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT;
2154
2155 /* record error and consider speeding down */
Tejun Heodfcc1732007-10-31 10:17:05 +09002156 dev = ehc->i.dev;
Tejun Heo2695e362008-01-10 13:41:23 +09002157 if (!dev && ((ata_link_max_devices(link) == 1 &&
2158 ata_dev_enabled(link->device))))
2159 dev = link->device;
Tejun Heodfcc1732007-10-31 10:17:05 +09002160
Tejun Heo76326ac2007-11-27 19:28:59 +09002161 if (dev) {
2162 if (dev->flags & ATA_DFLAG_DUBIOUS_XFER)
2163 eflags |= ATA_EFLAG_DUBIOUS_XFER;
Tejun Heo3884f7b2007-11-27 19:28:56 +09002164 ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask);
Tejun Heo76326ac2007-11-27 19:28:59 +09002165 }
Tejun Heodfcc1732007-10-31 10:17:05 +09002166
Tejun Heo022bdb02006-05-15 20:58:22 +09002167 DPRINTK("EXIT\n");
2168}
2169
2170/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09002171 * ata_eh_autopsy - analyze error and determine recovery action
2172 * @ap: host port to perform autopsy on
2173 *
2174 * Analyze all links of @ap and determine why they failed and
2175 * which recovery actions are needed.
2176 *
2177 * LOCKING:
2178 * Kernel thread context (may sleep).
2179 */
Tejun Heofb7fd612007-09-23 13:14:12 +09002180void ata_eh_autopsy(struct ata_port *ap)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002181{
2182 struct ata_link *link;
2183
Tejun Heo1eca4362008-11-03 20:03:17 +09002184 ata_for_each_link(link, ap, EDGE)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002185 ata_eh_link_autopsy(link);
Tejun Heo2695e362008-01-10 13:41:23 +09002186
Tejun Heob1c72912008-07-31 17:02:43 +09002187 /* Handle the frigging slave link. Autopsy is done similarly
2188 * but actions and flags are transferred over to the master
2189 * link and handled from there.
2190 */
2191 if (ap->slave_link) {
2192 struct ata_eh_context *mehc = &ap->link.eh_context;
2193 struct ata_eh_context *sehc = &ap->slave_link->eh_context;
2194
Tejun Heo848e4c62008-10-21 14:26:39 +09002195 /* transfer control flags from master to slave */
2196 sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK;
2197
2198 /* perform autopsy on the slave link */
Tejun Heob1c72912008-07-31 17:02:43 +09002199 ata_eh_link_autopsy(ap->slave_link);
2200
Tejun Heo848e4c62008-10-21 14:26:39 +09002201 /* transfer actions from slave to master and clear slave */
Tejun Heob1c72912008-07-31 17:02:43 +09002202 ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2203 mehc->i.action |= sehc->i.action;
2204 mehc->i.dev_action[1] |= sehc->i.dev_action[1];
2205 mehc->i.flags |= sehc->i.flags;
2206 ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2207 }
2208
Tejun Heo2695e362008-01-10 13:41:23 +09002209 /* Autopsy of fanout ports can affect host link autopsy.
2210 * Perform host link autopsy last.
2211 */
Tejun Heo071f44b2008-04-07 22:47:22 +09002212 if (sata_pmp_attached(ap))
Tejun Heo2695e362008-01-10 13:41:23 +09002213 ata_eh_link_autopsy(&ap->link);
Tejun Heo9b1e2652007-08-06 18:36:24 +09002214}
2215
2216/**
Robert Hancock65211482009-07-14 20:43:39 -06002217 * ata_get_cmd_descript - get description for ATA command
2218 * @command: ATA command code to get description for
2219 *
2220 * Return a textual description of the given command, or NULL if the
2221 * command is not known.
2222 *
2223 * LOCKING:
2224 * None
2225 */
2226const char *ata_get_cmd_descript(u8 command)
2227{
2228#ifdef CONFIG_ATA_VERBOSE_ERROR
2229 static const struct
2230 {
2231 u8 command;
2232 const char *text;
2233 } cmd_descr[] = {
2234 { ATA_CMD_DEV_RESET, "DEVICE RESET" },
2235 { ATA_CMD_CHK_POWER, "CHECK POWER MODE" },
2236 { ATA_CMD_STANDBY, "STANDBY" },
2237 { ATA_CMD_IDLE, "IDLE" },
2238 { ATA_CMD_EDD, "EXECUTE DEVICE DIAGNOSTIC" },
2239 { ATA_CMD_DOWNLOAD_MICRO, "DOWNLOAD MICROCODE" },
2240 { ATA_CMD_NOP, "NOP" },
2241 { ATA_CMD_FLUSH, "FLUSH CACHE" },
2242 { ATA_CMD_FLUSH_EXT, "FLUSH CACHE EXT" },
2243 { ATA_CMD_ID_ATA, "IDENTIFY DEVICE" },
2244 { ATA_CMD_ID_ATAPI, "IDENTIFY PACKET DEVICE" },
2245 { ATA_CMD_SERVICE, "SERVICE" },
2246 { ATA_CMD_READ, "READ DMA" },
2247 { ATA_CMD_READ_EXT, "READ DMA EXT" },
2248 { ATA_CMD_READ_QUEUED, "READ DMA QUEUED" },
2249 { ATA_CMD_READ_STREAM_EXT, "READ STREAM EXT" },
2250 { ATA_CMD_READ_STREAM_DMA_EXT, "READ STREAM DMA EXT" },
2251 { ATA_CMD_WRITE, "WRITE DMA" },
2252 { ATA_CMD_WRITE_EXT, "WRITE DMA EXT" },
2253 { ATA_CMD_WRITE_QUEUED, "WRITE DMA QUEUED EXT" },
2254 { ATA_CMD_WRITE_STREAM_EXT, "WRITE STREAM EXT" },
2255 { ATA_CMD_WRITE_STREAM_DMA_EXT, "WRITE STREAM DMA EXT" },
2256 { ATA_CMD_WRITE_FUA_EXT, "WRITE DMA FUA EXT" },
2257 { ATA_CMD_WRITE_QUEUED_FUA_EXT, "WRITE DMA QUEUED FUA EXT" },
2258 { ATA_CMD_FPDMA_READ, "READ FPDMA QUEUED" },
2259 { ATA_CMD_FPDMA_WRITE, "WRITE FPDMA QUEUED" },
2260 { ATA_CMD_PIO_READ, "READ SECTOR(S)" },
2261 { ATA_CMD_PIO_READ_EXT, "READ SECTOR(S) EXT" },
2262 { ATA_CMD_PIO_WRITE, "WRITE SECTOR(S)" },
2263 { ATA_CMD_PIO_WRITE_EXT, "WRITE SECTOR(S) EXT" },
2264 { ATA_CMD_READ_MULTI, "READ MULTIPLE" },
2265 { ATA_CMD_READ_MULTI_EXT, "READ MULTIPLE EXT" },
2266 { ATA_CMD_WRITE_MULTI, "WRITE MULTIPLE" },
2267 { ATA_CMD_WRITE_MULTI_EXT, "WRITE MULTIPLE EXT" },
2268 { ATA_CMD_WRITE_MULTI_FUA_EXT, "WRITE MULTIPLE FUA EXT" },
2269 { ATA_CMD_SET_FEATURES, "SET FEATURES" },
2270 { ATA_CMD_SET_MULTI, "SET MULTIPLE MODE" },
2271 { ATA_CMD_VERIFY, "READ VERIFY SECTOR(S)" },
2272 { ATA_CMD_VERIFY_EXT, "READ VERIFY SECTOR(S) EXT" },
2273 { ATA_CMD_WRITE_UNCORR_EXT, "WRITE UNCORRECTABLE EXT" },
2274 { ATA_CMD_STANDBYNOW1, "STANDBY IMMEDIATE" },
2275 { ATA_CMD_IDLEIMMEDIATE, "IDLE IMMEDIATE" },
2276 { ATA_CMD_SLEEP, "SLEEP" },
2277 { ATA_CMD_INIT_DEV_PARAMS, "INITIALIZE DEVICE PARAMETERS" },
2278 { ATA_CMD_READ_NATIVE_MAX, "READ NATIVE MAX ADDRESS" },
2279 { ATA_CMD_READ_NATIVE_MAX_EXT, "READ NATIVE MAX ADDRESS EXT" },
2280 { ATA_CMD_SET_MAX, "SET MAX ADDRESS" },
2281 { ATA_CMD_SET_MAX_EXT, "SET MAX ADDRESS EXT" },
2282 { ATA_CMD_READ_LOG_EXT, "READ LOG EXT" },
2283 { ATA_CMD_WRITE_LOG_EXT, "WRITE LOG EXT" },
2284 { ATA_CMD_READ_LOG_DMA_EXT, "READ LOG DMA EXT" },
2285 { ATA_CMD_WRITE_LOG_DMA_EXT, "WRITE LOG DMA EXT" },
2286 { ATA_CMD_TRUSTED_RCV, "TRUSTED RECEIVE" },
2287 { ATA_CMD_TRUSTED_RCV_DMA, "TRUSTED RECEIVE DMA" },
2288 { ATA_CMD_TRUSTED_SND, "TRUSTED SEND" },
2289 { ATA_CMD_TRUSTED_SND_DMA, "TRUSTED SEND DMA" },
2290 { ATA_CMD_PMP_READ, "READ BUFFER" },
2291 { ATA_CMD_PMP_WRITE, "WRITE BUFFER" },
2292 { ATA_CMD_CONF_OVERLAY, "DEVICE CONFIGURATION OVERLAY" },
2293 { ATA_CMD_SEC_SET_PASS, "SECURITY SET PASSWORD" },
2294 { ATA_CMD_SEC_UNLOCK, "SECURITY UNLOCK" },
2295 { ATA_CMD_SEC_ERASE_PREP, "SECURITY ERASE PREPARE" },
2296 { ATA_CMD_SEC_ERASE_UNIT, "SECURITY ERASE UNIT" },
2297 { ATA_CMD_SEC_FREEZE_LOCK, "SECURITY FREEZE LOCK" },
2298 { ATA_CMD_SEC_DISABLE_PASS, "SECURITY DISABLE PASSWORD" },
2299 { ATA_CMD_CONFIG_STREAM, "CONFIGURE STREAM" },
2300 { ATA_CMD_SMART, "SMART" },
2301 { ATA_CMD_MEDIA_LOCK, "DOOR LOCK" },
2302 { ATA_CMD_MEDIA_UNLOCK, "DOOR UNLOCK" },
FUJITA Tomonoriacad762722010-07-05 15:45:20 +09002303 { ATA_CMD_DSM, "DATA SET MANAGEMENT" },
Robert Hancock65211482009-07-14 20:43:39 -06002304 { ATA_CMD_CHK_MED_CRD_TYP, "CHECK MEDIA CARD TYPE" },
2305 { ATA_CMD_CFA_REQ_EXT_ERR, "CFA REQUEST EXTENDED ERROR" },
2306 { ATA_CMD_CFA_WRITE_NE, "CFA WRITE SECTORS WITHOUT ERASE" },
2307 { ATA_CMD_CFA_TRANS_SECT, "CFA TRANSLATE SECTOR" },
2308 { ATA_CMD_CFA_ERASE, "CFA ERASE SECTORS" },
2309 { ATA_CMD_CFA_WRITE_MULT_NE, "CFA WRITE MULTIPLE WITHOUT ERASE" },
2310 { ATA_CMD_READ_LONG, "READ LONG (with retries)" },
2311 { ATA_CMD_READ_LONG_ONCE, "READ LONG (without retries)" },
2312 { ATA_CMD_WRITE_LONG, "WRITE LONG (with retries)" },
2313 { ATA_CMD_WRITE_LONG_ONCE, "WRITE LONG (without retries)" },
2314 { ATA_CMD_RESTORE, "RECALIBRATE" },
2315 { 0, NULL } /* terminate list */
2316 };
2317
2318 unsigned int i;
2319 for (i = 0; cmd_descr[i].text; i++)
2320 if (cmd_descr[i].command == command)
2321 return cmd_descr[i].text;
2322#endif
2323
2324 return NULL;
2325}
2326
2327/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09002328 * ata_eh_link_report - report error handling to user
Tejun Heo02607312007-08-06 18:36:23 +09002329 * @link: ATA link EH is going on
Tejun Heo022bdb02006-05-15 20:58:22 +09002330 *
2331 * Report EH to user.
2332 *
2333 * LOCKING:
2334 * None.
2335 */
Tejun Heo9b1e2652007-08-06 18:36:24 +09002336static void ata_eh_link_report(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09002337{
Tejun Heo02607312007-08-06 18:36:23 +09002338 struct ata_port *ap = link->ap;
2339 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09002340 const char *frozen, *desc;
Tejun Heoa1e10f72007-08-18 13:28:49 +09002341 char tries_buf[6];
Tejun Heo022bdb02006-05-15 20:58:22 +09002342 int tag, nr_failed = 0;
2343
Tejun Heo94ff3d52007-10-09 14:57:56 +09002344 if (ehc->i.flags & ATA_EHI_QUIET)
2345 return;
2346
Tejun Heo022bdb02006-05-15 20:58:22 +09002347 desc = NULL;
2348 if (ehc->i.desc[0] != '\0')
2349 desc = ehc->i.desc;
2350
2351 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2352 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2353
Tejun Heob1c72912008-07-31 17:02:43 +09002354 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2355 ata_dev_phys_link(qc->dev) != link ||
Tejun Heoe027bd32007-10-26 16:19:26 +09002356 ((qc->flags & ATA_QCFLAG_QUIET) &&
2357 qc->err_mask == AC_ERR_DEV))
Tejun Heo022bdb02006-05-15 20:58:22 +09002358 continue;
2359 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
2360 continue;
2361
2362 nr_failed++;
2363 }
2364
2365 if (!nr_failed && !ehc->i.err_mask)
2366 return;
2367
2368 frozen = "";
Tejun Heob51e9e52006-06-29 01:29:30 +09002369 if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heo022bdb02006-05-15 20:58:22 +09002370 frozen = " frozen";
2371
Tejun Heoa1e10f72007-08-18 13:28:49 +09002372 memset(tries_buf, 0, sizeof(tries_buf));
2373 if (ap->eh_tries < ATA_EH_MAX_TRIES)
2374 snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
2375 ap->eh_tries);
2376
Tejun Heo022bdb02006-05-15 20:58:22 +09002377 if (ehc->i.dev) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002378 ata_dev_err(ehc->i.dev, "exception Emask 0x%x "
2379 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2380 ehc->i.err_mask, link->sactive, ehc->i.serror,
2381 ehc->i.action, frozen, tries_buf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002382 if (desc)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002383 ata_dev_err(ehc->i.dev, "%s\n", desc);
Tejun Heo022bdb02006-05-15 20:58:22 +09002384 } else {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002385 ata_link_err(link, "exception Emask 0x%x "
2386 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2387 ehc->i.err_mask, link->sactive, ehc->i.serror,
2388 ehc->i.action, frozen, tries_buf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002389 if (desc)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002390 ata_link_err(link, "%s\n", desc);
Tejun Heo022bdb02006-05-15 20:58:22 +09002391 }
2392
Robert Hancock65211482009-07-14 20:43:39 -06002393#ifdef CONFIG_ATA_VERBOSE_ERROR
Robert Hancock1333e192007-10-02 11:22:02 -04002394 if (ehc->i.serror)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002395 ata_link_err(link,
Robert Hancock1333e192007-10-02 11:22:02 -04002396 "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
2397 ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
2398 ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
2399 ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
2400 ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
2401 ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
2402 ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
2403 ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
2404 ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
2405 ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
2406 ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
2407 ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
2408 ehc->i.serror & SERR_CRC ? "BadCRC " : "",
2409 ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
2410 ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
2411 ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
2412 ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002413 ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
Robert Hancock65211482009-07-14 20:43:39 -06002414#endif
Robert Hancock1333e192007-10-02 11:22:02 -04002415
Tejun Heo022bdb02006-05-15 20:58:22 +09002416 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2417 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
Tejun Heo8a937582006-11-14 22:36:12 +09002418 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
Tejun Heoabb6a882007-11-28 23:16:09 +09002419 const u8 *cdb = qc->cdb;
2420 char data_buf[20] = "";
2421 char cdb_buf[70] = "";
Tejun Heo022bdb02006-05-15 20:58:22 +09002422
Tejun Heo02607312007-08-06 18:36:23 +09002423 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
Tejun Heob1c72912008-07-31 17:02:43 +09002424 ata_dev_phys_link(qc->dev) != link || !qc->err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09002425 continue;
2426
Tejun Heoabb6a882007-11-28 23:16:09 +09002427 if (qc->dma_dir != DMA_NONE) {
2428 static const char *dma_str[] = {
2429 [DMA_BIDIRECTIONAL] = "bidi",
2430 [DMA_TO_DEVICE] = "out",
2431 [DMA_FROM_DEVICE] = "in",
2432 };
2433 static const char *prot_str[] = {
2434 [ATA_PROT_PIO] = "pio",
2435 [ATA_PROT_DMA] = "dma",
2436 [ATA_PROT_NCQ] = "ncq",
Tejun Heo0dc36882007-12-18 16:34:43 -05002437 [ATAPI_PROT_PIO] = "pio",
2438 [ATAPI_PROT_DMA] = "dma",
Tejun Heoabb6a882007-11-28 23:16:09 +09002439 };
2440
2441 snprintf(data_buf, sizeof(data_buf), " %s %u %s",
2442 prot_str[qc->tf.protocol], qc->nbytes,
2443 dma_str[qc->dma_dir]);
2444 }
2445
Robert Hancock65211482009-07-14 20:43:39 -06002446 if (ata_is_atapi(qc->tf.protocol)) {
2447 if (qc->scsicmd)
2448 scsi_print_command(qc->scsicmd);
2449 else
2450 snprintf(cdb_buf, sizeof(cdb_buf),
Tejun Heoabb6a882007-11-28 23:16:09 +09002451 "cdb %02x %02x %02x %02x %02x %02x %02x %02x "
2452 "%02x %02x %02x %02x %02x %02x %02x %02x\n ",
2453 cdb[0], cdb[1], cdb[2], cdb[3],
2454 cdb[4], cdb[5], cdb[6], cdb[7],
2455 cdb[8], cdb[9], cdb[10], cdb[11],
2456 cdb[12], cdb[13], cdb[14], cdb[15]);
Robert Hancock65211482009-07-14 20:43:39 -06002457 } else {
2458 const char *descr = ata_get_cmd_descript(cmd->command);
2459 if (descr)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002460 ata_dev_err(qc->dev, "failed command: %s\n",
2461 descr);
Robert Hancock65211482009-07-14 20:43:39 -06002462 }
Tejun Heoabb6a882007-11-28 23:16:09 +09002463
Joe Perchesa9a79df2011-04-15 15:51:59 -07002464 ata_dev_err(qc->dev,
Tejun Heo8a937582006-11-14 22:36:12 +09002465 "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
Tejun Heoabb6a882007-11-28 23:16:09 +09002466 "tag %d%s\n %s"
Tejun Heo8a937582006-11-14 22:36:12 +09002467 "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
Tejun Heo5335b722007-07-16 14:29:40 +09002468 "Emask 0x%x (%s)%s\n",
Tejun Heo8a937582006-11-14 22:36:12 +09002469 cmd->command, cmd->feature, cmd->nsect,
2470 cmd->lbal, cmd->lbam, cmd->lbah,
2471 cmd->hob_feature, cmd->hob_nsect,
2472 cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
Tejun Heoabb6a882007-11-28 23:16:09 +09002473 cmd->device, qc->tag, data_buf, cdb_buf,
Tejun Heo8a937582006-11-14 22:36:12 +09002474 res->command, res->feature, res->nsect,
2475 res->lbal, res->lbam, res->lbah,
2476 res->hob_feature, res->hob_nsect,
2477 res->hob_lbal, res->hob_lbam, res->hob_lbah,
Tejun Heo5335b722007-07-16 14:29:40 +09002478 res->device, qc->err_mask, ata_err_string(qc->err_mask),
2479 qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
Robert Hancock1333e192007-10-02 11:22:02 -04002480
Robert Hancock65211482009-07-14 20:43:39 -06002481#ifdef CONFIG_ATA_VERBOSE_ERROR
Robert Hancock1333e192007-10-02 11:22:02 -04002482 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002483 ATA_ERR)) {
Robert Hancock1333e192007-10-02 11:22:02 -04002484 if (res->command & ATA_BUSY)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002485 ata_dev_err(qc->dev, "status: { Busy }\n");
Robert Hancock1333e192007-10-02 11:22:02 -04002486 else
Joe Perchesa9a79df2011-04-15 15:51:59 -07002487 ata_dev_err(qc->dev, "status: { %s%s%s%s}\n",
Robert Hancock1333e192007-10-02 11:22:02 -04002488 res->command & ATA_DRDY ? "DRDY " : "",
2489 res->command & ATA_DF ? "DF " : "",
2490 res->command & ATA_DRQ ? "DRQ " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002491 res->command & ATA_ERR ? "ERR " : "");
Robert Hancock1333e192007-10-02 11:22:02 -04002492 }
2493
2494 if (cmd->command != ATA_CMD_PACKET &&
2495 (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
2496 ATA_ABORTED)))
Joe Perchesa9a79df2011-04-15 15:51:59 -07002497 ata_dev_err(qc->dev, "error: { %s%s%s%s}\n",
Robert Hancock1333e192007-10-02 11:22:02 -04002498 res->feature & ATA_ICRC ? "ICRC " : "",
2499 res->feature & ATA_UNC ? "UNC " : "",
2500 res->feature & ATA_IDNF ? "IDNF " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002501 res->feature & ATA_ABORTED ? "ABRT " : "");
Robert Hancock65211482009-07-14 20:43:39 -06002502#endif
Tejun Heo022bdb02006-05-15 20:58:22 +09002503 }
2504}
2505
Tejun Heo9b1e2652007-08-06 18:36:24 +09002506/**
2507 * ata_eh_report - report error handling to user
2508 * @ap: ATA port to report EH about
2509 *
2510 * Report EH to user.
2511 *
2512 * LOCKING:
2513 * None.
2514 */
Tejun Heofb7fd612007-09-23 13:14:12 +09002515void ata_eh_report(struct ata_port *ap)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002516{
2517 struct ata_link *link;
2518
Tejun Heo1eca4362008-11-03 20:03:17 +09002519 ata_for_each_link(link, ap, HOST_FIRST)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002520 ata_eh_link_report(link);
2521}
2522
Tejun Heocc0680a2007-08-06 18:36:23 +09002523static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
Tejun Heob1c72912008-07-31 17:02:43 +09002524 unsigned int *classes, unsigned long deadline,
2525 bool clear_classes)
Tejun Heod87fa382006-05-31 18:28:24 +09002526{
Tejun Heof58229f2007-08-06 18:36:23 +09002527 struct ata_device *dev;
Tejun Heod87fa382006-05-31 18:28:24 +09002528
Tejun Heob1c72912008-07-31 17:02:43 +09002529 if (clear_classes)
Tejun Heo1eca4362008-11-03 20:03:17 +09002530 ata_for_each_dev(dev, link, ALL)
Tejun Heob1c72912008-07-31 17:02:43 +09002531 classes[dev->devno] = ATA_DEV_UNKNOWN;
Tejun Heod87fa382006-05-31 18:28:24 +09002532
Tejun Heof0465192008-05-19 01:15:08 +09002533 return reset(link, classes, deadline);
Tejun Heod87fa382006-05-31 18:28:24 +09002534}
2535
Sergei Shtylyove8411fb2011-08-09 23:25:50 +04002536static int ata_eh_followup_srst_needed(struct ata_link *link, int rc)
Tejun Heo664faf02006-05-31 18:27:50 +09002537{
Tejun Heo45db2f62008-04-08 01:46:56 +09002538 if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link))
Tejun Heoae791c02007-09-23 13:14:12 +09002539 return 0;
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002540 if (rc == -EAGAIN)
2541 return 1;
Tejun Heo071f44b2008-04-07 22:47:22 +09002542 if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
Tejun Heo3495de72007-09-23 13:19:53 +09002543 return 1;
Tejun Heo664faf02006-05-31 18:27:50 +09002544 return 0;
2545}
2546
Tejun Heofb7fd612007-09-23 13:14:12 +09002547int ata_eh_reset(struct ata_link *link, int classify,
2548 ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
2549 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
Tejun Heo022bdb02006-05-15 20:58:22 +09002550{
Tejun Heoafaa5c32007-10-09 15:06:10 +09002551 struct ata_port *ap = link->ap;
Tejun Heob1c72912008-07-31 17:02:43 +09002552 struct ata_link *slave = ap->slave_link;
Tejun Heo936fd732007-08-06 18:36:23 +09002553 struct ata_eh_context *ehc = &link->eh_context;
Bartlomiej Zolnierkiewicz705d2012009-07-26 16:21:01 +02002554 struct ata_eh_context *sehc = slave ? &slave->eh_context : NULL;
Tejun Heo664faf02006-05-31 18:27:50 +09002555 unsigned int *classes = ehc->classes;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002556 unsigned int lflags = link->flags;
Tejun Heo1cdaf532006-07-03 16:07:26 +09002557 int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
Tejun Heod8af0eb2008-05-20 02:17:53 +09002558 int max_tries = 0, try = 0;
Tejun Heob1c72912008-07-31 17:02:43 +09002559 struct ata_link *failed_link;
Tejun Heof58229f2007-08-06 18:36:23 +09002560 struct ata_device *dev;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002561 unsigned long deadline, now;
Tejun Heo022bdb02006-05-15 20:58:22 +09002562 ata_reset_fn_t reset;
Tejun Heoafaa5c32007-10-09 15:06:10 +09002563 unsigned long flags;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002564 u32 sstatus;
Tejun Heob1c72912008-07-31 17:02:43 +09002565 int nr_unknown, rc;
Tejun Heo022bdb02006-05-15 20:58:22 +09002566
Tejun Heo932648b2008-05-19 01:15:06 +09002567 /*
2568 * Prepare to reset
2569 */
Tejun Heod8af0eb2008-05-20 02:17:53 +09002570 while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX)
2571 max_tries++;
Tejun Heo05944bd2008-08-13 20:19:09 +09002572 if (link->flags & ATA_LFLAG_NO_HRST)
2573 hardreset = NULL;
2574 if (link->flags & ATA_LFLAG_NO_SRST)
2575 softreset = NULL;
Tejun Heod8af0eb2008-05-20 02:17:53 +09002576
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002577 /* make sure each reset attempt is at least COOL_DOWN apart */
Tejun Heo19b72322008-11-04 17:08:40 +09002578 if (ehc->i.flags & ATA_EHI_DID_RESET) {
2579 now = jiffies;
2580 WARN_ON(time_after(ehc->last_reset, now));
2581 deadline = ata_deadline(ehc->last_reset,
2582 ATA_EH_RESET_COOL_DOWN);
2583 if (time_before(now, deadline))
2584 schedule_timeout_uninterruptible(deadline - now);
2585 }
Tejun Heo0a2c0f52008-05-20 02:17:52 +09002586
Tejun Heoafaa5c32007-10-09 15:06:10 +09002587 spin_lock_irqsave(ap->lock, flags);
2588 ap->pflags |= ATA_PFLAG_RESETTING;
2589 spin_unlock_irqrestore(ap->lock, flags);
2590
Tejun Heocf480622008-01-24 00:05:14 +09002591 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
Tejun Heo13abf502006-07-10 23:18:46 +09002592
Tejun Heo1eca4362008-11-03 20:03:17 +09002593 ata_for_each_dev(dev, link, ALL) {
Tejun Heocdeab112007-10-29 16:41:09 +09002594 /* If we issue an SRST then an ATA drive (not ATAPI)
2595 * may change configuration and be in PIO0 timing. If
2596 * we do a hard reset (or are coming from power on)
2597 * this is true for ATA or ATAPI. Until we've set a
2598 * suitable controller mode we should not touch the
2599 * bus as we may be talking too fast.
2600 */
2601 dev->pio_mode = XFER_PIO_0;
2602
2603 /* If the controller has a pio mode setup function
2604 * then use it to set the chipset to rights. Don't
2605 * touch the DMA setup as that will be dealt with when
2606 * configuring devices.
2607 */
2608 if (ap->ops->set_piomode)
2609 ap->ops->set_piomode(ap, dev);
2610 }
2611
Tejun Heocf480622008-01-24 00:05:14 +09002612 /* prefer hardreset */
Tejun Heo932648b2008-05-19 01:15:06 +09002613 reset = NULL;
Tejun Heocf480622008-01-24 00:05:14 +09002614 ehc->i.action &= ~ATA_EH_RESET;
2615 if (hardreset) {
2616 reset = hardreset;
Tejun Heoa6740502008-07-31 16:07:04 +09002617 ehc->i.action |= ATA_EH_HARDRESET;
Tejun Heo4f7faa32008-01-30 18:18:26 +09002618 } else if (softreset) {
Tejun Heocf480622008-01-24 00:05:14 +09002619 reset = softreset;
Tejun Heoa6740502008-07-31 16:07:04 +09002620 ehc->i.action |= ATA_EH_SOFTRESET;
Tejun Heocf480622008-01-24 00:05:14 +09002621 }
Tejun Heof5914a42006-05-31 18:27:48 +09002622
2623 if (prereset) {
Tejun Heob1c72912008-07-31 17:02:43 +09002624 unsigned long deadline = ata_deadline(jiffies,
2625 ATA_EH_PRERESET_TIMEOUT);
2626
2627 if (slave) {
2628 sehc->i.action &= ~ATA_EH_RESET;
2629 sehc->i.action |= ehc->i.action;
2630 }
2631
2632 rc = prereset(link, deadline);
2633
2634 /* If present, do prereset on slave link too. Reset
2635 * is skipped iff both master and slave links report
2636 * -ENOENT or clear ATA_EH_RESET.
2637 */
2638 if (slave && (rc == 0 || rc == -ENOENT)) {
2639 int tmp;
2640
2641 tmp = prereset(slave, deadline);
2642 if (tmp != -ENOENT)
2643 rc = tmp;
2644
2645 ehc->i.action |= sehc->i.action;
2646 }
2647
Tejun Heof5914a42006-05-31 18:27:48 +09002648 if (rc) {
Alan Coxc9619222006-09-26 17:53:38 +01002649 if (rc == -ENOENT) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002650 ata_link_dbg(link, "port disabled--ignoring\n");
Tejun Heocf480622008-01-24 00:05:14 +09002651 ehc->i.action &= ~ATA_EH_RESET;
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002652
Tejun Heo1eca4362008-11-03 20:03:17 +09002653 ata_for_each_dev(dev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +09002654 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002655
2656 rc = 0;
Alan Coxc9619222006-09-26 17:53:38 +01002657 } else
Joe Perchesa9a79df2011-04-15 15:51:59 -07002658 ata_link_err(link,
2659 "prereset failed (errno=%d)\n",
2660 rc);
Tejun Heofccb6ea2007-07-16 14:29:41 +09002661 goto out;
Tejun Heof5914a42006-05-31 18:27:48 +09002662 }
Tejun Heof5914a42006-05-31 18:27:48 +09002663
Tejun Heo932648b2008-05-19 01:15:06 +09002664 /* prereset() might have cleared ATA_EH_RESET. If so,
Tejun Heod6515e62009-03-04 15:59:30 +09002665 * bang classes, thaw and return.
Tejun Heo932648b2008-05-19 01:15:06 +09002666 */
2667 if (reset && !(ehc->i.action & ATA_EH_RESET)) {
Tejun Heo1eca4362008-11-03 20:03:17 +09002668 ata_for_each_dev(dev, link, ALL)
Tejun Heo932648b2008-05-19 01:15:06 +09002669 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heod6515e62009-03-04 15:59:30 +09002670 if ((ap->pflags & ATA_PFLAG_FROZEN) &&
2671 ata_is_host_link(link))
2672 ata_eh_thaw_port(ap);
Tejun Heo932648b2008-05-19 01:15:06 +09002673 rc = 0;
2674 goto out;
2675 }
Tejun Heof5914a42006-05-31 18:27:48 +09002676 }
2677
Tejun Heo022bdb02006-05-15 20:58:22 +09002678 retry:
Tejun Heo932648b2008-05-19 01:15:06 +09002679 /*
2680 * Perform reset
2681 */
Tejun Heodc98c322008-05-19 01:15:07 +09002682 if (ata_is_host_link(link))
2683 ata_eh_freeze_port(ap);
2684
Tejun Heo341c2c92008-05-20 02:17:51 +09002685 deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]);
Tejun Heo31daabd2007-02-02 16:50:52 +09002686
Tejun Heo932648b2008-05-19 01:15:06 +09002687 if (reset) {
2688 if (verbose)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002689 ata_link_info(link, "%s resetting link\n",
2690 reset == softreset ? "soft" : "hard");
Tejun Heo022bdb02006-05-15 20:58:22 +09002691
Tejun Heo932648b2008-05-19 01:15:06 +09002692 /* mark that this EH session started with reset */
Tejun Heo19b72322008-11-04 17:08:40 +09002693 ehc->last_reset = jiffies;
Tejun Heo932648b2008-05-19 01:15:06 +09002694 if (reset == hardreset)
2695 ehc->i.flags |= ATA_EHI_DID_HARDRESET;
2696 else
2697 ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09002698
Tejun Heob1c72912008-07-31 17:02:43 +09002699 rc = ata_do_reset(link, reset, classes, deadline, true);
2700 if (rc && rc != -EAGAIN) {
2701 failed_link = link;
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002702 goto fail;
Tejun Heob1c72912008-07-31 17:02:43 +09002703 }
Tejun Heo022bdb02006-05-15 20:58:22 +09002704
Tejun Heob1c72912008-07-31 17:02:43 +09002705 /* hardreset slave link if existent */
2706 if (slave && reset == hardreset) {
2707 int tmp;
2708
2709 if (verbose)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002710 ata_link_info(slave, "hard resetting link\n");
Tejun Heob1c72912008-07-31 17:02:43 +09002711
2712 ata_eh_about_to_do(slave, NULL, ATA_EH_RESET);
2713 tmp = ata_do_reset(slave, reset, classes, deadline,
2714 false);
2715 switch (tmp) {
2716 case -EAGAIN:
2717 rc = -EAGAIN;
2718 case 0:
2719 break;
2720 default:
2721 failed_link = slave;
2722 rc = tmp;
2723 goto fail;
2724 }
2725 }
2726
2727 /* perform follow-up SRST if necessary */
Tejun Heo932648b2008-05-19 01:15:06 +09002728 if (reset == hardreset &&
Sergei Shtylyove8411fb2011-08-09 23:25:50 +04002729 ata_eh_followup_srst_needed(link, rc)) {
Tejun Heo932648b2008-05-19 01:15:06 +09002730 reset = softreset;
Tejun Heo664faf02006-05-31 18:27:50 +09002731
Tejun Heo932648b2008-05-19 01:15:06 +09002732 if (!reset) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002733 ata_link_err(link,
2734 "follow-up softreset required but no softreset available\n");
Tejun Heob1c72912008-07-31 17:02:43 +09002735 failed_link = link;
Tejun Heo932648b2008-05-19 01:15:06 +09002736 rc = -EINVAL;
2737 goto fail;
2738 }
2739
2740 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
Tejun Heob1c72912008-07-31 17:02:43 +09002741 rc = ata_do_reset(link, reset, classes, deadline, true);
Tejun Heofe2c4d02009-07-08 12:16:37 +09002742 if (rc) {
2743 failed_link = link;
2744 goto fail;
2745 }
Tejun Heo664faf02006-05-31 18:27:50 +09002746 }
Tejun Heo932648b2008-05-19 01:15:06 +09002747 } else {
2748 if (verbose)
Joe Perchesa9a79df2011-04-15 15:51:59 -07002749 ata_link_info(link,
2750 "no reset method available, skipping reset\n");
Tejun Heo932648b2008-05-19 01:15:06 +09002751 if (!(lflags & ATA_LFLAG_ASSUME_CLASS))
2752 lflags |= ATA_LFLAG_ASSUME_ATA;
Tejun Heo664faf02006-05-31 18:27:50 +09002753 }
2754
Tejun Heo932648b2008-05-19 01:15:06 +09002755 /*
2756 * Post-reset processing
2757 */
Tejun Heo1eca4362008-11-03 20:03:17 +09002758 ata_for_each_dev(dev, link, ALL) {
Tejun Heo416dc9e2007-10-31 10:17:03 +09002759 /* After the reset, the device state is PIO 0 and the
2760 * controller state is undefined. Reset also wakes up
2761 * drives from sleeping mode.
2762 */
2763 dev->pio_mode = XFER_PIO_0;
2764 dev->flags &= ~ATA_DFLAG_SLEEPING;
Tejun Heo664faf02006-05-31 18:27:50 +09002765
Tejun Heo3b761d32009-10-06 17:08:40 +09002766 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
2767 continue;
2768
2769 /* apply class override */
2770 if (lflags & ATA_LFLAG_ASSUME_ATA)
2771 classes[dev->devno] = ATA_DEV_ATA;
2772 else if (lflags & ATA_LFLAG_ASSUME_SEMB)
2773 classes[dev->devno] = ATA_DEV_SEMB_UNSUP;
Tejun Heo022bdb02006-05-15 20:58:22 +09002774 }
2775
Tejun Heo416dc9e2007-10-31 10:17:03 +09002776 /* record current link speed */
2777 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
2778 link->sata_spd = (sstatus >> 4) & 0xf;
Tejun Heob1c72912008-07-31 17:02:43 +09002779 if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0)
2780 slave->sata_spd = (sstatus >> 4) & 0xf;
Tejun Heo008a7892007-07-16 14:29:40 +09002781
Tejun Heodc98c322008-05-19 01:15:07 +09002782 /* thaw the port */
2783 if (ata_is_host_link(link))
2784 ata_eh_thaw_port(ap);
2785
Tejun Heof0465192008-05-19 01:15:08 +09002786 /* postreset() should clear hardware SError. Although SError
2787 * is cleared during link resume, clearing SError here is
2788 * necessary as some PHYs raise hotplug events after SRST.
2789 * This introduces race condition where hotplug occurs between
2790 * reset and here. This race is mediated by cross checking
2791 * link onlineness and classification result later.
2792 */
Tejun Heob1c72912008-07-31 17:02:43 +09002793 if (postreset) {
Tejun Heo416dc9e2007-10-31 10:17:03 +09002794 postreset(link, classes);
Tejun Heob1c72912008-07-31 17:02:43 +09002795 if (slave)
2796 postreset(slave, classes);
2797 }
Tejun Heo20952b62006-05-31 18:27:23 +09002798
Tejun Heo1e641062009-07-17 11:58:33 +09002799 /*
Tejun Heo8c56cac2011-05-25 13:19:39 +02002800 * Some controllers can't be frozen very well and may set spurious
2801 * error conditions during reset. Clear accumulated error
2802 * information and re-thaw the port if frozen. As reset is the
2803 * final recovery action and we cross check link onlineness against
2804 * device classification later, no hotplug event is lost by this.
Tejun Heo1e641062009-07-17 11:58:33 +09002805 */
Tejun Heof0465192008-05-19 01:15:08 +09002806 spin_lock_irqsave(link->ap->lock, flags);
Tejun Heo1e641062009-07-17 11:58:33 +09002807 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heob1c72912008-07-31 17:02:43 +09002808 if (slave)
Tejun Heo1e641062009-07-17 11:58:33 +09002809 memset(&slave->eh_info, 0, sizeof(link->eh_info));
2810 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heof0465192008-05-19 01:15:08 +09002811 spin_unlock_irqrestore(link->ap->lock, flags);
2812
Tejun Heo8c56cac2011-05-25 13:19:39 +02002813 if (ap->pflags & ATA_PFLAG_FROZEN)
2814 ata_eh_thaw_port(ap);
2815
Tejun Heo3b761d32009-10-06 17:08:40 +09002816 /*
2817 * Make sure onlineness and classification result correspond.
Tejun Heof0465192008-05-19 01:15:08 +09002818 * Hotplug could have happened during reset and some
2819 * controllers fail to wait while a drive is spinning up after
2820 * being hotplugged causing misdetection. By cross checking
Tejun Heo3b761d32009-10-06 17:08:40 +09002821 * link on/offlineness and classification result, those
2822 * conditions can be reliably detected and retried.
Tejun Heof0465192008-05-19 01:15:08 +09002823 */
Tejun Heob1c72912008-07-31 17:02:43 +09002824 nr_unknown = 0;
Tejun Heo1eca4362008-11-03 20:03:17 +09002825 ata_for_each_dev(dev, link, ALL) {
Tejun Heo3b761d32009-10-06 17:08:40 +09002826 if (ata_phys_link_online(ata_dev_phys_link(dev))) {
2827 if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002828 ata_dev_dbg(dev, "link online but device misclassified\n");
Tejun Heo3b761d32009-10-06 17:08:40 +09002829 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heob1c72912008-07-31 17:02:43 +09002830 nr_unknown++;
Tejun Heo3b761d32009-10-06 17:08:40 +09002831 }
2832 } else if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
2833 if (ata_class_enabled(classes[dev->devno]))
Joe Perchesa9a79df2011-04-15 15:51:59 -07002834 ata_dev_dbg(dev,
2835 "link offline, clearing class %d to NONE\n",
2836 classes[dev->devno]);
Tejun Heo3b761d32009-10-06 17:08:40 +09002837 classes[dev->devno] = ATA_DEV_NONE;
2838 } else if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002839 ata_dev_dbg(dev,
2840 "link status unknown, clearing UNKNOWN to NONE\n");
Tejun Heo3b761d32009-10-06 17:08:40 +09002841 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heob1c72912008-07-31 17:02:43 +09002842 }
Tejun Heof0465192008-05-19 01:15:08 +09002843 }
2844
Tejun Heob1c72912008-07-31 17:02:43 +09002845 if (classify && nr_unknown) {
Tejun Heof0465192008-05-19 01:15:08 +09002846 if (try < max_tries) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07002847 ata_link_warn(link,
2848 "link online but %d devices misclassified, retrying\n",
2849 nr_unknown);
Tejun Heob1c72912008-07-31 17:02:43 +09002850 failed_link = link;
Tejun Heof0465192008-05-19 01:15:08 +09002851 rc = -EAGAIN;
2852 goto fail;
2853 }
Joe Perchesa9a79df2011-04-15 15:51:59 -07002854 ata_link_warn(link,
2855 "link online but %d devices misclassified, "
2856 "device detection might fail\n", nr_unknown);
Tejun Heof0465192008-05-19 01:15:08 +09002857 }
2858
Tejun Heo416dc9e2007-10-31 10:17:03 +09002859 /* reset successful, schedule revalidation */
Tejun Heocf480622008-01-24 00:05:14 +09002860 ata_eh_done(link, NULL, ATA_EH_RESET);
Tejun Heob1c72912008-07-31 17:02:43 +09002861 if (slave)
2862 ata_eh_done(slave, NULL, ATA_EH_RESET);
Tejun Heo6b7ae952010-09-01 17:50:06 +02002863 ehc->last_reset = jiffies; /* update to completion time */
Tejun Heo416dc9e2007-10-31 10:17:03 +09002864 ehc->i.action |= ATA_EH_REVALIDATE;
Tejun Heo6b7ae952010-09-01 17:50:06 +02002865 link->lpm_policy = ATA_LPM_UNKNOWN; /* reset LPM state */
Tejun Heoae791c02007-09-23 13:14:12 +09002866
Tejun Heo416dc9e2007-10-31 10:17:03 +09002867 rc = 0;
Tejun Heofccb6ea2007-07-16 14:29:41 +09002868 out:
2869 /* clear hotplug flag */
2870 ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
Tejun Heob1c72912008-07-31 17:02:43 +09002871 if (slave)
2872 sehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
Tejun Heoafaa5c32007-10-09 15:06:10 +09002873
2874 spin_lock_irqsave(ap->lock, flags);
2875 ap->pflags &= ~ATA_PFLAG_RESETTING;
2876 spin_unlock_irqrestore(ap->lock, flags);
2877
Tejun Heo022bdb02006-05-15 20:58:22 +09002878 return rc;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002879
2880 fail:
Tejun Heo5958e302008-04-07 22:47:20 +09002881 /* if SCR isn't accessible on a fan-out port, PMP needs to be reset */
2882 if (!ata_is_host_link(link) &&
2883 sata_scr_read(link, SCR_STATUS, &sstatus))
2884 rc = -ERESTART;
2885
Gwendal Grignou7a46c072011-10-19 17:17:02 -07002886 if (try >= max_tries) {
Tejun Heo8ea76452011-05-25 12:23:56 +02002887 /*
2888 * Thaw host port even if reset failed, so that the port
2889 * can be retried on the next phy event. This risks
2890 * repeated EH runs but seems to be a better tradeoff than
2891 * shutting down a port after a botched hotplug attempt.
2892 */
2893 if (ata_is_host_link(link))
2894 ata_eh_thaw_port(ap);
Tejun Heo416dc9e2007-10-31 10:17:03 +09002895 goto out;
Tejun Heo8ea76452011-05-25 12:23:56 +02002896 }
Tejun Heo416dc9e2007-10-31 10:17:03 +09002897
2898 now = jiffies;
2899 if (time_before(now, deadline)) {
2900 unsigned long delta = deadline - now;
2901
Joe Perchesa9a79df2011-04-15 15:51:59 -07002902 ata_link_warn(failed_link,
Tejun Heo0a2c0f52008-05-20 02:17:52 +09002903 "reset failed (errno=%d), retrying in %u secs\n",
2904 rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));
Tejun Heo416dc9e2007-10-31 10:17:03 +09002905
Tejun Heoc0c362b2010-09-06 17:57:14 +02002906 ata_eh_release(ap);
Tejun Heo416dc9e2007-10-31 10:17:03 +09002907 while (delta)
2908 delta = schedule_timeout_uninterruptible(delta);
Tejun Heoc0c362b2010-09-06 17:57:14 +02002909 ata_eh_acquire(ap);
Tejun Heo416dc9e2007-10-31 10:17:03 +09002910 }
2911
Gwendal Grignou7a46c072011-10-19 17:17:02 -07002912 /*
2913 * While disks spinup behind PMP, some controllers fail sending SRST.
2914 * They need to be reset - as well as the PMP - before retrying.
2915 */
2916 if (rc == -ERESTART) {
2917 if (ata_is_host_link(link))
2918 ata_eh_thaw_port(ap);
2919 goto out;
2920 }
2921
Tejun Heob1c72912008-07-31 17:02:43 +09002922 if (try == max_tries - 1) {
Tejun Heoa07d4992009-01-29 20:31:33 +09002923 sata_down_spd_limit(link, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002924 if (slave)
Tejun Heoa07d4992009-01-29 20:31:33 +09002925 sata_down_spd_limit(slave, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002926 } else if (rc == -EPIPE)
Tejun Heoa07d4992009-01-29 20:31:33 +09002927 sata_down_spd_limit(failed_link, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002928
Tejun Heo416dc9e2007-10-31 10:17:03 +09002929 if (hardreset)
2930 reset = hardreset;
2931 goto retry;
Tejun Heo022bdb02006-05-15 20:58:22 +09002932}
2933
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02002934static inline void ata_eh_pull_park_action(struct ata_port *ap)
2935{
2936 struct ata_link *link;
2937 struct ata_device *dev;
2938 unsigned long flags;
2939
2940 /*
2941 * This function can be thought of as an extended version of
2942 * ata_eh_about_to_do() specially crafted to accommodate the
2943 * requirements of ATA_EH_PARK handling. Since the EH thread
2944 * does not leave the do {} while () loop in ata_eh_recover as
2945 * long as the timeout for a park request to *one* device on
2946 * the port has not expired, and since we still want to pick
2947 * up park requests to other devices on the same port or
2948 * timeout updates for the same device, we have to pull
2949 * ATA_EH_PARK actions from eh_info into eh_context.i
2950 * ourselves at the beginning of each pass over the loop.
2951 *
2952 * Additionally, all write accesses to &ap->park_req_pending
2953 * through INIT_COMPLETION() (see below) or complete_all()
2954 * (see ata_scsi_park_store()) are protected by the host lock.
2955 * As a result we have that park_req_pending.done is zero on
2956 * exit from this function, i.e. when ATA_EH_PARK actions for
2957 * *all* devices on port ap have been pulled into the
2958 * respective eh_context structs. If, and only if,
2959 * park_req_pending.done is non-zero by the time we reach
2960 * wait_for_completion_timeout(), another ATA_EH_PARK action
2961 * has been scheduled for at least one of the devices on port
2962 * ap and we have to cycle over the do {} while () loop in
2963 * ata_eh_recover() again.
2964 */
2965
2966 spin_lock_irqsave(ap->lock, flags);
2967 INIT_COMPLETION(ap->park_req_pending);
Tejun Heo1eca4362008-11-03 20:03:17 +09002968 ata_for_each_link(link, ap, EDGE) {
2969 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02002970 struct ata_eh_info *ehi = &link->eh_info;
2971
2972 link->eh_context.i.dev_action[dev->devno] |=
2973 ehi->dev_action[dev->devno] & ATA_EH_PARK;
2974 ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK);
2975 }
2976 }
2977 spin_unlock_irqrestore(ap->lock, flags);
2978}
2979
2980static void ata_eh_park_issue_cmd(struct ata_device *dev, int park)
2981{
2982 struct ata_eh_context *ehc = &dev->link->eh_context;
2983 struct ata_taskfile tf;
2984 unsigned int err_mask;
2985
2986 ata_tf_init(dev, &tf);
2987 if (park) {
2988 ehc->unloaded_mask |= 1 << dev->devno;
2989 tf.command = ATA_CMD_IDLEIMMEDIATE;
2990 tf.feature = 0x44;
2991 tf.lbal = 0x4c;
2992 tf.lbam = 0x4e;
2993 tf.lbah = 0x55;
2994 } else {
2995 ehc->unloaded_mask &= ~(1 << dev->devno);
2996 tf.command = ATA_CMD_CHK_POWER;
2997 }
2998
2999 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
3000 tf.protocol |= ATA_PROT_NODATA;
3001 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
3002 if (park && (err_mask || tf.lbal != 0xc4)) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07003003 ata_dev_err(dev, "head unload failed!\n");
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003004 ehc->unloaded_mask &= ~(1 << dev->devno);
3005 }
3006}
3007
Tejun Heo02607312007-08-06 18:36:23 +09003008static int ata_eh_revalidate_and_attach(struct ata_link *link,
Tejun Heo084fe632006-05-31 18:28:03 +09003009 struct ata_device **r_failed_dev)
Tejun Heo022bdb02006-05-15 20:58:22 +09003010{
Tejun Heo02607312007-08-06 18:36:23 +09003011 struct ata_port *ap = link->ap;
3012 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003013 struct ata_device *dev;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003014 unsigned int new_mask = 0;
Tejun Heo084fe632006-05-31 18:28:03 +09003015 unsigned long flags;
Tejun Heof58229f2007-08-06 18:36:23 +09003016 int rc = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003017
3018 DPRINTK("ENTER\n");
3019
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003020 /* For PATA drive side cable detection to work, IDENTIFY must
3021 * be done backwards such that PDIAG- is released by the slave
3022 * device before the master device is identified.
3023 */
Tejun Heo1eca4362008-11-03 20:03:17 +09003024 ata_for_each_dev(dev, link, ALL_REVERSE) {
Tejun Heof58229f2007-08-06 18:36:23 +09003025 unsigned int action = ata_eh_dev_action(dev);
3026 unsigned int readid_flags = 0;
Tejun Heo47005f22006-06-19 18:27:23 +09003027
Tejun Heobff04642006-11-10 18:08:10 +09003028 if (ehc->i.flags & ATA_EHI_DID_RESET)
3029 readid_flags |= ATA_READID_POSTRESET;
3030
Tejun Heo9666f402007-05-04 21:27:47 +02003031 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
Tejun Heo633273a2007-09-23 13:19:54 +09003032 WARN_ON(dev->class == ATA_DEV_PMP);
3033
Tejun Heob1c72912008-07-31 17:02:43 +09003034 if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
Tejun Heo022bdb02006-05-15 20:58:22 +09003035 rc = -EIO;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003036 goto err;
Tejun Heo022bdb02006-05-15 20:58:22 +09003037 }
3038
Tejun Heo02607312007-08-06 18:36:23 +09003039 ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
Tejun Heo422c9da2007-09-23 13:14:12 +09003040 rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
3041 readid_flags);
Tejun Heo022bdb02006-05-15 20:58:22 +09003042 if (rc)
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003043 goto err;
Tejun Heo022bdb02006-05-15 20:58:22 +09003044
Tejun Heo02607312007-08-06 18:36:23 +09003045 ata_eh_done(link, dev, ATA_EH_REVALIDATE);
Tejun Heo47005f22006-06-19 18:27:23 +09003046
Tejun Heobaa1e782006-11-01 18:39:27 +09003047 /* Configuration may have changed, reconfigure
3048 * transfer mode.
3049 */
3050 ehc->i.flags |= ATA_EHI_SETMODE;
3051
zhao, forrest3057ac32006-06-12 12:01:34 +08003052 /* schedule the scsi_rescan_device() here */
Tejun Heoad72cf92010-07-02 10:03:52 +02003053 schedule_work(&(ap->scsi_rescan_task));
Tejun Heo084fe632006-05-31 18:28:03 +09003054 } else if (dev->class == ATA_DEV_UNKNOWN &&
3055 ehc->tries[dev->devno] &&
3056 ata_class_enabled(ehc->classes[dev->devno])) {
Tejun Heo842faa62009-05-10 01:06:54 +09003057 /* Temporarily set dev->class, it will be
3058 * permanently set once all configurations are
3059 * complete. This is necessary because new
3060 * device configuration is done in two
3061 * separate loops.
3062 */
Tejun Heo084fe632006-05-31 18:28:03 +09003063 dev->class = ehc->classes[dev->devno];
3064
Tejun Heo633273a2007-09-23 13:19:54 +09003065 if (dev->class == ATA_DEV_PMP)
3066 rc = sata_pmp_attach(dev);
3067 else
3068 rc = ata_dev_read_id(dev, &dev->class,
3069 readid_flags, dev->id);
Tejun Heo842faa62009-05-10 01:06:54 +09003070
3071 /* read_id might have changed class, store and reset */
3072 ehc->classes[dev->devno] = dev->class;
3073 dev->class = ATA_DEV_UNKNOWN;
3074
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003075 switch (rc) {
3076 case 0:
Tejun Heo99cf6102009-01-29 20:31:32 +09003077 /* clear error info accumulated during probe */
3078 ata_ering_clear(&dev->ering);
Tejun Heof58229f2007-08-06 18:36:23 +09003079 new_mask |= 1 << dev->devno;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003080 break;
3081 case -ENOENT:
Tejun Heo55a8e2c2006-11-10 18:08:10 +09003082 /* IDENTIFY was issued to non-existent
3083 * device. No need to reset. Just
Tejun Heo842faa62009-05-10 01:06:54 +09003084 * thaw and ignore the device.
Tejun Heo55a8e2c2006-11-10 18:08:10 +09003085 */
3086 ata_eh_thaw_port(ap);
Tejun Heo084fe632006-05-31 18:28:03 +09003087 break;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003088 default:
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003089 goto err;
Tejun Heo55a8e2c2006-11-10 18:08:10 +09003090 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003091 }
3092 }
3093
Tejun Heoc1c4e8d2007-04-23 02:05:53 +09003094 /* PDIAG- should have been released, ask cable type if post-reset */
Tejun Heo33267322008-02-13 09:15:09 +09003095 if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) {
3096 if (ap->ops->cable_detect)
3097 ap->cbl = ap->ops->cable_detect(ap);
3098 ata_force_cbl(ap);
3099 }
Tejun Heoc1c4e8d2007-04-23 02:05:53 +09003100
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003101 /* Configure new devices forward such that user doesn't see
3102 * device detection messages backwards.
3103 */
Tejun Heo1eca4362008-11-03 20:03:17 +09003104 ata_for_each_dev(dev, link, ALL) {
Tejun Heo4f7c2872009-10-15 23:37:32 +09003105 if (!(new_mask & (1 << dev->devno)))
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003106 continue;
3107
Tejun Heo842faa62009-05-10 01:06:54 +09003108 dev->class = ehc->classes[dev->devno];
3109
Tejun Heo4f7c2872009-10-15 23:37:32 +09003110 if (dev->class == ATA_DEV_PMP)
3111 continue;
3112
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003113 ehc->i.flags |= ATA_EHI_PRINTINFO;
3114 rc = ata_dev_configure(dev);
3115 ehc->i.flags &= ~ATA_EHI_PRINTINFO;
Tejun Heo842faa62009-05-10 01:06:54 +09003116 if (rc) {
3117 dev->class = ATA_DEV_UNKNOWN;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003118 goto err;
Tejun Heo842faa62009-05-10 01:06:54 +09003119 }
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003120
3121 spin_lock_irqsave(ap->lock, flags);
3122 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
3123 spin_unlock_irqrestore(ap->lock, flags);
3124
3125 /* new device discovered, configure xfermode */
3126 ehc->i.flags |= ATA_EHI_SETMODE;
3127 }
3128
3129 return 0;
3130
3131 err:
3132 *r_failed_dev = dev;
3133 DPRINTK("EXIT rc=%d\n", rc);
Tejun Heo022bdb02006-05-15 20:58:22 +09003134 return rc;
3135}
3136
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003137/**
3138 * ata_set_mode - Program timings and issue SET FEATURES - XFER
3139 * @link: link on which timings will be programmed
Martin Olsson98a17082009-04-22 18:21:29 +02003140 * @r_failed_dev: out parameter for failed device
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003141 *
3142 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If
3143 * ata_set_mode() fails, pointer to the failing device is
3144 * returned in @r_failed_dev.
3145 *
3146 * LOCKING:
3147 * PCI/etc. bus probe sem.
3148 *
3149 * RETURNS:
3150 * 0 on success, negative errno otherwise
3151 */
3152int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3153{
3154 struct ata_port *ap = link->ap;
Tejun Heo00115e02007-11-27 19:28:58 +09003155 struct ata_device *dev;
3156 int rc;
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003157
Tejun Heo76326ac2007-11-27 19:28:59 +09003158 /* if data transfer is verified, clear DUBIOUS_XFER on ering top */
Tejun Heo1eca4362008-11-03 20:03:17 +09003159 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo76326ac2007-11-27 19:28:59 +09003160 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) {
3161 struct ata_ering_entry *ent;
3162
3163 ent = ata_ering_top(&dev->ering);
3164 if (ent)
3165 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER;
3166 }
3167 }
3168
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003169 /* has private set_mode? */
3170 if (ap->ops->set_mode)
Tejun Heo00115e02007-11-27 19:28:58 +09003171 rc = ap->ops->set_mode(link, r_failed_dev);
3172 else
3173 rc = ata_do_set_mode(link, r_failed_dev);
3174
3175 /* if transfer mode has changed, set DUBIOUS_XFER on device */
Tejun Heo1eca4362008-11-03 20:03:17 +09003176 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo00115e02007-11-27 19:28:58 +09003177 struct ata_eh_context *ehc = &link->eh_context;
3178 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno];
3179 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno));
3180
3181 if (dev->xfer_mode != saved_xfer_mode ||
3182 ata_ncq_enabled(dev) != saved_ncq)
3183 dev->flags |= ATA_DFLAG_DUBIOUS_XFER;
3184 }
3185
3186 return rc;
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003187}
3188
Tejun Heo11fc33d2008-08-30 14:20:01 +02003189/**
3190 * atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset
3191 * @dev: ATAPI device to clear UA for
3192 *
3193 * Resets and other operations can make an ATAPI device raise
3194 * UNIT ATTENTION which causes the next operation to fail. This
3195 * function clears UA.
3196 *
3197 * LOCKING:
3198 * EH context (may sleep).
3199 *
3200 * RETURNS:
3201 * 0 on success, -errno on failure.
3202 */
3203static int atapi_eh_clear_ua(struct ata_device *dev)
3204{
3205 int i;
3206
3207 for (i = 0; i < ATA_EH_UA_TRIES; i++) {
Tejun Heob5357082009-03-02 18:55:16 +09003208 u8 *sense_buffer = dev->link->ap->sector_buf;
Tejun Heo11fc33d2008-08-30 14:20:01 +02003209 u8 sense_key = 0;
3210 unsigned int err_mask;
3211
3212 err_mask = atapi_eh_tur(dev, &sense_key);
3213 if (err_mask != 0 && err_mask != AC_ERR_DEV) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07003214 ata_dev_warn(dev,
3215 "TEST_UNIT_READY failed (err_mask=0x%x)\n",
3216 err_mask);
Tejun Heo11fc33d2008-08-30 14:20:01 +02003217 return -EIO;
3218 }
3219
3220 if (!err_mask || sense_key != UNIT_ATTENTION)
3221 return 0;
3222
3223 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key);
3224 if (err_mask) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07003225 ata_dev_warn(dev, "failed to clear "
Tejun Heo11fc33d2008-08-30 14:20:01 +02003226 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask);
3227 return -EIO;
3228 }
3229 }
3230
Joe Perchesa9a79df2011-04-15 15:51:59 -07003231 ata_dev_warn(dev, "UNIT ATTENTION persists after %d tries\n",
3232 ATA_EH_UA_TRIES);
Tejun Heo11fc33d2008-08-30 14:20:01 +02003233
3234 return 0;
3235}
3236
Tejun Heo6013efd2009-11-19 15:36:45 +09003237/**
3238 * ata_eh_maybe_retry_flush - Retry FLUSH if necessary
3239 * @dev: ATA device which may need FLUSH retry
3240 *
3241 * If @dev failed FLUSH, it needs to be reported upper layer
3242 * immediately as it means that @dev failed to remap and already
3243 * lost at least a sector and further FLUSH retrials won't make
3244 * any difference to the lost sector. However, if FLUSH failed
3245 * for other reasons, for example transmission error, FLUSH needs
3246 * to be retried.
3247 *
3248 * This function determines whether FLUSH failure retry is
3249 * necessary and performs it if so.
3250 *
3251 * RETURNS:
3252 * 0 if EH can continue, -errno if EH needs to be repeated.
3253 */
3254static int ata_eh_maybe_retry_flush(struct ata_device *dev)
3255{
3256 struct ata_link *link = dev->link;
3257 struct ata_port *ap = link->ap;
3258 struct ata_queued_cmd *qc;
3259 struct ata_taskfile tf;
3260 unsigned int err_mask;
3261 int rc = 0;
3262
3263 /* did flush fail for this device? */
3264 if (!ata_tag_valid(link->active_tag))
3265 return 0;
3266
3267 qc = __ata_qc_from_tag(ap, link->active_tag);
3268 if (qc->dev != dev || (qc->tf.command != ATA_CMD_FLUSH_EXT &&
3269 qc->tf.command != ATA_CMD_FLUSH))
3270 return 0;
3271
3272 /* if the device failed it, it should be reported to upper layers */
3273 if (qc->err_mask & AC_ERR_DEV)
3274 return 0;
3275
3276 /* flush failed for some other reason, give it another shot */
3277 ata_tf_init(dev, &tf);
3278
3279 tf.command = qc->tf.command;
3280 tf.flags |= ATA_TFLAG_DEVICE;
3281 tf.protocol = ATA_PROT_NODATA;
3282
Joe Perchesa9a79df2011-04-15 15:51:59 -07003283 ata_dev_warn(dev, "retrying FLUSH 0x%x Emask 0x%x\n",
Tejun Heo6013efd2009-11-19 15:36:45 +09003284 tf.command, qc->err_mask);
3285
3286 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
3287 if (!err_mask) {
3288 /*
3289 * FLUSH is complete but there's no way to
3290 * successfully complete a failed command from EH.
3291 * Making sure retry is allowed at least once and
3292 * retrying it should do the trick - whatever was in
3293 * the cache is already on the platter and this won't
3294 * cause infinite loop.
3295 */
3296 qc->scsicmd->allowed = max(qc->scsicmd->allowed, 1);
3297 } else {
Joe Perchesa9a79df2011-04-15 15:51:59 -07003298 ata_dev_warn(dev, "FLUSH failed Emask 0x%x\n",
Tejun Heo6013efd2009-11-19 15:36:45 +09003299 err_mask);
3300 rc = -EIO;
3301
3302 /* if device failed it, report it to upper layers */
3303 if (err_mask & AC_ERR_DEV) {
3304 qc->err_mask |= AC_ERR_DEV;
3305 qc->result_tf = tf;
3306 if (!(ap->pflags & ATA_PFLAG_FROZEN))
3307 rc = 0;
3308 }
3309 }
3310 return rc;
3311}
3312
Tejun Heo6b7ae952010-09-01 17:50:06 +02003313/**
3314 * ata_eh_set_lpm - configure SATA interface power management
3315 * @link: link to configure power management
3316 * @policy: the link power management policy
3317 * @r_failed_dev: out parameter for failed device
3318 *
3319 * Enable SATA Interface power management. This will enable
3320 * Device Interface Power Management (DIPM) for min_power
3321 * policy, and then call driver specific callbacks for
3322 * enabling Host Initiated Power management.
3323 *
3324 * LOCKING:
3325 * EH context.
3326 *
3327 * RETURNS:
3328 * 0 on success, -errno on failure.
3329 */
3330static int ata_eh_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
3331 struct ata_device **r_failed_dev)
3332{
Tejun Heo6c8ea892010-09-01 17:50:07 +02003333 struct ata_port *ap = ata_is_host_link(link) ? link->ap : NULL;
Tejun Heo6b7ae952010-09-01 17:50:06 +02003334 struct ata_eh_context *ehc = &link->eh_context;
3335 struct ata_device *dev, *link_dev = NULL, *lpm_dev = NULL;
Tejun Heoe5005b12010-12-09 16:13:15 +01003336 enum ata_lpm_policy old_policy = link->lpm_policy;
Tejun Heo5f6f12c2011-05-09 16:04:11 +02003337 bool no_dipm = link->ap->flags & ATA_FLAG_NO_DIPM;
Tejun Heo6b7ae952010-09-01 17:50:06 +02003338 unsigned int hints = ATA_LPM_EMPTY | ATA_LPM_HIPM;
3339 unsigned int err_mask;
3340 int rc;
3341
3342 /* if the link or host doesn't do LPM, noop */
3343 if ((link->flags & ATA_LFLAG_NO_LPM) || (ap && !ap->ops->set_lpm))
3344 return 0;
3345
3346 /*
3347 * DIPM is enabled only for MIN_POWER as some devices
3348 * misbehave when the host NACKs transition to SLUMBER. Order
3349 * device and link configurations such that the host always
3350 * allows DIPM requests.
3351 */
3352 ata_for_each_dev(dev, link, ENABLED) {
3353 bool hipm = ata_id_has_hipm(dev->id);
Tejun Heoae01b242011-03-16 11:14:55 +01003354 bool dipm = ata_id_has_dipm(dev->id) && !no_dipm;
Tejun Heo6b7ae952010-09-01 17:50:06 +02003355
3356 /* find the first enabled and LPM enabled devices */
3357 if (!link_dev)
3358 link_dev = dev;
3359
3360 if (!lpm_dev && (hipm || dipm))
3361 lpm_dev = dev;
3362
3363 hints &= ~ATA_LPM_EMPTY;
3364 if (!hipm)
3365 hints &= ~ATA_LPM_HIPM;
3366
3367 /* disable DIPM before changing link config */
3368 if (policy != ATA_LPM_MIN_POWER && dipm) {
3369 err_mask = ata_dev_set_feature(dev,
3370 SETFEATURES_SATA_DISABLE, SATA_DIPM);
3371 if (err_mask && err_mask != AC_ERR_DEV) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07003372 ata_dev_warn(dev,
3373 "failed to disable DIPM, Emask 0x%x\n",
3374 err_mask);
Tejun Heo6b7ae952010-09-01 17:50:06 +02003375 rc = -EIO;
3376 goto fail;
3377 }
3378 }
3379 }
3380
Tejun Heo6c8ea892010-09-01 17:50:07 +02003381 if (ap) {
3382 rc = ap->ops->set_lpm(link, policy, hints);
3383 if (!rc && ap->slave_link)
3384 rc = ap->ops->set_lpm(ap->slave_link, policy, hints);
3385 } else
3386 rc = sata_pmp_set_lpm(link, policy, hints);
Tejun Heo6b7ae952010-09-01 17:50:06 +02003387
3388 /*
3389 * Attribute link config failure to the first (LPM) enabled
3390 * device on the link.
3391 */
3392 if (rc) {
3393 if (rc == -EOPNOTSUPP) {
3394 link->flags |= ATA_LFLAG_NO_LPM;
3395 return 0;
3396 }
3397 dev = lpm_dev ? lpm_dev : link_dev;
3398 goto fail;
3399 }
3400
Tejun Heoe5005b12010-12-09 16:13:15 +01003401 /*
3402 * Low level driver acked the transition. Issue DIPM command
3403 * with the new policy set.
3404 */
3405 link->lpm_policy = policy;
3406 if (ap && ap->slave_link)
3407 ap->slave_link->lpm_policy = policy;
3408
Tejun Heo6b7ae952010-09-01 17:50:06 +02003409 /* host config updated, enable DIPM if transitioning to MIN_POWER */
3410 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heoae01b242011-03-16 11:14:55 +01003411 if (policy == ATA_LPM_MIN_POWER && !no_dipm &&
3412 ata_id_has_dipm(dev->id)) {
Tejun Heo6b7ae952010-09-01 17:50:06 +02003413 err_mask = ata_dev_set_feature(dev,
3414 SETFEATURES_SATA_ENABLE, SATA_DIPM);
3415 if (err_mask && err_mask != AC_ERR_DEV) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07003416 ata_dev_warn(dev,
Tejun Heo6b7ae952010-09-01 17:50:06 +02003417 "failed to enable DIPM, Emask 0x%x\n",
3418 err_mask);
3419 rc = -EIO;
3420 goto fail;
3421 }
3422 }
3423 }
3424
Tejun Heo6b7ae952010-09-01 17:50:06 +02003425 return 0;
3426
3427fail:
Tejun Heoe5005b12010-12-09 16:13:15 +01003428 /* restore the old policy */
3429 link->lpm_policy = old_policy;
3430 if (ap && ap->slave_link)
3431 ap->slave_link->lpm_policy = old_policy;
3432
Tejun Heo6b7ae952010-09-01 17:50:06 +02003433 /* if no device or only one more chance is left, disable LPM */
3434 if (!dev || ehc->tries[dev->devno] <= 2) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07003435 ata_link_warn(link, "disabling LPM on the link\n");
Tejun Heo6b7ae952010-09-01 17:50:06 +02003436 link->flags |= ATA_LFLAG_NO_LPM;
3437 }
3438 if (r_failed_dev)
3439 *r_failed_dev = dev;
3440 return rc;
3441}
3442
Kristen Carlson Accardi8a745f12011-03-04 10:24:11 -08003443int ata_link_nr_enabled(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09003444{
Tejun Heof58229f2007-08-06 18:36:23 +09003445 struct ata_device *dev;
3446 int cnt = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003447
Tejun Heo1eca4362008-11-03 20:03:17 +09003448 ata_for_each_dev(dev, link, ENABLED)
3449 cnt++;
Tejun Heo022bdb02006-05-15 20:58:22 +09003450 return cnt;
3451}
3452
Tejun Heo02607312007-08-06 18:36:23 +09003453static int ata_link_nr_vacant(struct ata_link *link)
Tejun Heo084fe632006-05-31 18:28:03 +09003454{
Tejun Heof58229f2007-08-06 18:36:23 +09003455 struct ata_device *dev;
3456 int cnt = 0;
Tejun Heo084fe632006-05-31 18:28:03 +09003457
Tejun Heo1eca4362008-11-03 20:03:17 +09003458 ata_for_each_dev(dev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +09003459 if (dev->class == ATA_DEV_UNKNOWN)
Tejun Heo084fe632006-05-31 18:28:03 +09003460 cnt++;
3461 return cnt;
3462}
3463
Tejun Heo02607312007-08-06 18:36:23 +09003464static int ata_eh_skip_recovery(struct ata_link *link)
Tejun Heo084fe632006-05-31 18:28:03 +09003465{
Tejun Heo672b2d62008-01-24 00:05:14 +09003466 struct ata_port *ap = link->ap;
Tejun Heo02607312007-08-06 18:36:23 +09003467 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heof58229f2007-08-06 18:36:23 +09003468 struct ata_device *dev;
Tejun Heo084fe632006-05-31 18:28:03 +09003469
Tejun Heof9df58c2007-09-23 13:14:13 +09003470 /* skip disabled links */
3471 if (link->flags & ATA_LFLAG_DISABLED)
3472 return 1;
3473
Tejun Heoe2f3d752010-09-07 14:05:31 +02003474 /* skip if explicitly requested */
3475 if (ehc->i.flags & ATA_EHI_NO_RECOVERY)
3476 return 1;
3477
Tejun Heo672b2d62008-01-24 00:05:14 +09003478 /* thaw frozen port and recover failed devices */
3479 if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link))
3480 return 0;
3481
3482 /* reset at least once if reset is requested */
3483 if ((ehc->i.action & ATA_EH_RESET) &&
3484 !(ehc->i.flags & ATA_EHI_DID_RESET))
Tejun Heo084fe632006-05-31 18:28:03 +09003485 return 0;
3486
3487 /* skip if class codes for all vacant slots are ATA_DEV_NONE */
Tejun Heo1eca4362008-11-03 20:03:17 +09003488 ata_for_each_dev(dev, link, ALL) {
Tejun Heo084fe632006-05-31 18:28:03 +09003489 if (dev->class == ATA_DEV_UNKNOWN &&
3490 ehc->classes[dev->devno] != ATA_DEV_NONE)
3491 return 0;
3492 }
3493
3494 return 1;
3495}
3496
Tejun Heoc2c7a892009-01-29 20:31:34 +09003497static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg)
3498{
3499 u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL);
3500 u64 now = get_jiffies_64();
3501 int *trials = void_arg;
3502
3503 if (ent->timestamp < now - min(now, interval))
3504 return -1;
3505
3506 (*trials)++;
3507 return 0;
3508}
3509
Tejun Heo02c05a22007-11-27 19:28:54 +09003510static int ata_eh_schedule_probe(struct ata_device *dev)
3511{
3512 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heoc2c7a892009-01-29 20:31:34 +09003513 struct ata_link *link = ata_dev_phys_link(dev);
3514 int trials = 0;
Tejun Heo02c05a22007-11-27 19:28:54 +09003515
3516 if (!(ehc->i.probe_mask & (1 << dev->devno)) ||
3517 (ehc->did_probe_mask & (1 << dev->devno)))
3518 return 0;
3519
3520 ata_eh_detach_dev(dev);
3521 ata_dev_init(dev);
3522 ehc->did_probe_mask |= (1 << dev->devno);
Tejun Heocf480622008-01-24 00:05:14 +09003523 ehc->i.action |= ATA_EH_RESET;
Tejun Heo00115e02007-11-27 19:28:58 +09003524 ehc->saved_xfer_mode[dev->devno] = 0;
3525 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
Tejun Heo02c05a22007-11-27 19:28:54 +09003526
Tejun Heo6b7ae952010-09-01 17:50:06 +02003527 /* the link maybe in a deep sleep, wake it up */
Tejun Heo6c8ea892010-09-01 17:50:07 +02003528 if (link->lpm_policy > ATA_LPM_MAX_POWER) {
3529 if (ata_is_host_link(link))
3530 link->ap->ops->set_lpm(link, ATA_LPM_MAX_POWER,
3531 ATA_LPM_EMPTY);
3532 else
3533 sata_pmp_set_lpm(link, ATA_LPM_MAX_POWER,
3534 ATA_LPM_EMPTY);
3535 }
Tejun Heo6b7ae952010-09-01 17:50:06 +02003536
Tejun Heoc2c7a892009-01-29 20:31:34 +09003537 /* Record and count probe trials on the ering. The specific
3538 * error mask used is irrelevant. Because a successful device
3539 * detection clears the ering, this count accumulates only if
3540 * there are consecutive failed probes.
3541 *
3542 * If the count is equal to or higher than ATA_EH_PROBE_TRIALS
3543 * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is
3544 * forced to 1.5Gbps.
3545 *
3546 * This is to work around cases where failed link speed
3547 * negotiation results in device misdetection leading to
3548 * infinite DEVXCHG or PHRDY CHG events.
3549 */
3550 ata_ering_record(&dev->ering, 0, AC_ERR_OTHER);
3551 ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials);
3552
3553 if (trials > ATA_EH_PROBE_TRIALS)
3554 sata_down_spd_limit(link, 1);
3555
Tejun Heo02c05a22007-11-27 19:28:54 +09003556 return 1;
3557}
3558
Tejun Heo9b1e2652007-08-06 18:36:24 +09003559static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
Tejun Heofee7ca72007-07-01 19:05:58 +09003560{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09003561 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heofee7ca72007-07-01 19:05:58 +09003562
Tejun Heocf9a5902009-01-29 20:31:35 +09003563 /* -EAGAIN from EH routine indicates retry without prejudice.
3564 * The requester is responsible for ensuring forward progress.
3565 */
3566 if (err != -EAGAIN)
3567 ehc->tries[dev->devno]--;
Tejun Heofee7ca72007-07-01 19:05:58 +09003568
3569 switch (err) {
3570 case -ENODEV:
3571 /* device missing or wrong IDENTIFY data, schedule probing */
3572 ehc->i.probe_mask |= (1 << dev->devno);
3573 case -EINVAL:
3574 /* give it just one more chance */
3575 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
3576 case -EIO:
Tejun Heod89293a2009-01-29 20:31:29 +09003577 if (ehc->tries[dev->devno] == 1) {
Tejun Heofee7ca72007-07-01 19:05:58 +09003578 /* This is the last chance, better to slow
3579 * down than lose it.
3580 */
Tejun Heoa07d4992009-01-29 20:31:33 +09003581 sata_down_spd_limit(ata_dev_phys_link(dev), 0);
Tejun Heod89293a2009-01-29 20:31:29 +09003582 if (dev->pio_mode > XFER_PIO_0)
3583 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
Tejun Heofee7ca72007-07-01 19:05:58 +09003584 }
3585 }
3586
3587 if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
3588 /* disable device if it has used up all its chances */
3589 ata_dev_disable(dev);
3590
3591 /* detach if offline */
Tejun Heob1c72912008-07-31 17:02:43 +09003592 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
Tejun Heofee7ca72007-07-01 19:05:58 +09003593 ata_eh_detach_dev(dev);
3594
Tejun Heo02c05a22007-11-27 19:28:54 +09003595 /* schedule probe if necessary */
Tejun Heo87fbc5a2008-05-20 02:17:54 +09003596 if (ata_eh_schedule_probe(dev)) {
Tejun Heofee7ca72007-07-01 19:05:58 +09003597 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
Tejun Heo87fbc5a2008-05-20 02:17:54 +09003598 memset(ehc->cmd_timeout_idx[dev->devno], 0,
3599 sizeof(ehc->cmd_timeout_idx[dev->devno]));
3600 }
Tejun Heo9b1e2652007-08-06 18:36:24 +09003601
3602 return 1;
Tejun Heofee7ca72007-07-01 19:05:58 +09003603 } else {
Tejun Heocf480622008-01-24 00:05:14 +09003604 ehc->i.action |= ATA_EH_RESET;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003605 return 0;
Tejun Heofee7ca72007-07-01 19:05:58 +09003606 }
3607}
3608
Tejun Heo022bdb02006-05-15 20:58:22 +09003609/**
3610 * ata_eh_recover - recover host port after error
3611 * @ap: host port to recover
Tejun Heof5914a42006-05-31 18:27:48 +09003612 * @prereset: prereset method (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09003613 * @softreset: softreset method (can be NULL)
3614 * @hardreset: hardreset method (can be NULL)
3615 * @postreset: postreset method (can be NULL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003616 * @r_failed_link: out parameter for failed link
Tejun Heo022bdb02006-05-15 20:58:22 +09003617 *
3618 * This is the alpha and omega, eum and yang, heart and soul of
3619 * libata exception handling. On entry, actions required to
Tejun Heo9b1e2652007-08-06 18:36:24 +09003620 * recover each link and hotplug requests are recorded in the
3621 * link's eh_context. This function executes all the operations
3622 * with appropriate retrials and fallbacks to resurrect failed
Tejun Heo084fe632006-05-31 18:28:03 +09003623 * devices, detach goners and greet newcomers.
Tejun Heo022bdb02006-05-15 20:58:22 +09003624 *
3625 * LOCKING:
3626 * Kernel thread context (may sleep).
3627 *
3628 * RETURNS:
3629 * 0 on success, -errno on failure.
3630 */
Tejun Heofb7fd612007-09-23 13:14:12 +09003631int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
3632 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3633 ata_postreset_fn_t postreset,
3634 struct ata_link **r_failed_link)
Tejun Heo022bdb02006-05-15 20:58:22 +09003635{
Tejun Heo9b1e2652007-08-06 18:36:24 +09003636 struct ata_link *link;
Tejun Heo022bdb02006-05-15 20:58:22 +09003637 struct ata_device *dev;
Tejun Heo6b7ae952010-09-01 17:50:06 +02003638 int rc, nr_fails;
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003639 unsigned long flags, deadline;
Tejun Heo022bdb02006-05-15 20:58:22 +09003640
3641 DPRINTK("ENTER\n");
3642
3643 /* prep for recovery */
Tejun Heo1eca4362008-11-03 20:03:17 +09003644 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003645 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo084fe632006-05-31 18:28:03 +09003646
Tejun Heof9df58c2007-09-23 13:14:13 +09003647 /* re-enable link? */
3648 if (ehc->i.action & ATA_EH_ENABLE_LINK) {
3649 ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
3650 spin_lock_irqsave(ap->lock, flags);
3651 link->flags &= ~ATA_LFLAG_DISABLED;
3652 spin_unlock_irqrestore(ap->lock, flags);
3653 ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
3654 }
3655
Tejun Heo1eca4362008-11-03 20:03:17 +09003656 ata_for_each_dev(dev, link, ALL) {
Tejun Heofd995f72007-09-23 13:14:12 +09003657 if (link->flags & ATA_LFLAG_NO_RETRY)
3658 ehc->tries[dev->devno] = 1;
3659 else
3660 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
Tejun Heo79a55b72007-01-18 17:22:18 +09003661
Tejun Heo9b1e2652007-08-06 18:36:24 +09003662 /* collect port action mask recorded in dev actions */
3663 ehc->i.action |= ehc->i.dev_action[dev->devno] &
3664 ~ATA_EH_PERDEV_MASK;
3665 ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
Tejun Heo084fe632006-05-31 18:28:03 +09003666
Tejun Heo9b1e2652007-08-06 18:36:24 +09003667 /* process hotplug request */
3668 if (dev->flags & ATA_DFLAG_DETACH)
3669 ata_eh_detach_dev(dev);
3670
Tejun Heo02c05a22007-11-27 19:28:54 +09003671 /* schedule probe if necessary */
3672 if (!ata_dev_enabled(dev))
3673 ata_eh_schedule_probe(dev);
Tejun Heo084fe632006-05-31 18:28:03 +09003674 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003675 }
3676
3677 retry:
Tejun Heo022bdb02006-05-15 20:58:22 +09003678 rc = 0;
3679
Tejun Heoaeb2ecd2006-06-12 14:11:43 +09003680 /* if UNLOADING, finish immediately */
Tejun Heob51e9e52006-06-29 01:29:30 +09003681 if (ap->pflags & ATA_PFLAG_UNLOADING)
Tejun Heoaeb2ecd2006-06-12 14:11:43 +09003682 goto out;
3683
Tejun Heo9b1e2652007-08-06 18:36:24 +09003684 /* prep for EH */
Tejun Heo1eca4362008-11-03 20:03:17 +09003685 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003686 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003687
Tejun Heo9b1e2652007-08-06 18:36:24 +09003688 /* skip EH if possible. */
3689 if (ata_eh_skip_recovery(link))
3690 ehc->i.action = 0;
3691
Tejun Heo1eca4362008-11-03 20:03:17 +09003692 ata_for_each_dev(dev, link, ALL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003693 ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
3694 }
Tejun Heo084fe632006-05-31 18:28:03 +09003695
Tejun Heo022bdb02006-05-15 20:58:22 +09003696 /* reset */
Tejun Heo1eca4362008-11-03 20:03:17 +09003697 ata_for_each_link(link, ap, EDGE) {
Tejun Heodc98c322008-05-19 01:15:07 +09003698 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003699
Tejun Heodc98c322008-05-19 01:15:07 +09003700 if (!(ehc->i.action & ATA_EH_RESET))
3701 continue;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003702
Tejun Heodc98c322008-05-19 01:15:07 +09003703 rc = ata_eh_reset(link, ata_link_nr_vacant(link),
3704 prereset, softreset, hardreset, postreset);
3705 if (rc) {
Joe Perchesa9a79df2011-04-15 15:51:59 -07003706 ata_link_err(link, "reset failed, giving up\n");
Tejun Heodc98c322008-05-19 01:15:07 +09003707 goto out;
Tejun Heo022bdb02006-05-15 20:58:22 +09003708 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003709 }
3710
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003711 do {
3712 unsigned long now;
3713
3714 /*
3715 * clears ATA_EH_PARK in eh_info and resets
3716 * ap->park_req_pending
3717 */
3718 ata_eh_pull_park_action(ap);
3719
3720 deadline = jiffies;
Tejun Heo1eca4362008-11-03 20:03:17 +09003721 ata_for_each_link(link, ap, EDGE) {
3722 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003723 struct ata_eh_context *ehc = &link->eh_context;
3724 unsigned long tmp;
3725
3726 if (dev->class != ATA_DEV_ATA)
3727 continue;
3728 if (!(ehc->i.dev_action[dev->devno] &
3729 ATA_EH_PARK))
3730 continue;
3731 tmp = dev->unpark_deadline;
3732 if (time_before(deadline, tmp))
3733 deadline = tmp;
3734 else if (time_before_eq(tmp, jiffies))
3735 continue;
3736 if (ehc->unloaded_mask & (1 << dev->devno))
3737 continue;
3738
3739 ata_eh_park_issue_cmd(dev, 1);
3740 }
3741 }
3742
3743 now = jiffies;
3744 if (time_before_eq(deadline, now))
3745 break;
3746
Tejun Heoc0c362b2010-09-06 17:57:14 +02003747 ata_eh_release(ap);
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003748 deadline = wait_for_completion_timeout(&ap->park_req_pending,
3749 deadline - now);
Tejun Heoc0c362b2010-09-06 17:57:14 +02003750 ata_eh_acquire(ap);
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003751 } while (deadline);
Tejun Heo1eca4362008-11-03 20:03:17 +09003752 ata_for_each_link(link, ap, EDGE) {
3753 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003754 if (!(link->eh_context.unloaded_mask &
3755 (1 << dev->devno)))
3756 continue;
3757
3758 ata_eh_park_issue_cmd(dev, 0);
3759 ata_eh_done(link, dev, ATA_EH_PARK);
3760 }
3761 }
3762
Tejun Heo9b1e2652007-08-06 18:36:24 +09003763 /* the rest */
Tejun Heo6b7ae952010-09-01 17:50:06 +02003764 nr_fails = 0;
3765 ata_for_each_link(link, ap, PMP_FIRST) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003766 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003767
Tejun Heo6b7ae952010-09-01 17:50:06 +02003768 if (sata_pmp_attached(ap) && ata_is_host_link(link))
3769 goto config_lpm;
3770
Tejun Heo9b1e2652007-08-06 18:36:24 +09003771 /* revalidate existing devices and attach new ones */
3772 rc = ata_eh_revalidate_and_attach(link, &dev);
Tejun Heo4ae72a12007-02-02 16:22:30 +09003773 if (rc)
Tejun Heo6b7ae952010-09-01 17:50:06 +02003774 goto rest_fail;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003775
Tejun Heo633273a2007-09-23 13:19:54 +09003776 /* if PMP got attached, return, pmp EH will take care of it */
3777 if (link->device->class == ATA_DEV_PMP) {
3778 ehc->i.action = 0;
3779 return 0;
3780 }
3781
Tejun Heo9b1e2652007-08-06 18:36:24 +09003782 /* configure transfer mode if necessary */
3783 if (ehc->i.flags & ATA_EHI_SETMODE) {
3784 rc = ata_set_mode(link, &dev);
3785 if (rc)
Tejun Heo6b7ae952010-09-01 17:50:06 +02003786 goto rest_fail;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003787 ehc->i.flags &= ~ATA_EHI_SETMODE;
3788 }
3789
Tejun Heo11fc33d2008-08-30 14:20:01 +02003790 /* If reset has been issued, clear UA to avoid
3791 * disrupting the current users of the device.
3792 */
3793 if (ehc->i.flags & ATA_EHI_DID_RESET) {
Tejun Heo1eca4362008-11-03 20:03:17 +09003794 ata_for_each_dev(dev, link, ALL) {
Tejun Heo11fc33d2008-08-30 14:20:01 +02003795 if (dev->class != ATA_DEV_ATAPI)
3796 continue;
3797 rc = atapi_eh_clear_ua(dev);
3798 if (rc)
Tejun Heo6b7ae952010-09-01 17:50:06 +02003799 goto rest_fail;
Tejun Heo11fc33d2008-08-30 14:20:01 +02003800 }
3801 }
3802
Tejun Heo6013efd2009-11-19 15:36:45 +09003803 /* retry flush if necessary */
3804 ata_for_each_dev(dev, link, ALL) {
3805 if (dev->class != ATA_DEV_ATA)
3806 continue;
3807 rc = ata_eh_maybe_retry_flush(dev);
3808 if (rc)
Tejun Heo6b7ae952010-09-01 17:50:06 +02003809 goto rest_fail;
Tejun Heo6013efd2009-11-19 15:36:45 +09003810 }
3811
Tejun Heo6b7ae952010-09-01 17:50:06 +02003812 config_lpm:
Tejun Heo11fc33d2008-08-30 14:20:01 +02003813 /* configure link power saving */
Tejun Heo6b7ae952010-09-01 17:50:06 +02003814 if (link->lpm_policy != ap->target_lpm_policy) {
3815 rc = ata_eh_set_lpm(link, ap->target_lpm_policy, &dev);
3816 if (rc)
3817 goto rest_fail;
3818 }
Kristen Carlson Accardica773292007-10-25 00:58:59 -04003819
Tejun Heo9b1e2652007-08-06 18:36:24 +09003820 /* this link is okay now */
3821 ehc->i.flags = 0;
3822 continue;
3823
Tejun Heo6b7ae952010-09-01 17:50:06 +02003824 rest_fail:
3825 nr_fails++;
3826 if (dev)
3827 ata_eh_handle_dev_fail(dev, rc);
Tejun Heo9b1e2652007-08-06 18:36:24 +09003828
Tejun Heob06ce3e2007-10-09 15:06:48 +09003829 if (ap->pflags & ATA_PFLAG_FROZEN) {
3830 /* PMP reset requires working host port.
3831 * Can't retry if it's frozen.
3832 */
Tejun Heo071f44b2008-04-07 22:47:22 +09003833 if (sata_pmp_attached(ap))
Tejun Heob06ce3e2007-10-09 15:06:48 +09003834 goto out;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003835 break;
Tejun Heob06ce3e2007-10-09 15:06:48 +09003836 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003837 }
3838
Tejun Heo6b7ae952010-09-01 17:50:06 +02003839 if (nr_fails)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003840 goto retry;
Tejun Heo022bdb02006-05-15 20:58:22 +09003841
Tejun Heo022bdb02006-05-15 20:58:22 +09003842 out:
Tejun Heo9b1e2652007-08-06 18:36:24 +09003843 if (rc && r_failed_link)
3844 *r_failed_link = link;
Tejun Heo022bdb02006-05-15 20:58:22 +09003845
3846 DPRINTK("EXIT, rc=%d\n", rc);
3847 return rc;
3848}
3849
3850/**
3851 * ata_eh_finish - finish up EH
3852 * @ap: host port to finish EH for
3853 *
3854 * Recovery is complete. Clean up EH states and retry or finish
3855 * failed qcs.
3856 *
3857 * LOCKING:
3858 * None.
3859 */
Tejun Heofb7fd612007-09-23 13:14:12 +09003860void ata_eh_finish(struct ata_port *ap)
Tejun Heo022bdb02006-05-15 20:58:22 +09003861{
3862 int tag;
3863
3864 /* retry or finish qcs */
3865 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
3866 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
3867
3868 if (!(qc->flags & ATA_QCFLAG_FAILED))
3869 continue;
3870
3871 if (qc->err_mask) {
3872 /* FIXME: Once EH migration is complete,
3873 * generate sense data in this function,
3874 * considering both err_mask and tf.
3875 */
Tejun Heo03faab72008-03-27 19:14:24 +09003876 if (qc->flags & ATA_QCFLAG_RETRY)
Tejun Heo022bdb02006-05-15 20:58:22 +09003877 ata_eh_qc_retry(qc);
Tejun Heo03faab72008-03-27 19:14:24 +09003878 else
3879 ata_eh_qc_complete(qc);
Tejun Heo022bdb02006-05-15 20:58:22 +09003880 } else {
3881 if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
3882 ata_eh_qc_complete(qc);
3883 } else {
3884 /* feed zero TF to sense generation */
3885 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
3886 ata_eh_qc_retry(qc);
3887 }
3888 }
3889 }
Tejun Heoda917d62007-09-23 13:14:12 +09003890
3891 /* make sure nr_active_links is zero after EH */
3892 WARN_ON(ap->nr_active_links);
3893 ap->nr_active_links = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003894}
3895
3896/**
3897 * ata_do_eh - do standard error handling
3898 * @ap: host port to handle error for
Tejun Heoa1efdab2008-03-25 12:22:50 +09003899 *
Tejun Heof5914a42006-05-31 18:27:48 +09003900 * @prereset: prereset method (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09003901 * @softreset: softreset method (can be NULL)
3902 * @hardreset: hardreset method (can be NULL)
3903 * @postreset: postreset method (can be NULL)
3904 *
3905 * Perform standard error handling sequence.
3906 *
3907 * LOCKING:
3908 * Kernel thread context (may sleep).
3909 */
Tejun Heof5914a42006-05-31 18:27:48 +09003910void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
3911 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3912 ata_postreset_fn_t postreset)
Tejun Heo022bdb02006-05-15 20:58:22 +09003913{
Tejun Heo9b1e2652007-08-06 18:36:24 +09003914 struct ata_device *dev;
3915 int rc;
3916
3917 ata_eh_autopsy(ap);
3918 ata_eh_report(ap);
3919
3920 rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
3921 NULL);
3922 if (rc) {
Tejun Heo1eca4362008-11-03 20:03:17 +09003923 ata_for_each_dev(dev, &ap->link, ALL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003924 ata_dev_disable(dev);
3925 }
3926
Tejun Heo022bdb02006-05-15 20:58:22 +09003927 ata_eh_finish(ap);
3928}
Tejun Heo500530f2006-07-03 16:07:27 +09003929
Tejun Heoa1efdab2008-03-25 12:22:50 +09003930/**
3931 * ata_std_error_handler - standard error handler
3932 * @ap: host port to handle error for
3933 *
3934 * Standard error handler
3935 *
3936 * LOCKING:
3937 * Kernel thread context (may sleep).
3938 */
3939void ata_std_error_handler(struct ata_port *ap)
3940{
3941 struct ata_port_operations *ops = ap->ops;
3942 ata_reset_fn_t hardreset = ops->hardreset;
3943
Tejun Heo57c9efd2008-04-07 22:47:19 +09003944 /* ignore built-in hardreset if SCR access is not available */
Tejun Heofe06e5f2010-05-10 21:41:39 +02003945 if (hardreset == sata_std_hardreset && !sata_scr_valid(&ap->link))
Tejun Heoa1efdab2008-03-25 12:22:50 +09003946 hardreset = NULL;
3947
3948 ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);
3949}
3950
Tejun Heo6ffa01d2007-03-02 17:32:47 +09003951#ifdef CONFIG_PM
Tejun Heo500530f2006-07-03 16:07:27 +09003952/**
3953 * ata_eh_handle_port_suspend - perform port suspend operation
3954 * @ap: port to suspend
3955 *
3956 * Suspend @ap.
3957 *
3958 * LOCKING:
3959 * Kernel thread context (may sleep).
3960 */
3961static void ata_eh_handle_port_suspend(struct ata_port *ap)
3962{
3963 unsigned long flags;
3964 int rc = 0;
3965
3966 /* are we suspending? */
3967 spin_lock_irqsave(ap->lock, flags);
3968 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
3969 ap->pm_mesg.event == PM_EVENT_ON) {
3970 spin_unlock_irqrestore(ap->lock, flags);
3971 return;
3972 }
3973 spin_unlock_irqrestore(ap->lock, flags);
3974
3975 WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
3976
Tejun Heo64578a32007-05-15 03:28:16 +09003977 /* tell ACPI we're suspending */
3978 rc = ata_acpi_on_suspend(ap);
3979 if (rc)
3980 goto out;
3981
Tejun Heo500530f2006-07-03 16:07:27 +09003982 /* suspend */
3983 ata_eh_freeze_port(ap);
3984
3985 if (ap->ops->port_suspend)
3986 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
3987
Shaohua Libd3adca2007-11-02 09:32:38 +08003988 ata_acpi_set_state(ap, PMSG_SUSPEND);
Tejun Heo64578a32007-05-15 03:28:16 +09003989 out:
Tejun Heo500530f2006-07-03 16:07:27 +09003990 /* report result */
3991 spin_lock_irqsave(ap->lock, flags);
3992
3993 ap->pflags &= ~ATA_PFLAG_PM_PENDING;
3994 if (rc == 0)
3995 ap->pflags |= ATA_PFLAG_SUSPENDED;
Tejun Heo64578a32007-05-15 03:28:16 +09003996 else if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heo500530f2006-07-03 16:07:27 +09003997 ata_port_schedule_eh(ap);
3998
3999 if (ap->pm_result) {
4000 *ap->pm_result = rc;
4001 ap->pm_result = NULL;
4002 }
4003
4004 spin_unlock_irqrestore(ap->lock, flags);
4005
4006 return;
4007}
4008
4009/**
4010 * ata_eh_handle_port_resume - perform port resume operation
4011 * @ap: port to resume
4012 *
4013 * Resume @ap.
4014 *
Tejun Heo500530f2006-07-03 16:07:27 +09004015 * LOCKING:
4016 * Kernel thread context (may sleep).
4017 */
4018static void ata_eh_handle_port_resume(struct ata_port *ap)
4019{
Tejun Heo6f9c1ea2009-04-23 09:55:28 +09004020 struct ata_link *link;
4021 struct ata_device *dev;
Tejun Heo500530f2006-07-03 16:07:27 +09004022 unsigned long flags;
Tejun Heo9666f402007-05-04 21:27:47 +02004023 int rc = 0;
Tejun Heo500530f2006-07-03 16:07:27 +09004024
4025 /* are we resuming? */
4026 spin_lock_irqsave(ap->lock, flags);
4027 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
4028 ap->pm_mesg.event != PM_EVENT_ON) {
4029 spin_unlock_irqrestore(ap->lock, flags);
4030 return;
4031 }
4032 spin_unlock_irqrestore(ap->lock, flags);
4033
Tejun Heo9666f402007-05-04 21:27:47 +02004034 WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
Tejun Heo500530f2006-07-03 16:07:27 +09004035
Tejun Heo6f9c1ea2009-04-23 09:55:28 +09004036 /*
4037 * Error timestamps are in jiffies which doesn't run while
4038 * suspended and PHY events during resume isn't too uncommon.
4039 * When the two are combined, it can lead to unnecessary speed
4040 * downs if the machine is suspended and resumed repeatedly.
4041 * Clear error history.
4042 */
4043 ata_for_each_link(link, ap, HOST_FIRST)
4044 ata_for_each_dev(dev, link, ALL)
4045 ata_ering_clear(&dev->ering);
4046
Shaohua Libd3adca2007-11-02 09:32:38 +08004047 ata_acpi_set_state(ap, PMSG_ON);
4048
Tejun Heo500530f2006-07-03 16:07:27 +09004049 if (ap->ops->port_resume)
4050 rc = ap->ops->port_resume(ap);
4051
Tejun Heo67465442007-05-15 03:28:16 +09004052 /* tell ACPI that we're resuming */
4053 ata_acpi_on_resume(ap);
4054
Tejun Heo9666f402007-05-04 21:27:47 +02004055 /* report result */
Tejun Heo500530f2006-07-03 16:07:27 +09004056 spin_lock_irqsave(ap->lock, flags);
4057 ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
4058 if (ap->pm_result) {
4059 *ap->pm_result = rc;
4060 ap->pm_result = NULL;
4061 }
4062 spin_unlock_irqrestore(ap->lock, flags);
4063}
Tejun Heo6ffa01d2007-03-02 17:32:47 +09004064#endif /* CONFIG_PM */