blob: 9f6cfac0f2cce6ac50bf8ca2262326cad5c21201 [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>
Jeff Garzik28555682007-10-11 17:12:35 -040037#include <linux/pci.h>
Tejun Heoece1d632006-04-02 18:51:53 +090038#include <scsi/scsi.h>
39#include <scsi/scsi_host.h>
40#include <scsi/scsi_eh.h>
41#include <scsi/scsi_device.h>
42#include <scsi/scsi_cmnd.h>
Robert Hancock65211482009-07-14 20:43:39 -060043#include <scsi/scsi_dbg.h>
Jeff Garzikc6fd2802006-08-10 07:31:37 -040044#include "../scsi/scsi_transport_api.h"
Tejun Heoece1d632006-04-02 18:51:53 +090045
46#include <linux/libata.h>
47
48#include "libata.h"
49
Tejun Heo7d47e8d2007-02-02 16:22:31 +090050enum {
Tejun Heo3884f7b2007-11-27 19:28:56 +090051 /* speed down verdicts */
Tejun Heo7d47e8d2007-02-02 16:22:31 +090052 ATA_EH_SPDN_NCQ_OFF = (1 << 0),
53 ATA_EH_SPDN_SPEED_DOWN = (1 << 1),
54 ATA_EH_SPDN_FALLBACK_TO_PIO = (1 << 2),
Tejun Heo76326ac2007-11-27 19:28:59 +090055 ATA_EH_SPDN_KEEP_ERRORS = (1 << 3),
Tejun Heo3884f7b2007-11-27 19:28:56 +090056
57 /* error flags */
58 ATA_EFLAG_IS_IO = (1 << 0),
Tejun Heo76326ac2007-11-27 19:28:59 +090059 ATA_EFLAG_DUBIOUS_XFER = (1 << 1),
Tejun Heo3884f7b2007-11-27 19:28:56 +090060
61 /* error categories */
62 ATA_ECAT_NONE = 0,
63 ATA_ECAT_ATA_BUS = 1,
64 ATA_ECAT_TOUT_HSM = 2,
65 ATA_ECAT_UNK_DEV = 3,
Tejun Heo75f9caf2008-01-03 01:21:14 +090066 ATA_ECAT_DUBIOUS_NONE = 4,
67 ATA_ECAT_DUBIOUS_ATA_BUS = 5,
68 ATA_ECAT_DUBIOUS_TOUT_HSM = 6,
69 ATA_ECAT_DUBIOUS_UNK_DEV = 7,
70 ATA_ECAT_NR = 8,
Tejun Heo7d47e8d2007-02-02 16:22:31 +090071
Tejun Heo87fbc5a2008-05-20 02:17:54 +090072 ATA_EH_CMD_DFL_TIMEOUT = 5000,
73
Tejun Heo0a2c0f52008-05-20 02:17:52 +090074 /* always put at least this amount of time between resets */
75 ATA_EH_RESET_COOL_DOWN = 5000,
76
Tejun Heo341c2c92008-05-20 02:17:51 +090077 /* Waiting in ->prereset can never be reliable. It's
78 * sometimes nice to wait there but it can't be depended upon;
79 * otherwise, we wouldn't be resetting. Just give it enough
80 * time for most drives to spin up.
81 */
82 ATA_EH_PRERESET_TIMEOUT = 10000,
83 ATA_EH_FASTDRAIN_INTERVAL = 3000,
Tejun Heo11fc33d2008-08-30 14:20:01 +020084
85 ATA_EH_UA_TRIES = 5,
Tejun Heoc2c7a892009-01-29 20:31:34 +090086
87 /* probe speed down parameters, see ata_eh_schedule_probe() */
88 ATA_EH_PROBE_TRIAL_INTERVAL = 60000, /* 1 min */
89 ATA_EH_PROBE_TRIALS = 2,
Tejun Heo31daabd2007-02-02 16:50:52 +090090};
91
92/* The following table determines how we sequence resets. Each entry
93 * represents timeout for that try. The first try can be soft or
94 * hardreset. All others are hardreset if available. In most cases
95 * the first reset w/ 10sec timeout should succeed. Following entries
96 * are mostly for error handling, hotplug and retarded devices.
97 */
98static const unsigned long ata_eh_reset_timeouts[] = {
Tejun Heo341c2c92008-05-20 02:17:51 +090099 10000, /* most drives spin up by 10sec */
100 10000, /* > 99% working drives spin up before 20sec */
101 35000, /* give > 30 secs of idleness for retarded devices */
102 5000, /* and sweet one last chance */
Tejun Heod8af0eb2008-05-20 02:17:53 +0900103 ULONG_MAX, /* > 1 min has elapsed, give up */
Tejun Heo31daabd2007-02-02 16:50:52 +0900104};
105
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900106static const unsigned long ata_eh_identify_timeouts[] = {
107 5000, /* covers > 99% of successes and not too boring on failures */
108 10000, /* combined time till here is enough even for media access */
109 30000, /* for true idiots */
110 ULONG_MAX,
111};
112
Tejun Heo6013efd2009-11-19 15:36:45 +0900113static const unsigned long ata_eh_flush_timeouts[] = {
114 15000, /* be generous with flush */
115 15000, /* ditto */
116 30000, /* and even more generous */
117 ULONG_MAX,
118};
119
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900120static const unsigned long ata_eh_other_timeouts[] = {
121 5000, /* same rationale as identify timeout */
122 10000, /* ditto */
123 /* but no merciful 30sec for other commands, it just isn't worth it */
124 ULONG_MAX,
125};
126
127struct ata_eh_cmd_timeout_ent {
128 const u8 *commands;
129 const unsigned long *timeouts;
130};
131
132/* The following table determines timeouts to use for EH internal
133 * commands. Each table entry is a command class and matches the
134 * commands the entry applies to and the timeout table to use.
135 *
136 * On the retry after a command timed out, the next timeout value from
137 * the table is used. If the table doesn't contain further entries,
138 * the last value is used.
139 *
140 * ehc->cmd_timeout_idx keeps track of which timeout to use per
141 * command class, so if SET_FEATURES times out on the first try, the
142 * next try will use the second timeout value only for that class.
143 */
144#define CMDS(cmds...) (const u8 []){ cmds, 0 }
145static const struct ata_eh_cmd_timeout_ent
146ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = {
147 { .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI),
148 .timeouts = ata_eh_identify_timeouts, },
149 { .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT),
150 .timeouts = ata_eh_other_timeouts, },
151 { .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT),
152 .timeouts = ata_eh_other_timeouts, },
153 { .commands = CMDS(ATA_CMD_SET_FEATURES),
154 .timeouts = ata_eh_other_timeouts, },
155 { .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS),
156 .timeouts = ata_eh_other_timeouts, },
Tejun Heo6013efd2009-11-19 15:36:45 +0900157 { .commands = CMDS(ATA_CMD_FLUSH, ATA_CMD_FLUSH_EXT),
158 .timeouts = ata_eh_flush_timeouts },
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900159};
160#undef CMDS
161
Tejun Heoad9e2762006-05-15 20:58:12 +0900162static void __ata_port_freeze(struct ata_port *ap);
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900163#ifdef CONFIG_PM
Tejun Heo500530f2006-07-03 16:07:27 +0900164static void ata_eh_handle_port_suspend(struct ata_port *ap);
165static void ata_eh_handle_port_resume(struct ata_port *ap);
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900166#else /* CONFIG_PM */
167static void ata_eh_handle_port_suspend(struct ata_port *ap)
168{ }
169
170static void ata_eh_handle_port_resume(struct ata_port *ap)
171{ }
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900172#endif /* CONFIG_PM */
Tejun Heoad9e2762006-05-15 20:58:12 +0900173
Tejun Heob64bbc32007-07-16 14:29:39 +0900174static void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, const char *fmt,
175 va_list args)
176{
177 ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
178 ATA_EH_DESC_LEN - ehi->desc_len,
179 fmt, args);
180}
181
182/**
183 * __ata_ehi_push_desc - push error description without adding separator
184 * @ehi: target EHI
185 * @fmt: printf format string
186 *
187 * Format string according to @fmt and append it to @ehi->desc.
188 *
189 * LOCKING:
190 * spin_lock_irqsave(host lock)
191 */
192void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
193{
194 va_list args;
195
196 va_start(args, fmt);
197 __ata_ehi_pushv_desc(ehi, fmt, args);
198 va_end(args);
199}
200
201/**
202 * ata_ehi_push_desc - push error description with separator
203 * @ehi: target EHI
204 * @fmt: printf format string
205 *
206 * Format string according to @fmt and append it to @ehi->desc.
207 * If @ehi->desc is not empty, ", " is added in-between.
208 *
209 * LOCKING:
210 * spin_lock_irqsave(host lock)
211 */
212void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
213{
214 va_list args;
215
216 if (ehi->desc_len)
217 __ata_ehi_push_desc(ehi, ", ");
218
219 va_start(args, fmt);
220 __ata_ehi_pushv_desc(ehi, fmt, args);
221 va_end(args);
222}
223
224/**
225 * ata_ehi_clear_desc - clean error description
226 * @ehi: target EHI
227 *
228 * Clear @ehi->desc.
229 *
230 * LOCKING:
231 * spin_lock_irqsave(host lock)
232 */
233void ata_ehi_clear_desc(struct ata_eh_info *ehi)
234{
235 ehi->desc[0] = '\0';
236 ehi->desc_len = 0;
237}
238
Tejun Heocbcdd872007-08-18 13:14:55 +0900239/**
240 * ata_port_desc - append port description
241 * @ap: target ATA port
242 * @fmt: printf format string
243 *
244 * Format string according to @fmt and append it to port
245 * description. If port description is not empty, " " is added
246 * in-between. This function is to be used while initializing
247 * ata_host. The description is printed on host registration.
248 *
249 * LOCKING:
250 * None.
251 */
252void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
253{
254 va_list args;
255
256 WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
257
258 if (ap->link.eh_info.desc_len)
259 __ata_ehi_push_desc(&ap->link.eh_info, " ");
260
261 va_start(args, fmt);
262 __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
263 va_end(args);
264}
265
266#ifdef CONFIG_PCI
267
268/**
269 * ata_port_pbar_desc - append PCI BAR description
270 * @ap: target ATA port
271 * @bar: target PCI BAR
272 * @offset: offset into PCI BAR
273 * @name: name of the area
274 *
275 * If @offset is negative, this function formats a string which
276 * contains the name, address, size and type of the BAR and
277 * appends it to the port description. If @offset is zero or
278 * positive, only name and offsetted address is appended.
279 *
280 * LOCKING:
281 * None.
282 */
283void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
284 const char *name)
285{
286 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
287 char *type = "";
288 unsigned long long start, len;
289
290 if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
291 type = "m";
292 else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
293 type = "i";
294
295 start = (unsigned long long)pci_resource_start(pdev, bar);
296 len = (unsigned long long)pci_resource_len(pdev, bar);
297
298 if (offset < 0)
299 ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
300 else
Andrew Mortone6a73ab2007-12-13 16:01:37 -0800301 ata_port_desc(ap, "%s 0x%llx", name,
302 start + (unsigned long long)offset);
Tejun Heocbcdd872007-08-18 13:14:55 +0900303}
304
305#endif /* CONFIG_PCI */
306
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900307static int ata_lookup_timeout_table(u8 cmd)
308{
309 int i;
310
311 for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) {
312 const u8 *cur;
313
314 for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++)
315 if (*cur == cmd)
316 return i;
317 }
318
319 return -1;
320}
321
322/**
323 * ata_internal_cmd_timeout - determine timeout for an internal command
324 * @dev: target device
325 * @cmd: internal command to be issued
326 *
327 * Determine timeout for internal command @cmd for @dev.
328 *
329 * LOCKING:
330 * EH context.
331 *
332 * RETURNS:
333 * Determined timeout.
334 */
335unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd)
336{
337 struct ata_eh_context *ehc = &dev->link->eh_context;
338 int ent = ata_lookup_timeout_table(cmd);
339 int idx;
340
341 if (ent < 0)
342 return ATA_EH_CMD_DFL_TIMEOUT;
343
344 idx = ehc->cmd_timeout_idx[dev->devno][ent];
345 return ata_eh_cmd_timeout_table[ent].timeouts[idx];
346}
347
348/**
349 * ata_internal_cmd_timed_out - notification for internal command timeout
350 * @dev: target device
351 * @cmd: internal command which timed out
352 *
353 * Notify EH that internal command @cmd for @dev timed out. This
354 * function should be called only for commands whose timeouts are
355 * determined using ata_internal_cmd_timeout().
356 *
357 * LOCKING:
358 * EH context.
359 */
360void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd)
361{
362 struct ata_eh_context *ehc = &dev->link->eh_context;
363 int ent = ata_lookup_timeout_table(cmd);
364 int idx;
365
366 if (ent < 0)
367 return;
368
369 idx = ehc->cmd_timeout_idx[dev->devno][ent];
370 if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX)
371 ehc->cmd_timeout_idx[dev->devno][ent]++;
372}
373
Tejun Heo3884f7b2007-11-27 19:28:56 +0900374static void ata_ering_record(struct ata_ering *ering, unsigned int eflags,
Tejun Heo0c247c52006-05-15 20:58:19 +0900375 unsigned int err_mask)
376{
377 struct ata_ering_entry *ent;
378
379 WARN_ON(!err_mask);
380
381 ering->cursor++;
382 ering->cursor %= ATA_ERING_SIZE;
383
384 ent = &ering->ring[ering->cursor];
Tejun Heo3884f7b2007-11-27 19:28:56 +0900385 ent->eflags = eflags;
Tejun Heo0c247c52006-05-15 20:58:19 +0900386 ent->err_mask = err_mask;
387 ent->timestamp = get_jiffies_64();
388}
389
Tejun Heo76326ac2007-11-27 19:28:59 +0900390static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
391{
392 struct ata_ering_entry *ent = &ering->ring[ering->cursor];
393
394 if (ent->err_mask)
395 return ent;
396 return NULL;
397}
398
Tejun Heo7d47e8d2007-02-02 16:22:31 +0900399static void ata_ering_clear(struct ata_ering *ering)
Tejun Heo0c247c52006-05-15 20:58:19 +0900400{
Tejun Heo7d47e8d2007-02-02 16:22:31 +0900401 memset(ering, 0, sizeof(*ering));
Tejun Heo0c247c52006-05-15 20:58:19 +0900402}
403
404static int ata_ering_map(struct ata_ering *ering,
405 int (*map_fn)(struct ata_ering_entry *, void *),
406 void *arg)
407{
408 int idx, rc = 0;
409 struct ata_ering_entry *ent;
410
411 idx = ering->cursor;
412 do {
413 ent = &ering->ring[idx];
414 if (!ent->err_mask)
415 break;
416 rc = map_fn(ent, arg);
417 if (rc)
418 break;
419 idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
420 } while (idx != ering->cursor);
421
422 return rc;
423}
424
Tejun Heo64f65ca2006-06-24 20:30:18 +0900425static unsigned int ata_eh_dev_action(struct ata_device *dev)
426{
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900427 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heo64f65ca2006-06-24 20:30:18 +0900428
429 return ehc->i.action | ehc->i.dev_action[dev->devno];
430}
431
Tejun Heof58229f2007-08-06 18:36:23 +0900432static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
Tejun Heoaf181c22006-06-24 20:30:18 +0900433 struct ata_eh_info *ehi, unsigned int action)
434{
Tejun Heof58229f2007-08-06 18:36:23 +0900435 struct ata_device *tdev;
Tejun Heoaf181c22006-06-24 20:30:18 +0900436
437 if (!dev) {
438 ehi->action &= ~action;
Tejun Heo1eca4362008-11-03 20:03:17 +0900439 ata_for_each_dev(tdev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +0900440 ehi->dev_action[tdev->devno] &= ~action;
Tejun Heoaf181c22006-06-24 20:30:18 +0900441 } else {
442 /* doesn't make sense for port-wide EH actions */
443 WARN_ON(!(action & ATA_EH_PERDEV_MASK));
444
445 /* break ehi->action into ehi->dev_action */
446 if (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] |=
449 ehi->action & action;
Tejun Heoaf181c22006-06-24 20:30:18 +0900450 ehi->action &= ~action;
451 }
452
453 /* turn off the specified per-dev action */
454 ehi->dev_action[dev->devno] &= ~action;
455 }
456}
457
Tejun Heoece1d632006-04-02 18:51:53 +0900458/**
459 * ata_scsi_timed_out - SCSI layer time out callback
460 * @cmd: timed out SCSI command
461 *
462 * Handles SCSI layer timeout. We race with normal completion of
463 * the qc for @cmd. If the qc is already gone, we lose and let
464 * the scsi command finish (EH_HANDLED). Otherwise, the qc has
465 * timed out and EH should be invoked. Prevent ata_qc_complete()
466 * from finishing it by setting EH_SCHEDULED and return
467 * EH_NOT_HANDLED.
468 *
Tejun Heoad9e2762006-05-15 20:58:12 +0900469 * TODO: kill this function once old EH is gone.
470 *
Tejun Heoece1d632006-04-02 18:51:53 +0900471 * LOCKING:
472 * Called from timer context
473 *
474 * RETURNS:
475 * EH_HANDLED or EH_NOT_HANDLED
476 */
Jens Axboe242f9dc2008-09-14 05:55:09 -0700477enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
Tejun Heoece1d632006-04-02 18:51:53 +0900478{
479 struct Scsi_Host *host = cmd->device->host;
Jeff Garzik35bb94b2006-04-11 13:12:34 -0400480 struct ata_port *ap = ata_shost_to_port(host);
Tejun Heoece1d632006-04-02 18:51:53 +0900481 unsigned long flags;
482 struct ata_queued_cmd *qc;
Jens Axboe242f9dc2008-09-14 05:55:09 -0700483 enum blk_eh_timer_return ret;
Tejun Heoece1d632006-04-02 18:51:53 +0900484
485 DPRINTK("ENTER\n");
486
Tejun Heoad9e2762006-05-15 20:58:12 +0900487 if (ap->ops->error_handler) {
Jens Axboe242f9dc2008-09-14 05:55:09 -0700488 ret = BLK_EH_NOT_HANDLED;
Tejun Heoad9e2762006-05-15 20:58:12 +0900489 goto out;
490 }
491
Jens Axboe242f9dc2008-09-14 05:55:09 -0700492 ret = BLK_EH_HANDLED;
Jeff Garzikba6a1302006-06-22 23:46:10 -0400493 spin_lock_irqsave(ap->lock, flags);
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900494 qc = ata_qc_from_tag(ap, ap->link.active_tag);
Tejun Heoece1d632006-04-02 18:51:53 +0900495 if (qc) {
496 WARN_ON(qc->scsicmd != cmd);
497 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
498 qc->err_mask |= AC_ERR_TIMEOUT;
Jens Axboe242f9dc2008-09-14 05:55:09 -0700499 ret = BLK_EH_NOT_HANDLED;
Tejun Heoece1d632006-04-02 18:51:53 +0900500 }
Jeff Garzikba6a1302006-06-22 23:46:10 -0400501 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +0900502
Tejun Heoad9e2762006-05-15 20:58:12 +0900503 out:
Tejun Heoece1d632006-04-02 18:51:53 +0900504 DPRINTK("EXIT, ret=%d\n", ret);
505 return ret;
506}
507
Tejun Heoece180d2008-11-03 20:04:37 +0900508static void ata_eh_unload(struct ata_port *ap)
509{
510 struct ata_link *link;
511 struct ata_device *dev;
512 unsigned long flags;
513
514 /* Restore SControl IPM and SPD for the next driver and
515 * disable attached devices.
516 */
517 ata_for_each_link(link, ap, PMP_FIRST) {
518 sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);
519 ata_for_each_dev(dev, link, ALL)
520 ata_dev_disable(dev);
521 }
522
523 /* freeze and set UNLOADED */
524 spin_lock_irqsave(ap->lock, flags);
525
526 ata_port_freeze(ap); /* won't be thawed */
527 ap->pflags &= ~ATA_PFLAG_EH_PENDING; /* clear pending from freeze */
528 ap->pflags |= ATA_PFLAG_UNLOADED;
529
530 spin_unlock_irqrestore(ap->lock, flags);
531}
532
Tejun Heoece1d632006-04-02 18:51:53 +0900533/**
534 * ata_scsi_error - SCSI layer error handler callback
535 * @host: SCSI host on which error occurred
536 *
537 * Handles SCSI-layer-thrown error events.
538 *
539 * LOCKING:
540 * Inherited from SCSI layer (none, can sleep)
541 *
542 * RETURNS:
543 * Zero.
544 */
Jeff Garzik381544b2006-04-11 13:04:39 -0400545void ata_scsi_error(struct Scsi_Host *host)
Tejun Heoece1d632006-04-02 18:51:53 +0900546{
Jeff Garzik35bb94b2006-04-11 13:12:34 -0400547 struct ata_port *ap = ata_shost_to_port(host);
Tejun Heoa1e10f72007-08-18 13:28:49 +0900548 int i;
Tejun Heoad9e2762006-05-15 20:58:12 +0900549 unsigned long flags;
Tejun Heoece1d632006-04-02 18:51:53 +0900550
551 DPRINTK("ENTER\n");
552
Tejun Heoad9e2762006-05-15 20:58:12 +0900553 /* synchronize with port task */
Tejun Heoece1d632006-04-02 18:51:53 +0900554 ata_port_flush_task(ap);
555
Jeff Garzikcca39742006-08-24 03:19:22 -0400556 /* synchronize with host lock and sort out timeouts */
Tejun Heoece1d632006-04-02 18:51:53 +0900557
Tejun Heoad9e2762006-05-15 20:58:12 +0900558 /* For new EH, all qcs are finished in one of three ways -
559 * normal completion, error completion, and SCSI timeout.
Alan Coxc96f1732009-03-24 10:23:46 +0000560 * Both completions can race against SCSI timeout. When normal
Tejun Heoad9e2762006-05-15 20:58:12 +0900561 * completion wins, the qc never reaches EH. When error
562 * completion wins, the qc has ATA_QCFLAG_FAILED set.
563 *
564 * When SCSI timeout wins, things are a bit more complex.
565 * Normal or error completion can occur after the timeout but
566 * before this point. In such cases, both types of
567 * completions are honored. A scmd is determined to have
568 * timed out iff its associated qc is active and not failed.
569 */
570 if (ap->ops->error_handler) {
571 struct scsi_cmnd *scmd, *tmp;
572 int nr_timedout = 0;
Tejun Heoece1d632006-04-02 18:51:53 +0900573
Tejun Heoe30349d2006-07-03 03:02:15 +0900574 spin_lock_irqsave(ap->lock, flags);
Alan Coxc96f1732009-03-24 10:23:46 +0000575
576 /* This must occur under the ap->lock as we don't want
577 a polled recovery to race the real interrupt handler
578
579 The lost_interrupt handler checks for any completed but
580 non-notified command and completes much like an IRQ handler.
581
582 We then fall into the error recovery code which will treat
583 this as if normal completion won the race */
Tejun Heoad9e2762006-05-15 20:58:12 +0900584
Alan Coxc96f1732009-03-24 10:23:46 +0000585 if (ap->ops->lost_interrupt)
586 ap->ops->lost_interrupt(ap);
587
Tejun Heoad9e2762006-05-15 20:58:12 +0900588 list_for_each_entry_safe(scmd, tmp, &host->eh_cmd_q, eh_entry) {
589 struct ata_queued_cmd *qc;
590
591 for (i = 0; i < ATA_MAX_QUEUE; i++) {
592 qc = __ata_qc_from_tag(ap, i);
593 if (qc->flags & ATA_QCFLAG_ACTIVE &&
594 qc->scsicmd == scmd)
595 break;
596 }
597
598 if (i < ATA_MAX_QUEUE) {
599 /* the scmd has an associated qc */
600 if (!(qc->flags & ATA_QCFLAG_FAILED)) {
601 /* which hasn't failed yet, timeout */
602 qc->err_mask |= AC_ERR_TIMEOUT;
603 qc->flags |= ATA_QCFLAG_FAILED;
604 nr_timedout++;
605 }
606 } else {
607 /* Normal completion occurred after
608 * SCSI timeout but before this point.
609 * Successfully complete it.
610 */
611 scmd->retries = scmd->allowed;
612 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
613 }
614 }
615
616 /* If we have timed out qcs. They belong to EH from
617 * this point but the state of the controller is
618 * unknown. Freeze the port to make sure the IRQ
619 * handler doesn't diddle with those qcs. This must
620 * be done atomically w.r.t. setting QCFLAG_FAILED.
621 */
622 if (nr_timedout)
623 __ata_port_freeze(ap);
624
Tejun Heoe30349d2006-07-03 03:02:15 +0900625 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoa1e10f72007-08-18 13:28:49 +0900626
627 /* initialize eh_tries */
628 ap->eh_tries = ATA_EH_MAX_TRIES;
Tejun Heoad9e2762006-05-15 20:58:12 +0900629 } else
Tejun Heoe30349d2006-07-03 03:02:15 +0900630 spin_unlock_wait(ap->lock);
Alan Coxc96f1732009-03-24 10:23:46 +0000631
632 /* If we timed raced normal completion and there is nothing to
633 recover nr_timedout == 0 why exactly are we doing error recovery ? */
Tejun Heoad9e2762006-05-15 20:58:12 +0900634
635 repeat:
636 /* invoke error handler */
637 if (ap->ops->error_handler) {
Tejun Heocf1b86c2007-08-06 18:36:23 +0900638 struct ata_link *link;
639
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900640 /* kill fast drain timer */
641 del_timer_sync(&ap->fastdrain_timer);
642
Tejun Heo500530f2006-07-03 16:07:27 +0900643 /* process port resume request */
644 ata_eh_handle_port_resume(ap);
645
Tejun Heof3e81b12006-05-15 20:58:21 +0900646 /* fetch & clear EH info */
Tejun Heoe30349d2006-07-03 03:02:15 +0900647 spin_lock_irqsave(ap->lock, flags);
Tejun Heof3e81b12006-05-15 20:58:21 +0900648
Tejun Heo1eca4362008-11-03 20:03:17 +0900649 ata_for_each_link(link, ap, HOST_FIRST) {
Tejun Heo00115e02007-11-27 19:28:58 +0900650 struct ata_eh_context *ehc = &link->eh_context;
651 struct ata_device *dev;
652
Tejun Heocf1b86c2007-08-06 18:36:23 +0900653 memset(&link->eh_context, 0, sizeof(link->eh_context));
654 link->eh_context.i = link->eh_info;
655 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heo00115e02007-11-27 19:28:58 +0900656
Tejun Heo1eca4362008-11-03 20:03:17 +0900657 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo00115e02007-11-27 19:28:58 +0900658 int devno = dev->devno;
659
660 ehc->saved_xfer_mode[devno] = dev->xfer_mode;
661 if (ata_ncq_enabled(dev))
662 ehc->saved_ncq_enabled |= 1 << devno;
663 }
Tejun Heocf1b86c2007-08-06 18:36:23 +0900664 }
Tejun Heof3e81b12006-05-15 20:58:21 +0900665
Tejun Heob51e9e52006-06-29 01:29:30 +0900666 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
667 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heoda917d62007-09-23 13:14:12 +0900668 ap->excl_link = NULL; /* don't maintain exclusion over EH */
Tejun Heof3e81b12006-05-15 20:58:21 +0900669
Tejun Heoe30349d2006-07-03 03:02:15 +0900670 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900671
Tejun Heo500530f2006-07-03 16:07:27 +0900672 /* invoke EH, skip if unloading or suspended */
673 if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
Tejun Heo720ba122006-05-31 18:28:13 +0900674 ap->ops->error_handler(ap);
Tejun Heoece180d2008-11-03 20:04:37 +0900675 else {
676 /* if unloading, commence suicide */
677 if ((ap->pflags & ATA_PFLAG_UNLOADING) &&
678 !(ap->pflags & ATA_PFLAG_UNLOADED))
679 ata_eh_unload(ap);
Tejun Heo720ba122006-05-31 18:28:13 +0900680 ata_eh_finish(ap);
Tejun Heoece180d2008-11-03 20:04:37 +0900681 }
Tejun Heoad9e2762006-05-15 20:58:12 +0900682
Tejun Heo500530f2006-07-03 16:07:27 +0900683 /* process port suspend request */
684 ata_eh_handle_port_suspend(ap);
685
Tejun Heoad9e2762006-05-15 20:58:12 +0900686 /* Exception might have happend after ->error_handler
687 * recovered the port but before this point. Repeat
688 * EH in such case.
689 */
Tejun Heoe30349d2006-07-03 03:02:15 +0900690 spin_lock_irqsave(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900691
Tejun Heob51e9e52006-06-29 01:29:30 +0900692 if (ap->pflags & ATA_PFLAG_EH_PENDING) {
Tejun Heoa1e10f72007-08-18 13:28:49 +0900693 if (--ap->eh_tries) {
Tejun Heoe30349d2006-07-03 03:02:15 +0900694 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900695 goto repeat;
696 }
697 ata_port_printk(ap, KERN_ERR, "EH pending after %d "
Tejun Heoa1e10f72007-08-18 13:28:49 +0900698 "tries, giving up\n", ATA_EH_MAX_TRIES);
Tejun Heo914616a2007-06-25 21:47:11 +0900699 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heoad9e2762006-05-15 20:58:12 +0900700 }
701
Tejun Heof3e81b12006-05-15 20:58:21 +0900702 /* this run is complete, make sure EH info is clear */
Tejun Heo1eca4362008-11-03 20:03:17 +0900703 ata_for_each_link(link, ap, HOST_FIRST)
Tejun Heocf1b86c2007-08-06 18:36:23 +0900704 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heof3e81b12006-05-15 20:58:21 +0900705
Tejun Heoe30349d2006-07-03 03:02:15 +0900706 /* Clear host_eh_scheduled while holding ap->lock such
Tejun Heoad9e2762006-05-15 20:58:12 +0900707 * that if exception occurs after this point but
708 * before EH completion, SCSI midlayer will
709 * re-initiate EH.
710 */
711 host->host_eh_scheduled = 0;
712
Tejun Heoe30349d2006-07-03 03:02:15 +0900713 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900714 } else {
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900715 WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
Tejun Heoad9e2762006-05-15 20:58:12 +0900716 ap->ops->eng_timeout(ap);
717 }
718
719 /* finish or retry handled scmd's and clean up */
Tejun Heoece1d632006-04-02 18:51:53 +0900720 WARN_ON(host->host_failed || !list_empty(&host->eh_cmd_q));
721
722 scsi_eh_flush_done_q(&ap->eh_done_q);
723
Tejun Heoad9e2762006-05-15 20:58:12 +0900724 /* clean up */
Tejun Heoe30349d2006-07-03 03:02:15 +0900725 spin_lock_irqsave(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900726
Tejun Heo1cdaf532006-07-03 16:07:26 +0900727 if (ap->pflags & ATA_PFLAG_LOADING)
Tejun Heob51e9e52006-06-29 01:29:30 +0900728 ap->pflags &= ~ATA_PFLAG_LOADING;
Tejun Heo1cdaf532006-07-03 16:07:26 +0900729 else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
David Howells52bad642006-11-22 14:54:01 +0000730 queue_delayed_work(ata_aux_wq, &ap->hotplug_task, 0);
Tejun Heo1cdaf532006-07-03 16:07:26 +0900731
732 if (ap->pflags & ATA_PFLAG_RECOVERED)
733 ata_port_printk(ap, KERN_INFO, "EH complete\n");
Tejun Heo580b21022006-05-31 18:28:05 +0900734
Tejun Heob51e9e52006-06-29 01:29:30 +0900735 ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
Tejun Heoad9e2762006-05-15 20:58:12 +0900736
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900737 /* tell wait_eh that we're done */
Tejun Heob51e9e52006-06-29 01:29:30 +0900738 ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900739 wake_up_all(&ap->eh_wait_q);
740
Tejun Heoe30349d2006-07-03 03:02:15 +0900741 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900742
Tejun Heoece1d632006-04-02 18:51:53 +0900743 DPRINTK("EXIT\n");
Tejun Heoece1d632006-04-02 18:51:53 +0900744}
745
746/**
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900747 * ata_port_wait_eh - Wait for the currently pending EH to complete
748 * @ap: Port to wait EH for
749 *
750 * Wait until the currently pending EH is complete.
751 *
752 * LOCKING:
753 * Kernel thread context (may sleep).
754 */
755void ata_port_wait_eh(struct ata_port *ap)
756{
757 unsigned long flags;
758 DEFINE_WAIT(wait);
759
760 retry:
Jeff Garzikba6a1302006-06-22 23:46:10 -0400761 spin_lock_irqsave(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900762
Tejun Heob51e9e52006-06-29 01:29:30 +0900763 while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900764 prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
Jeff Garzikba6a1302006-06-22 23:46:10 -0400765 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900766 schedule();
Jeff Garzikba6a1302006-06-22 23:46:10 -0400767 spin_lock_irqsave(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900768 }
Tejun Heo0a1b6222006-06-11 11:01:38 +0900769 finish_wait(&ap->eh_wait_q, &wait);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900770
Jeff Garzikba6a1302006-06-22 23:46:10 -0400771 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900772
773 /* make sure SCSI EH is complete */
Jeff Garzikcca39742006-08-24 03:19:22 -0400774 if (scsi_host_in_recovery(ap->scsi_host)) {
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900775 msleep(10);
776 goto retry;
777 }
778}
779
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900780static int ata_eh_nr_in_flight(struct ata_port *ap)
781{
782 unsigned int tag;
783 int nr = 0;
784
785 /* count only non-internal commands */
786 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
787 if (ata_qc_from_tag(ap, tag))
788 nr++;
789
790 return nr;
791}
792
793void ata_eh_fastdrain_timerfn(unsigned long arg)
794{
795 struct ata_port *ap = (void *)arg;
796 unsigned long flags;
797 int cnt;
798
799 spin_lock_irqsave(ap->lock, flags);
800
801 cnt = ata_eh_nr_in_flight(ap);
802
803 /* are we done? */
804 if (!cnt)
805 goto out_unlock;
806
807 if (cnt == ap->fastdrain_cnt) {
808 unsigned int tag;
809
810 /* No progress during the last interval, tag all
811 * in-flight qcs as timed out and freeze the port.
812 */
813 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
814 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
815 if (qc)
816 qc->err_mask |= AC_ERR_TIMEOUT;
817 }
818
819 ata_port_freeze(ap);
820 } else {
821 /* some qcs have finished, give it another chance */
822 ap->fastdrain_cnt = cnt;
823 ap->fastdrain_timer.expires =
Tejun Heo341c2c92008-05-20 02:17:51 +0900824 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900825 add_timer(&ap->fastdrain_timer);
826 }
827
828 out_unlock:
829 spin_unlock_irqrestore(ap->lock, flags);
830}
831
832/**
833 * ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
834 * @ap: target ATA port
835 * @fastdrain: activate fast drain
836 *
837 * Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
838 * is non-zero and EH wasn't pending before. Fast drain ensures
839 * that EH kicks in in timely manner.
840 *
841 * LOCKING:
842 * spin_lock_irqsave(host lock)
843 */
844static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
845{
846 int cnt;
847
848 /* already scheduled? */
849 if (ap->pflags & ATA_PFLAG_EH_PENDING)
850 return;
851
852 ap->pflags |= ATA_PFLAG_EH_PENDING;
853
854 if (!fastdrain)
855 return;
856
857 /* do we have in-flight qcs? */
858 cnt = ata_eh_nr_in_flight(ap);
859 if (!cnt)
860 return;
861
862 /* activate fast drain */
863 ap->fastdrain_cnt = cnt;
Tejun Heo341c2c92008-05-20 02:17:51 +0900864 ap->fastdrain_timer.expires =
865 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900866 add_timer(&ap->fastdrain_timer);
867}
868
Tejun Heof686bcb2006-05-15 20:58:05 +0900869/**
870 * ata_qc_schedule_eh - schedule qc for error handling
871 * @qc: command to schedule error handling for
872 *
873 * Schedule error handling for @qc. EH will kick in as soon as
874 * other commands are drained.
875 *
876 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400877 * spin_lock_irqsave(host lock)
Tejun Heof686bcb2006-05-15 20:58:05 +0900878 */
879void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
880{
881 struct ata_port *ap = qc->ap;
882
883 WARN_ON(!ap->ops->error_handler);
884
885 qc->flags |= ATA_QCFLAG_FAILED;
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900886 ata_eh_set_pending(ap, 1);
Tejun Heof686bcb2006-05-15 20:58:05 +0900887
888 /* The following will fail if timeout has already expired.
889 * ata_scsi_error() takes care of such scmds on EH entry.
890 * Note that ATA_QCFLAG_FAILED is unconditionally set after
891 * this function completes.
892 */
Jens Axboe242f9dc2008-09-14 05:55:09 -0700893 blk_abort_request(qc->scsicmd->request);
Tejun Heof686bcb2006-05-15 20:58:05 +0900894}
895
Tejun Heo7b70fc02006-05-15 20:58:07 +0900896/**
897 * ata_port_schedule_eh - schedule error handling without a qc
898 * @ap: ATA port to schedule EH for
899 *
900 * Schedule error handling for @ap. EH will kick in as soon as
901 * all commands are drained.
902 *
903 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400904 * spin_lock_irqsave(host lock)
Tejun Heo7b70fc02006-05-15 20:58:07 +0900905 */
906void ata_port_schedule_eh(struct ata_port *ap)
907{
908 WARN_ON(!ap->ops->error_handler);
909
Tejun Heof4d6d002007-05-01 11:50:15 +0200910 if (ap->pflags & ATA_PFLAG_INITIALIZING)
911 return;
912
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900913 ata_eh_set_pending(ap, 1);
Jeff Garzikcca39742006-08-24 03:19:22 -0400914 scsi_schedule_eh(ap->scsi_host);
Tejun Heo7b70fc02006-05-15 20:58:07 +0900915
916 DPRINTK("port EH scheduled\n");
917}
918
Tejun Heodbd82612007-08-06 18:36:23 +0900919static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
Tejun Heo7b70fc02006-05-15 20:58:07 +0900920{
921 int tag, nr_aborted = 0;
922
923 WARN_ON(!ap->ops->error_handler);
924
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900925 /* we're gonna abort all commands, no need for fast drain */
926 ata_eh_set_pending(ap, 0);
927
Tejun Heo7b70fc02006-05-15 20:58:07 +0900928 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
929 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
930
Tejun Heodbd82612007-08-06 18:36:23 +0900931 if (qc && (!link || qc->dev->link == link)) {
Tejun Heo7b70fc02006-05-15 20:58:07 +0900932 qc->flags |= ATA_QCFLAG_FAILED;
933 ata_qc_complete(qc);
934 nr_aborted++;
935 }
936 }
937
938 if (!nr_aborted)
939 ata_port_schedule_eh(ap);
940
941 return nr_aborted;
942}
943
Tejun Heoe3180492006-05-15 20:58:09 +0900944/**
Tejun Heodbd82612007-08-06 18:36:23 +0900945 * ata_link_abort - abort all qc's on the link
946 * @link: ATA link to abort qc's for
947 *
948 * Abort all active qc's active on @link and schedule EH.
949 *
950 * LOCKING:
951 * spin_lock_irqsave(host lock)
952 *
953 * RETURNS:
954 * Number of aborted qc's.
955 */
956int ata_link_abort(struct ata_link *link)
957{
958 return ata_do_link_abort(link->ap, link);
959}
960
961/**
962 * ata_port_abort - abort all qc's on the port
963 * @ap: ATA port to abort qc's for
964 *
965 * Abort all active qc's of @ap and schedule EH.
966 *
967 * LOCKING:
968 * spin_lock_irqsave(host_set lock)
969 *
970 * RETURNS:
971 * Number of aborted qc's.
972 */
973int ata_port_abort(struct ata_port *ap)
974{
975 return ata_do_link_abort(ap, NULL);
976}
977
978/**
Tejun Heoe3180492006-05-15 20:58:09 +0900979 * __ata_port_freeze - freeze port
980 * @ap: ATA port to freeze
981 *
982 * This function is called when HSM violation or some other
983 * condition disrupts normal operation of the port. Frozen port
984 * is not allowed to perform any operation until the port is
985 * thawed, which usually follows a successful reset.
986 *
987 * ap->ops->freeze() callback can be used for freezing the port
988 * hardware-wise (e.g. mask interrupt and stop DMA engine). If a
989 * port cannot be frozen hardware-wise, the interrupt handler
990 * must ack and clear interrupts unconditionally while the port
991 * is frozen.
992 *
993 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400994 * spin_lock_irqsave(host lock)
Tejun Heoe3180492006-05-15 20:58:09 +0900995 */
996static void __ata_port_freeze(struct ata_port *ap)
997{
998 WARN_ON(!ap->ops->error_handler);
999
1000 if (ap->ops->freeze)
1001 ap->ops->freeze(ap);
1002
Tejun Heob51e9e52006-06-29 01:29:30 +09001003 ap->pflags |= ATA_PFLAG_FROZEN;
Tejun Heoe3180492006-05-15 20:58:09 +09001004
Tejun Heo44877b42007-02-21 01:06:51 +09001005 DPRINTK("ata%u port frozen\n", ap->print_id);
Tejun Heoe3180492006-05-15 20:58:09 +09001006}
1007
1008/**
1009 * ata_port_freeze - abort & freeze port
1010 * @ap: ATA port to freeze
1011 *
Jeff Garzik54c38442009-04-07 19:13:15 -04001012 * Abort and freeze @ap. The freeze operation must be called
1013 * first, because some hardware requires special operations
1014 * before the taskfile registers are accessible.
Tejun Heoe3180492006-05-15 20:58:09 +09001015 *
1016 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001017 * spin_lock_irqsave(host lock)
Tejun Heoe3180492006-05-15 20:58:09 +09001018 *
1019 * RETURNS:
1020 * Number of aborted commands.
1021 */
1022int ata_port_freeze(struct ata_port *ap)
1023{
1024 int nr_aborted;
1025
1026 WARN_ON(!ap->ops->error_handler);
1027
Tejun Heoe3180492006-05-15 20:58:09 +09001028 __ata_port_freeze(ap);
Jeff Garzik54c38442009-04-07 19:13:15 -04001029 nr_aborted = ata_port_abort(ap);
Tejun Heoe3180492006-05-15 20:58:09 +09001030
1031 return nr_aborted;
1032}
1033
1034/**
Tejun Heo7d77b242007-09-23 13:14:13 +09001035 * sata_async_notification - SATA async notification handler
1036 * @ap: ATA port where async notification is received
1037 *
1038 * Handler to be called when async notification via SDB FIS is
1039 * received. This function schedules EH if necessary.
1040 *
1041 * LOCKING:
1042 * spin_lock_irqsave(host lock)
1043 *
1044 * RETURNS:
1045 * 1 if EH is scheduled, 0 otherwise.
1046 */
1047int sata_async_notification(struct ata_port *ap)
1048{
1049 u32 sntf;
1050 int rc;
1051
1052 if (!(ap->flags & ATA_FLAG_AN))
1053 return 0;
1054
1055 rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1056 if (rc == 0)
1057 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1058
Tejun Heo071f44b2008-04-07 22:47:22 +09001059 if (!sata_pmp_attached(ap) || rc) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001060 /* PMP is not attached or SNTF is not available */
Tejun Heo071f44b2008-04-07 22:47:22 +09001061 if (!sata_pmp_attached(ap)) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001062 /* PMP is not attached. Check whether ATAPI
1063 * AN is configured. If so, notify media
1064 * change.
1065 */
1066 struct ata_device *dev = ap->link.device;
1067
1068 if ((dev->class == ATA_DEV_ATAPI) &&
1069 (dev->flags & ATA_DFLAG_AN))
1070 ata_scsi_media_change_notify(dev);
1071 return 0;
1072 } else {
1073 /* PMP is attached but SNTF is not available.
1074 * ATAPI async media change notification is
1075 * not used. The PMP must be reporting PHY
1076 * status change, schedule EH.
1077 */
1078 ata_port_schedule_eh(ap);
1079 return 1;
1080 }
1081 } else {
1082 /* PMP is attached and SNTF is available */
1083 struct ata_link *link;
1084
1085 /* check and notify ATAPI AN */
Tejun Heo1eca4362008-11-03 20:03:17 +09001086 ata_for_each_link(link, ap, EDGE) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001087 if (!(sntf & (1 << link->pmp)))
1088 continue;
1089
1090 if ((link->device->class == ATA_DEV_ATAPI) &&
1091 (link->device->flags & ATA_DFLAG_AN))
1092 ata_scsi_media_change_notify(link->device);
1093 }
1094
1095 /* If PMP is reporting that PHY status of some
1096 * downstream ports has changed, schedule EH.
1097 */
1098 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
1099 ata_port_schedule_eh(ap);
1100 return 1;
1101 }
1102
1103 return 0;
1104 }
1105}
1106
1107/**
Tejun Heoe3180492006-05-15 20:58:09 +09001108 * ata_eh_freeze_port - EH helper to freeze port
1109 * @ap: ATA port to freeze
1110 *
1111 * Freeze @ap.
1112 *
1113 * LOCKING:
1114 * None.
1115 */
1116void ata_eh_freeze_port(struct ata_port *ap)
1117{
1118 unsigned long flags;
1119
1120 if (!ap->ops->error_handler)
1121 return;
1122
Jeff Garzikba6a1302006-06-22 23:46:10 -04001123 spin_lock_irqsave(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001124 __ata_port_freeze(ap);
Jeff Garzikba6a1302006-06-22 23:46:10 -04001125 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001126}
1127
1128/**
1129 * ata_port_thaw_port - EH helper to thaw port
1130 * @ap: ATA port to thaw
1131 *
1132 * Thaw frozen port @ap.
1133 *
1134 * LOCKING:
1135 * None.
1136 */
1137void ata_eh_thaw_port(struct ata_port *ap)
1138{
1139 unsigned long flags;
1140
1141 if (!ap->ops->error_handler)
1142 return;
1143
Jeff Garzikba6a1302006-06-22 23:46:10 -04001144 spin_lock_irqsave(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001145
Tejun Heob51e9e52006-06-29 01:29:30 +09001146 ap->pflags &= ~ATA_PFLAG_FROZEN;
Tejun Heoe3180492006-05-15 20:58:09 +09001147
1148 if (ap->ops->thaw)
1149 ap->ops->thaw(ap);
1150
Jeff Garzikba6a1302006-06-22 23:46:10 -04001151 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001152
Tejun Heo44877b42007-02-21 01:06:51 +09001153 DPRINTK("ata%u port thawed\n", ap->print_id);
Tejun Heoe3180492006-05-15 20:58:09 +09001154}
1155
Tejun Heoece1d632006-04-02 18:51:53 +09001156static void ata_eh_scsidone(struct scsi_cmnd *scmd)
1157{
1158 /* nada */
1159}
1160
1161static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
1162{
1163 struct ata_port *ap = qc->ap;
1164 struct scsi_cmnd *scmd = qc->scsicmd;
1165 unsigned long flags;
1166
Jeff Garzikba6a1302006-06-22 23:46:10 -04001167 spin_lock_irqsave(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +09001168 qc->scsidone = ata_eh_scsidone;
1169 __ata_qc_complete(qc);
1170 WARN_ON(ata_tag_valid(qc->tag));
Jeff Garzikba6a1302006-06-22 23:46:10 -04001171 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +09001172
1173 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
1174}
1175
1176/**
1177 * ata_eh_qc_complete - Complete an active ATA command from EH
1178 * @qc: Command to complete
1179 *
1180 * Indicate to the mid and upper layers that an ATA command has
1181 * completed. To be used from EH.
1182 */
1183void ata_eh_qc_complete(struct ata_queued_cmd *qc)
1184{
1185 struct scsi_cmnd *scmd = qc->scsicmd;
1186 scmd->retries = scmd->allowed;
1187 __ata_eh_qc_complete(qc);
1188}
1189
1190/**
1191 * ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
1192 * @qc: Command to retry
1193 *
1194 * Indicate to the mid and upper layers that an ATA command
1195 * should be retried. To be used from EH.
1196 *
1197 * SCSI midlayer limits the number of retries to scmd->allowed.
1198 * scmd->retries is decremented for commands which get retried
1199 * due to unrelated failures (qc->err_mask is zero).
1200 */
1201void ata_eh_qc_retry(struct ata_queued_cmd *qc)
1202{
1203 struct scsi_cmnd *scmd = qc->scsicmd;
1204 if (!qc->err_mask && scmd->retries)
1205 scmd->retries--;
1206 __ata_eh_qc_complete(qc);
1207}
Tejun Heo022bdb02006-05-15 20:58:22 +09001208
1209/**
Tejun Heo678afac2009-01-29 20:31:30 +09001210 * ata_dev_disable - disable ATA device
1211 * @dev: ATA device to disable
1212 *
1213 * Disable @dev.
1214 *
1215 * Locking:
1216 * EH context.
1217 */
1218void ata_dev_disable(struct ata_device *dev)
1219{
1220 if (!ata_dev_enabled(dev))
1221 return;
1222
1223 if (ata_msg_drv(dev->link->ap))
1224 ata_dev_printk(dev, KERN_WARNING, "disabled\n");
1225 ata_acpi_on_disable(dev);
1226 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET);
1227 dev->class++;
Tejun Heo99cf6102009-01-29 20:31:32 +09001228
1229 /* From now till the next successful probe, ering is used to
1230 * track probe failures. Clear accumulated device error info.
1231 */
1232 ata_ering_clear(&dev->ering);
Tejun Heo678afac2009-01-29 20:31:30 +09001233}
1234
1235/**
Tejun Heo0ea035a2006-05-31 18:28:01 +09001236 * ata_eh_detach_dev - detach ATA device
1237 * @dev: ATA device to detach
1238 *
1239 * Detach @dev.
1240 *
1241 * LOCKING:
1242 * None.
1243 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001244void ata_eh_detach_dev(struct ata_device *dev)
Tejun Heo0ea035a2006-05-31 18:28:01 +09001245{
Tejun Heof58229f2007-08-06 18:36:23 +09001246 struct ata_link *link = dev->link;
1247 struct ata_port *ap = link->ap;
Tejun Heo90484eb2008-10-26 15:43:03 +09001248 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo0ea035a2006-05-31 18:28:01 +09001249 unsigned long flags;
1250
1251 ata_dev_disable(dev);
1252
Jeff Garzikba6a1302006-06-22 23:46:10 -04001253 spin_lock_irqsave(ap->lock, flags);
Tejun Heo0ea035a2006-05-31 18:28:01 +09001254
1255 dev->flags &= ~ATA_DFLAG_DETACH;
1256
1257 if (ata_scsi_offline_dev(dev)) {
1258 dev->flags |= ATA_DFLAG_DETACHED;
Tejun Heob51e9e52006-06-29 01:29:30 +09001259 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
Tejun Heo0ea035a2006-05-31 18:28:01 +09001260 }
1261
Tejun Heo90484eb2008-10-26 15:43:03 +09001262 /* clear per-dev EH info */
Tejun Heof58229f2007-08-06 18:36:23 +09001263 ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
1264 ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
Tejun Heo90484eb2008-10-26 15:43:03 +09001265 ehc->saved_xfer_mode[dev->devno] = 0;
1266 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
Tejun Heobeb07c12006-06-24 20:30:19 +09001267
Jeff Garzikba6a1302006-06-22 23:46:10 -04001268 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo0ea035a2006-05-31 18:28:01 +09001269}
1270
1271/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001272 * ata_eh_about_to_do - about to perform eh_action
Tejun Heo955e57d2007-08-06 18:36:23 +09001273 * @link: target ATA link
Tejun Heo47005f22006-06-19 18:27:23 +09001274 * @dev: target ATA dev for per-dev action (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09001275 * @action: action about to be performed
1276 *
1277 * Called just before performing EH actions to clear related bits
Tejun Heo955e57d2007-08-06 18:36:23 +09001278 * in @link->eh_info such that eh actions are not unnecessarily
1279 * repeated.
Tejun Heo022bdb02006-05-15 20:58:22 +09001280 *
1281 * LOCKING:
1282 * None.
1283 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001284void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
1285 unsigned int action)
Tejun Heo022bdb02006-05-15 20:58:22 +09001286{
Tejun Heo955e57d2007-08-06 18:36:23 +09001287 struct ata_port *ap = link->ap;
1288 struct ata_eh_info *ehi = &link->eh_info;
1289 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09001290 unsigned long flags;
1291
Jeff Garzikba6a1302006-06-22 23:46:10 -04001292 spin_lock_irqsave(ap->lock, flags);
Tejun Heo1cdaf532006-07-03 16:07:26 +09001293
Tejun Heo955e57d2007-08-06 18:36:23 +09001294 ata_eh_clear_action(link, dev, ehi, action);
Tejun Heo13abf502006-07-10 23:18:46 +09001295
Tejun Heoa568d1d2008-10-21 20:37:21 +09001296 /* About to take EH action, set RECOVERED. Ignore actions on
1297 * slave links as master will do them again.
1298 */
1299 if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link)
Tejun Heo1cdaf532006-07-03 16:07:26 +09001300 ap->pflags |= ATA_PFLAG_RECOVERED;
1301
Jeff Garzikba6a1302006-06-22 23:46:10 -04001302 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo022bdb02006-05-15 20:58:22 +09001303}
1304
1305/**
Tejun Heo47005f22006-06-19 18:27:23 +09001306 * ata_eh_done - EH action complete
Tejun Heo955e57d2007-08-06 18:36:23 +09001307* @ap: target ATA port
Tejun Heo47005f22006-06-19 18:27:23 +09001308 * @dev: target ATA dev for per-dev action (can be NULL)
1309 * @action: action just completed
1310 *
1311 * Called right after performing EH actions to clear related bits
Tejun Heo955e57d2007-08-06 18:36:23 +09001312 * in @link->eh_context.
Tejun Heo47005f22006-06-19 18:27:23 +09001313 *
1314 * LOCKING:
1315 * None.
1316 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001317void ata_eh_done(struct ata_link *link, struct ata_device *dev,
1318 unsigned int action)
Tejun Heo47005f22006-06-19 18:27:23 +09001319{
Tejun Heo955e57d2007-08-06 18:36:23 +09001320 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001321
Tejun Heo955e57d2007-08-06 18:36:23 +09001322 ata_eh_clear_action(link, dev, &ehc->i, action);
Tejun Heo47005f22006-06-19 18:27:23 +09001323}
1324
1325/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001326 * ata_err_string - convert err_mask to descriptive string
1327 * @err_mask: error mask to convert to string
1328 *
1329 * Convert @err_mask to descriptive string. Errors are
1330 * prioritized according to severity and only the most severe
1331 * error is reported.
1332 *
1333 * LOCKING:
1334 * None.
1335 *
1336 * RETURNS:
1337 * Descriptive string for @err_mask
1338 */
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001339static const char *ata_err_string(unsigned int err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09001340{
1341 if (err_mask & AC_ERR_HOST_BUS)
1342 return "host bus error";
1343 if (err_mask & AC_ERR_ATA_BUS)
1344 return "ATA bus error";
1345 if (err_mask & AC_ERR_TIMEOUT)
1346 return "timeout";
1347 if (err_mask & AC_ERR_HSM)
1348 return "HSM violation";
1349 if (err_mask & AC_ERR_SYSTEM)
1350 return "internal error";
1351 if (err_mask & AC_ERR_MEDIA)
1352 return "media error";
1353 if (err_mask & AC_ERR_INVALID)
1354 return "invalid argument";
1355 if (err_mask & AC_ERR_DEV)
1356 return "device error";
1357 return "unknown error";
1358}
1359
1360/**
Tejun Heoe8ee8452006-05-15 21:03:46 +09001361 * ata_read_log_page - read a specific log page
1362 * @dev: target device
1363 * @page: page to read
1364 * @buf: buffer to store read page
1365 * @sectors: number of sectors to read
1366 *
1367 * Read log page using READ_LOG_EXT command.
1368 *
1369 * LOCKING:
1370 * Kernel thread context (may sleep).
1371 *
1372 * RETURNS:
1373 * 0 on success, AC_ERR_* mask otherwise.
1374 */
1375static unsigned int ata_read_log_page(struct ata_device *dev,
1376 u8 page, void *buf, unsigned int sectors)
1377{
1378 struct ata_taskfile tf;
1379 unsigned int err_mask;
1380
1381 DPRINTK("read log page - page %d\n", page);
1382
1383 ata_tf_init(dev, &tf);
1384 tf.command = ATA_CMD_READ_LOG_EXT;
1385 tf.lbal = page;
1386 tf.nsect = sectors;
1387 tf.hob_nsect = sectors >> 8;
1388 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
1389 tf.protocol = ATA_PROT_PIO;
1390
1391 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
Tejun Heo2b789102007-10-09 15:05:44 +09001392 buf, sectors * ATA_SECT_SIZE, 0);
Tejun Heoe8ee8452006-05-15 21:03:46 +09001393
1394 DPRINTK("EXIT, err_mask=%x\n", err_mask);
1395 return err_mask;
1396}
1397
1398/**
1399 * ata_eh_read_log_10h - Read log page 10h for NCQ error details
1400 * @dev: Device to read log page 10h from
1401 * @tag: Resulting tag of the failed command
1402 * @tf: Resulting taskfile registers of the failed command
1403 *
1404 * Read log page 10h to obtain NCQ error details and clear error
1405 * condition.
1406 *
1407 * LOCKING:
1408 * Kernel thread context (may sleep).
1409 *
1410 * RETURNS:
1411 * 0 on success, -errno otherwise.
1412 */
1413static int ata_eh_read_log_10h(struct ata_device *dev,
1414 int *tag, struct ata_taskfile *tf)
1415{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001416 u8 *buf = dev->link->ap->sector_buf;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001417 unsigned int err_mask;
1418 u8 csum;
1419 int i;
1420
1421 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1);
1422 if (err_mask)
1423 return -EIO;
1424
1425 csum = 0;
1426 for (i = 0; i < ATA_SECT_SIZE; i++)
1427 csum += buf[i];
1428 if (csum)
1429 ata_dev_printk(dev, KERN_WARNING,
1430 "invalid checksum 0x%x on log page 10h\n", csum);
1431
1432 if (buf[0] & 0x80)
1433 return -ENOENT;
1434
1435 *tag = buf[0] & 0x1f;
1436
1437 tf->command = buf[2];
1438 tf->feature = buf[3];
1439 tf->lbal = buf[4];
1440 tf->lbam = buf[5];
1441 tf->lbah = buf[6];
1442 tf->device = buf[7];
1443 tf->hob_lbal = buf[8];
1444 tf->hob_lbam = buf[9];
1445 tf->hob_lbah = buf[10];
1446 tf->nsect = buf[12];
1447 tf->hob_nsect = buf[13];
1448
1449 return 0;
1450}
1451
1452/**
Tejun Heo11fc33d2008-08-30 14:20:01 +02001453 * atapi_eh_tur - perform ATAPI TEST_UNIT_READY
1454 * @dev: target ATAPI device
1455 * @r_sense_key: out parameter for sense_key
1456 *
1457 * Perform ATAPI TEST_UNIT_READY.
1458 *
1459 * LOCKING:
1460 * EH context (may sleep).
1461 *
1462 * RETURNS:
1463 * 0 on success, AC_ERR_* mask on failure.
1464 */
1465static unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
1466{
1467 u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 };
1468 struct ata_taskfile tf;
1469 unsigned int err_mask;
1470
1471 ata_tf_init(dev, &tf);
1472
1473 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1474 tf.command = ATA_CMD_PACKET;
1475 tf.protocol = ATAPI_PROT_NODATA;
1476
1477 err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
1478 if (err_mask == AC_ERR_DEV)
1479 *r_sense_key = tf.feature >> 4;
1480 return err_mask;
1481}
1482
1483/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001484 * atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
1485 * @dev: device to perform REQUEST_SENSE to
1486 * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
Tejun Heo3eabddb2008-06-10 18:28:05 +09001487 * @dfl_sense_key: default sense key to use
Tejun Heo022bdb02006-05-15 20:58:22 +09001488 *
1489 * Perform ATAPI REQUEST_SENSE after the device reported CHECK
1490 * SENSE. This function is EH helper.
1491 *
1492 * LOCKING:
1493 * Kernel thread context (may sleep).
1494 *
1495 * RETURNS:
1496 * 0 on success, AC_ERR_* mask on failure
1497 */
Tejun Heo3eabddb2008-06-10 18:28:05 +09001498static unsigned int atapi_eh_request_sense(struct ata_device *dev,
1499 u8 *sense_buf, u8 dfl_sense_key)
Tejun Heo022bdb02006-05-15 20:58:22 +09001500{
Tejun Heo3eabddb2008-06-10 18:28:05 +09001501 u8 cdb[ATAPI_CDB_LEN] =
1502 { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 };
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001503 struct ata_port *ap = dev->link->ap;
Tejun Heo022bdb02006-05-15 20:58:22 +09001504 struct ata_taskfile tf;
Tejun Heo022bdb02006-05-15 20:58:22 +09001505
1506 DPRINTK("ATAPI request sense\n");
1507
Tejun Heo022bdb02006-05-15 20:58:22 +09001508 /* FIXME: is this needed? */
1509 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
1510
Albert Lee56287762007-04-02 11:30:46 +08001511 /* initialize sense_buf with the error register,
1512 * for the case where they are -not- overwritten
1513 */
Tejun Heo022bdb02006-05-15 20:58:22 +09001514 sense_buf[0] = 0x70;
Tejun Heo3eabddb2008-06-10 18:28:05 +09001515 sense_buf[2] = dfl_sense_key;
Albert Lee56287762007-04-02 11:30:46 +08001516
Jeff Garzika617c092007-05-21 20:14:23 -04001517 /* some devices time out if garbage left in tf */
Albert Lee56287762007-04-02 11:30:46 +08001518 ata_tf_init(dev, &tf);
Tejun Heo022bdb02006-05-15 20:58:22 +09001519
Tejun Heo022bdb02006-05-15 20:58:22 +09001520 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1521 tf.command = ATA_CMD_PACKET;
1522
1523 /* is it pointless to prefer PIO for "safety reasons"? */
1524 if (ap->flags & ATA_FLAG_PIO_DMA) {
Tejun Heo0dc36882007-12-18 16:34:43 -05001525 tf.protocol = ATAPI_PROT_DMA;
Tejun Heo022bdb02006-05-15 20:58:22 +09001526 tf.feature |= ATAPI_PKT_DMA;
1527 } else {
Tejun Heo0dc36882007-12-18 16:34:43 -05001528 tf.protocol = ATAPI_PROT_PIO;
Tejun Heof2dfc1a2007-12-12 12:12:46 +09001529 tf.lbam = SCSI_SENSE_BUFFERSIZE;
1530 tf.lbah = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09001531 }
1532
1533 return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
Tejun Heo2b789102007-10-09 15:05:44 +09001534 sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
Tejun Heo022bdb02006-05-15 20:58:22 +09001535}
1536
1537/**
1538 * ata_eh_analyze_serror - analyze SError for a failed port
Tejun Heo02607312007-08-06 18:36:23 +09001539 * @link: ATA link to analyze SError for
Tejun Heo022bdb02006-05-15 20:58:22 +09001540 *
1541 * Analyze SError if available and further determine cause of
1542 * failure.
1543 *
1544 * LOCKING:
1545 * None.
1546 */
Tejun Heo02607312007-08-06 18:36:23 +09001547static void ata_eh_analyze_serror(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09001548{
Tejun Heo02607312007-08-06 18:36:23 +09001549 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09001550 u32 serror = ehc->i.serror;
1551 unsigned int err_mask = 0, action = 0;
Tejun Heof9df58c2007-09-23 13:14:13 +09001552 u32 hotplug_mask;
Tejun Heo022bdb02006-05-15 20:58:22 +09001553
Tejun Heoe0614db2008-05-19 01:15:09 +09001554 if (serror & (SERR_PERSISTENT | SERR_DATA)) {
Tejun Heo022bdb02006-05-15 20:58:22 +09001555 err_mask |= AC_ERR_ATA_BUS;
Tejun Heocf480622008-01-24 00:05:14 +09001556 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001557 }
1558 if (serror & SERR_PROTOCOL) {
1559 err_mask |= AC_ERR_HSM;
Tejun Heocf480622008-01-24 00:05:14 +09001560 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001561 }
1562 if (serror & SERR_INTERNAL) {
1563 err_mask |= AC_ERR_SYSTEM;
Tejun Heocf480622008-01-24 00:05:14 +09001564 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001565 }
Tejun Heof9df58c2007-09-23 13:14:13 +09001566
1567 /* Determine whether a hotplug event has occurred. Both
1568 * SError.N/X are considered hotplug events for enabled or
1569 * host links. For disabled PMP links, only N bit is
1570 * considered as X bit is left at 1 for link plugging.
1571 */
1572 hotplug_mask = 0;
1573
1574 if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
1575 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
1576 else
1577 hotplug_mask = SERR_PHYRDY_CHG;
1578
1579 if (serror & hotplug_mask)
Tejun Heo084fe632006-05-31 18:28:03 +09001580 ata_ehi_hotplugged(&ehc->i);
Tejun Heo022bdb02006-05-15 20:58:22 +09001581
1582 ehc->i.err_mask |= err_mask;
1583 ehc->i.action |= action;
1584}
1585
1586/**
Tejun Heoe8ee8452006-05-15 21:03:46 +09001587 * ata_eh_analyze_ncq_error - analyze NCQ error
Tejun Heo02607312007-08-06 18:36:23 +09001588 * @link: ATA link to analyze NCQ error for
Tejun Heoe8ee8452006-05-15 21:03:46 +09001589 *
1590 * Read log page 10h, determine the offending qc and acquire
1591 * error status TF. For NCQ device errors, all LLDDs have to do
1592 * is setting AC_ERR_DEV in ehi->err_mask. This function takes
1593 * care of the rest.
1594 *
1595 * LOCKING:
1596 * Kernel thread context (may sleep).
1597 */
Mark Lord10acf3b2008-05-02 02:14:53 -04001598void ata_eh_analyze_ncq_error(struct ata_link *link)
Tejun Heoe8ee8452006-05-15 21:03:46 +09001599{
Tejun Heo02607312007-08-06 18:36:23 +09001600 struct ata_port *ap = link->ap;
1601 struct ata_eh_context *ehc = &link->eh_context;
1602 struct ata_device *dev = link->device;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001603 struct ata_queued_cmd *qc;
1604 struct ata_taskfile tf;
1605 int tag, rc;
1606
1607 /* if frozen, we can't do much */
Tejun Heob51e9e52006-06-29 01:29:30 +09001608 if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heoe8ee8452006-05-15 21:03:46 +09001609 return;
1610
1611 /* is it NCQ device error? */
Tejun Heo02607312007-08-06 18:36:23 +09001612 if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
Tejun Heoe8ee8452006-05-15 21:03:46 +09001613 return;
1614
1615 /* has LLDD analyzed already? */
1616 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1617 qc = __ata_qc_from_tag(ap, tag);
1618
1619 if (!(qc->flags & ATA_QCFLAG_FAILED))
1620 continue;
1621
1622 if (qc->err_mask)
1623 return;
1624 }
1625
1626 /* okay, this error is ours */
1627 rc = ata_eh_read_log_10h(dev, &tag, &tf);
1628 if (rc) {
Tejun Heo02607312007-08-06 18:36:23 +09001629 ata_link_printk(link, KERN_ERR, "failed to read log page 10h "
Tejun Heoe8ee8452006-05-15 21:03:46 +09001630 "(errno=%d)\n", rc);
1631 return;
1632 }
1633
Tejun Heo02607312007-08-06 18:36:23 +09001634 if (!(link->sactive & (1 << tag))) {
1635 ata_link_printk(link, KERN_ERR, "log page 10h reported "
Tejun Heoe8ee8452006-05-15 21:03:46 +09001636 "inactive tag %d\n", tag);
1637 return;
1638 }
1639
1640 /* we've got the perpetrator, condemn it */
1641 qc = __ata_qc_from_tag(ap, tag);
1642 memcpy(&qc->result_tf, &tf, sizeof(tf));
Mark Lorda6116c92008-04-23 22:36:25 -04001643 qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
Tejun Heo5335b722007-07-16 14:29:40 +09001644 qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001645 ehc->i.err_mask &= ~AC_ERR_DEV;
1646}
1647
1648/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001649 * ata_eh_analyze_tf - analyze taskfile of a failed qc
1650 * @qc: qc to analyze
1651 * @tf: Taskfile registers to analyze
1652 *
1653 * Analyze taskfile of @qc and further determine cause of
1654 * failure. This function also requests ATAPI sense data if
1655 * avaliable.
1656 *
1657 * LOCKING:
1658 * Kernel thread context (may sleep).
1659 *
1660 * RETURNS:
1661 * Determined recovery action
1662 */
1663static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
1664 const struct ata_taskfile *tf)
1665{
1666 unsigned int tmp, action = 0;
1667 u8 stat = tf->command, err = tf->feature;
1668
1669 if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
1670 qc->err_mask |= AC_ERR_HSM;
Tejun Heocf480622008-01-24 00:05:14 +09001671 return ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001672 }
1673
Tejun Heoa51d6442007-03-20 15:24:11 +09001674 if (stat & (ATA_ERR | ATA_DF))
1675 qc->err_mask |= AC_ERR_DEV;
1676 else
Tejun Heo022bdb02006-05-15 20:58:22 +09001677 return 0;
1678
1679 switch (qc->dev->class) {
1680 case ATA_DEV_ATA:
1681 if (err & ATA_ICRC)
1682 qc->err_mask |= AC_ERR_ATA_BUS;
1683 if (err & ATA_UNC)
1684 qc->err_mask |= AC_ERR_MEDIA;
1685 if (err & ATA_IDNF)
1686 qc->err_mask |= AC_ERR_INVALID;
1687 break;
1688
1689 case ATA_DEV_ATAPI:
Tejun Heoa569a302006-11-21 10:40:51 +09001690 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
Tejun Heo3eabddb2008-06-10 18:28:05 +09001691 tmp = atapi_eh_request_sense(qc->dev,
1692 qc->scsicmd->sense_buffer,
1693 qc->result_tf.feature >> 4);
Tejun Heoa569a302006-11-21 10:40:51 +09001694 if (!tmp) {
1695 /* ATA_QCFLAG_SENSE_VALID is used to
1696 * tell atapi_qc_complete() that sense
1697 * data is already valid.
1698 *
1699 * TODO: interpret sense data and set
1700 * appropriate err_mask.
1701 */
1702 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1703 } else
1704 qc->err_mask |= tmp;
1705 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001706 }
1707
1708 if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
Tejun Heocf480622008-01-24 00:05:14 +09001709 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001710
1711 return action;
1712}
1713
Tejun Heo76326ac2007-11-27 19:28:59 +09001714static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
1715 int *xfer_ok)
Tejun Heo022bdb02006-05-15 20:58:22 +09001716{
Tejun Heo76326ac2007-11-27 19:28:59 +09001717 int base = 0;
1718
1719 if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
1720 *xfer_ok = 1;
1721
1722 if (!*xfer_ok)
Tejun Heo75f9caf2008-01-03 01:21:14 +09001723 base = ATA_ECAT_DUBIOUS_NONE;
Tejun Heo76326ac2007-11-27 19:28:59 +09001724
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001725 if (err_mask & AC_ERR_ATA_BUS)
Tejun Heo76326ac2007-11-27 19:28:59 +09001726 return base + ATA_ECAT_ATA_BUS;
Tejun Heo022bdb02006-05-15 20:58:22 +09001727
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001728 if (err_mask & AC_ERR_TIMEOUT)
Tejun Heo76326ac2007-11-27 19:28:59 +09001729 return base + ATA_ECAT_TOUT_HSM;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001730
Tejun Heo3884f7b2007-11-27 19:28:56 +09001731 if (eflags & ATA_EFLAG_IS_IO) {
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001732 if (err_mask & AC_ERR_HSM)
Tejun Heo76326ac2007-11-27 19:28:59 +09001733 return base + ATA_ECAT_TOUT_HSM;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001734 if ((err_mask &
1735 (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
Tejun Heo76326ac2007-11-27 19:28:59 +09001736 return base + ATA_ECAT_UNK_DEV;
Tejun Heo022bdb02006-05-15 20:58:22 +09001737 }
1738
1739 return 0;
1740}
1741
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001742struct speed_down_verdict_arg {
Tejun Heo022bdb02006-05-15 20:58:22 +09001743 u64 since;
Tejun Heo76326ac2007-11-27 19:28:59 +09001744 int xfer_ok;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001745 int nr_errors[ATA_ECAT_NR];
Tejun Heo022bdb02006-05-15 20:58:22 +09001746};
1747
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001748static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
Tejun Heo022bdb02006-05-15 20:58:22 +09001749{
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001750 struct speed_down_verdict_arg *arg = void_arg;
Tejun Heo76326ac2007-11-27 19:28:59 +09001751 int cat;
Tejun Heo022bdb02006-05-15 20:58:22 +09001752
1753 if (ent->timestamp < arg->since)
1754 return -1;
1755
Tejun Heo76326ac2007-11-27 19:28:59 +09001756 cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
1757 &arg->xfer_ok);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001758 arg->nr_errors[cat]++;
Tejun Heo76326ac2007-11-27 19:28:59 +09001759
Tejun Heo022bdb02006-05-15 20:58:22 +09001760 return 0;
1761}
1762
1763/**
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001764 * ata_eh_speed_down_verdict - Determine speed down verdict
Tejun Heo022bdb02006-05-15 20:58:22 +09001765 * @dev: Device of interest
1766 *
1767 * This function examines error ring of @dev and determines
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001768 * whether NCQ needs to be turned off, transfer speed should be
1769 * stepped down, or falling back to PIO is necessary.
Tejun Heo022bdb02006-05-15 20:58:22 +09001770 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001771 * ECAT_ATA_BUS : ATA_BUS error for any command
Tejun Heo022bdb02006-05-15 20:58:22 +09001772 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001773 * ECAT_TOUT_HSM : TIMEOUT for any command or HSM violation for
1774 * IO commands
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001775 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001776 * ECAT_UNK_DEV : Unknown DEV error for IO commands
Tejun Heo022bdb02006-05-15 20:58:22 +09001777 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001778 * ECAT_DUBIOUS_* : Identical to above three but occurred while
1779 * data transfer hasn't been verified.
1780 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001781 * Verdicts are
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001782 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001783 * NCQ_OFF : Turn off NCQ.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001784 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001785 * SPEED_DOWN : Speed down transfer speed but don't fall back
1786 * to PIO.
1787 *
1788 * FALLBACK_TO_PIO : Fall back to PIO.
1789 *
1790 * Even if multiple verdicts are returned, only one action is
Tejun Heo76326ac2007-11-27 19:28:59 +09001791 * taken per error. An action triggered by non-DUBIOUS errors
1792 * clears ering, while one triggered by DUBIOUS_* errors doesn't.
1793 * This is to expedite speed down decisions right after device is
1794 * initially configured.
Tejun Heo3884f7b2007-11-27 19:28:56 +09001795 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001796 * The followings are speed down rules. #1 and #2 deal with
1797 * DUBIOUS errors.
1798 *
1799 * 1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors
1800 * occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO.
1801 *
1802 * 2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors
1803 * occurred during last 5 mins, NCQ_OFF.
1804 *
1805 * 3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
Tejun Heo3884f7b2007-11-27 19:28:56 +09001806 * ocurred during last 5 mins, FALLBACK_TO_PIO
1807 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001808 * 4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
Tejun Heo3884f7b2007-11-27 19:28:56 +09001809 * during last 10 mins, NCQ_OFF.
1810 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001811 * 5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6
Tejun Heo3884f7b2007-11-27 19:28:56 +09001812 * UNK_DEV errors occurred during last 10 mins, SPEED_DOWN.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001813 *
Tejun Heo022bdb02006-05-15 20:58:22 +09001814 * LOCKING:
1815 * Inherited from caller.
1816 *
1817 * RETURNS:
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001818 * OR of ATA_EH_SPDN_* flags.
Tejun Heo022bdb02006-05-15 20:58:22 +09001819 */
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001820static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
Tejun Heo022bdb02006-05-15 20:58:22 +09001821{
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001822 const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
1823 u64 j64 = get_jiffies_64();
1824 struct speed_down_verdict_arg arg;
1825 unsigned int verdict = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09001826
Tejun Heo3884f7b2007-11-27 19:28:56 +09001827 /* scan past 5 mins of error history */
1828 memset(&arg, 0, sizeof(arg));
1829 arg.since = j64 - min(j64, j5mins);
1830 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1831
Tejun Heo76326ac2007-11-27 19:28:59 +09001832 if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
1833 arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
1834 verdict |= ATA_EH_SPDN_SPEED_DOWN |
1835 ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
1836
1837 if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
1838 arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
1839 verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
1840
Tejun Heo3884f7b2007-11-27 19:28:56 +09001841 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1842 arg.nr_errors[ATA_ECAT_TOUT_HSM] +
Tejun Heo663f99b2007-11-27 19:28:57 +09001843 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
Tejun Heo3884f7b2007-11-27 19:28:56 +09001844 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
1845
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001846 /* scan past 10 mins of error history */
Tejun Heo022bdb02006-05-15 20:58:22 +09001847 memset(&arg, 0, sizeof(arg));
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001848 arg.since = j64 - min(j64, j10mins);
1849 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
Tejun Heo022bdb02006-05-15 20:58:22 +09001850
Tejun Heo3884f7b2007-11-27 19:28:56 +09001851 if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1852 arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001853 verdict |= ATA_EH_SPDN_NCQ_OFF;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001854
1855 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1856 arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
Tejun Heo663f99b2007-11-27 19:28:57 +09001857 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001858 verdict |= ATA_EH_SPDN_SPEED_DOWN;
Tejun Heo022bdb02006-05-15 20:58:22 +09001859
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001860 return verdict;
Tejun Heo022bdb02006-05-15 20:58:22 +09001861}
1862
1863/**
1864 * ata_eh_speed_down - record error and speed down if necessary
1865 * @dev: Failed device
Tejun Heo3884f7b2007-11-27 19:28:56 +09001866 * @eflags: mask of ATA_EFLAG_* flags
Tejun Heo022bdb02006-05-15 20:58:22 +09001867 * @err_mask: err_mask of the error
1868 *
1869 * Record error and examine error history to determine whether
1870 * adjusting transmission speed is necessary. It also sets
1871 * transmission limits appropriately if such adjustment is
1872 * necessary.
1873 *
1874 * LOCKING:
1875 * Kernel thread context (may sleep).
1876 *
1877 * RETURNS:
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001878 * Determined recovery action.
Tejun Heo022bdb02006-05-15 20:58:22 +09001879 */
Tejun Heo3884f7b2007-11-27 19:28:56 +09001880static unsigned int ata_eh_speed_down(struct ata_device *dev,
1881 unsigned int eflags, unsigned int err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09001882{
Tejun Heob1c72912008-07-31 17:02:43 +09001883 struct ata_link *link = ata_dev_phys_link(dev);
Tejun Heo76326ac2007-11-27 19:28:59 +09001884 int xfer_ok = 0;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001885 unsigned int verdict;
1886 unsigned int action = 0;
1887
1888 /* don't bother if Cat-0 error */
Tejun Heo76326ac2007-11-27 19:28:59 +09001889 if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
Tejun Heo022bdb02006-05-15 20:58:22 +09001890 return 0;
1891
1892 /* record error and determine whether speed down is necessary */
Tejun Heo3884f7b2007-11-27 19:28:56 +09001893 ata_ering_record(&dev->ering, eflags, err_mask);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001894 verdict = ata_eh_speed_down_verdict(dev);
Tejun Heo022bdb02006-05-15 20:58:22 +09001895
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001896 /* turn off NCQ? */
1897 if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
1898 (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
1899 ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
1900 dev->flags |= ATA_DFLAG_NCQ_OFF;
1901 ata_dev_printk(dev, KERN_WARNING,
1902 "NCQ disabled due to excessive errors\n");
1903 goto done;
1904 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001905
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001906 /* speed down? */
1907 if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
1908 /* speed down SATA link speed if possible */
Tejun Heoa07d4992009-01-29 20:31:33 +09001909 if (sata_down_spd_limit(link, 0) == 0) {
Tejun Heocf480622008-01-24 00:05:14 +09001910 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001911 goto done;
1912 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001913
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001914 /* lower transfer mode */
1915 if (dev->spdn_cnt < 2) {
1916 static const int dma_dnxfer_sel[] =
1917 { ATA_DNXFER_DMA, ATA_DNXFER_40C };
1918 static const int pio_dnxfer_sel[] =
1919 { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
1920 int sel;
Tejun Heo022bdb02006-05-15 20:58:22 +09001921
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001922 if (dev->xfer_shift != ATA_SHIFT_PIO)
1923 sel = dma_dnxfer_sel[dev->spdn_cnt];
1924 else
1925 sel = pio_dnxfer_sel[dev->spdn_cnt];
1926
1927 dev->spdn_cnt++;
1928
1929 if (ata_down_xfermask_limit(dev, sel) == 0) {
Tejun Heocf480622008-01-24 00:05:14 +09001930 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001931 goto done;
1932 }
1933 }
1934 }
1935
1936 /* Fall back to PIO? Slowing down to PIO is meaningless for
Tejun Heo663f99b2007-11-27 19:28:57 +09001937 * SATA ATA devices. Consider it only for PATA and SATAPI.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001938 */
1939 if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
Tejun Heo663f99b2007-11-27 19:28:57 +09001940 (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) &&
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001941 (dev->xfer_shift != ATA_SHIFT_PIO)) {
1942 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
1943 dev->spdn_cnt = 0;
Tejun Heocf480622008-01-24 00:05:14 +09001944 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001945 goto done;
1946 }
1947 }
1948
Tejun Heo022bdb02006-05-15 20:58:22 +09001949 return 0;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001950 done:
1951 /* device has been slowed down, blow error history */
Tejun Heo76326ac2007-11-27 19:28:59 +09001952 if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS))
1953 ata_ering_clear(&dev->ering);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001954 return action;
Tejun Heo022bdb02006-05-15 20:58:22 +09001955}
1956
1957/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09001958 * ata_eh_link_autopsy - analyze error and determine recovery action
1959 * @link: host link to perform autopsy on
Tejun Heo022bdb02006-05-15 20:58:22 +09001960 *
Tejun Heo02607312007-08-06 18:36:23 +09001961 * Analyze why @link failed and determine which recovery actions
1962 * are needed. This function also sets more detailed AC_ERR_*
1963 * values and fills sense data for ATAPI CHECK SENSE.
Tejun Heo022bdb02006-05-15 20:58:22 +09001964 *
1965 * LOCKING:
1966 * Kernel thread context (may sleep).
1967 */
Tejun Heo9b1e2652007-08-06 18:36:24 +09001968static void ata_eh_link_autopsy(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09001969{
Tejun Heo02607312007-08-06 18:36:23 +09001970 struct ata_port *ap = link->ap;
Tejun Heo936fd732007-08-06 18:36:23 +09001971 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heodfcc1732007-10-31 10:17:05 +09001972 struct ata_device *dev;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001973 unsigned int all_err_mask = 0, eflags = 0;
1974 int tag;
Tejun Heo022bdb02006-05-15 20:58:22 +09001975 u32 serror;
1976 int rc;
1977
1978 DPRINTK("ENTER\n");
1979
Tejun Heo1cdaf532006-07-03 16:07:26 +09001980 if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
1981 return;
1982
Tejun Heo022bdb02006-05-15 20:58:22 +09001983 /* obtain and analyze SError */
Tejun Heo936fd732007-08-06 18:36:23 +09001984 rc = sata_scr_read(link, SCR_ERROR, &serror);
Tejun Heo022bdb02006-05-15 20:58:22 +09001985 if (rc == 0) {
1986 ehc->i.serror |= serror;
Tejun Heo02607312007-08-06 18:36:23 +09001987 ata_eh_analyze_serror(link);
Tejun Heo4e57c512007-07-16 14:29:41 +09001988 } else if (rc != -EOPNOTSUPP) {
Tejun Heocf480622008-01-24 00:05:14 +09001989 /* SError read failed, force reset and probing */
Tejun Heob558edd2008-01-24 00:05:14 +09001990 ehc->i.probe_mask |= ATA_ALL_DEVICES;
Tejun Heocf480622008-01-24 00:05:14 +09001991 ehc->i.action |= ATA_EH_RESET;
Tejun Heo4e57c512007-07-16 14:29:41 +09001992 ehc->i.err_mask |= AC_ERR_OTHER;
1993 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001994
Tejun Heoe8ee8452006-05-15 21:03:46 +09001995 /* analyze NCQ failure */
Tejun Heo02607312007-08-06 18:36:23 +09001996 ata_eh_analyze_ncq_error(link);
Tejun Heoe8ee8452006-05-15 21:03:46 +09001997
Tejun Heo022bdb02006-05-15 20:58:22 +09001998 /* any real error trumps AC_ERR_OTHER */
1999 if (ehc->i.err_mask & ~AC_ERR_OTHER)
2000 ehc->i.err_mask &= ~AC_ERR_OTHER;
2001
2002 all_err_mask |= ehc->i.err_mask;
2003
2004 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2005 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2006
Tejun Heob1c72912008-07-31 17:02:43 +09002007 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2008 ata_dev_phys_link(qc->dev) != link)
Tejun Heo022bdb02006-05-15 20:58:22 +09002009 continue;
2010
2011 /* inherit upper level err_mask */
2012 qc->err_mask |= ehc->i.err_mask;
2013
Tejun Heo022bdb02006-05-15 20:58:22 +09002014 /* analyze TF */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002015 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002016
2017 /* DEV errors are probably spurious in case of ATA_BUS error */
2018 if (qc->err_mask & AC_ERR_ATA_BUS)
2019 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
2020 AC_ERR_INVALID);
2021
2022 /* any real error trumps unknown error */
2023 if (qc->err_mask & ~AC_ERR_OTHER)
2024 qc->err_mask &= ~AC_ERR_OTHER;
2025
2026 /* SENSE_VALID trumps dev/unknown error and revalidation */
Tejun Heof90f0822007-10-26 16:12:41 +09002027 if (qc->flags & ATA_QCFLAG_SENSE_VALID)
Tejun Heo022bdb02006-05-15 20:58:22 +09002028 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
Tejun Heo022bdb02006-05-15 20:58:22 +09002029
Tejun Heo03faab72008-03-27 19:14:24 +09002030 /* determine whether the command is worth retrying */
Tejun Heo534ead72010-01-14 16:18:09 +09002031 if (qc->flags & ATA_QCFLAG_IO ||
2032 (!(qc->err_mask & AC_ERR_INVALID) &&
2033 qc->err_mask != AC_ERR_DEV))
Tejun Heo03faab72008-03-27 19:14:24 +09002034 qc->flags |= ATA_QCFLAG_RETRY;
2035
Tejun Heo022bdb02006-05-15 20:58:22 +09002036 /* accumulate error info */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002037 ehc->i.dev = qc->dev;
Tejun Heo022bdb02006-05-15 20:58:22 +09002038 all_err_mask |= qc->err_mask;
2039 if (qc->flags & ATA_QCFLAG_IO)
Tejun Heo3884f7b2007-11-27 19:28:56 +09002040 eflags |= ATA_EFLAG_IS_IO;
Tejun Heo022bdb02006-05-15 20:58:22 +09002041 }
2042
Tejun Heoa20f33f2006-05-16 12:58:24 +09002043 /* enforce default EH actions */
Tejun Heob51e9e52006-06-29 01:29:30 +09002044 if (ap->pflags & ATA_PFLAG_FROZEN ||
Tejun Heoa20f33f2006-05-16 12:58:24 +09002045 all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
Tejun Heocf480622008-01-24 00:05:14 +09002046 ehc->i.action |= ATA_EH_RESET;
Tejun Heo3884f7b2007-11-27 19:28:56 +09002047 else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) ||
2048 (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV)))
Tejun Heo4528e4d2006-07-08 20:17:26 +09002049 ehc->i.action |= ATA_EH_REVALIDATE;
Tejun Heo022bdb02006-05-15 20:58:22 +09002050
Tejun Heodfcc1732007-10-31 10:17:05 +09002051 /* If we have offending qcs and the associated failed device,
2052 * perform per-dev EH action only on the offending device.
2053 */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002054 if (ehc->i.dev) {
Tejun Heo4528e4d2006-07-08 20:17:26 +09002055 ehc->i.dev_action[ehc->i.dev->devno] |=
2056 ehc->i.action & ATA_EH_PERDEV_MASK;
2057 ehc->i.action &= ~ATA_EH_PERDEV_MASK;
Tejun Heo47005f22006-06-19 18:27:23 +09002058 }
2059
Tejun Heo2695e362008-01-10 13:41:23 +09002060 /* propagate timeout to host link */
2061 if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link))
2062 ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT;
2063
2064 /* record error and consider speeding down */
Tejun Heodfcc1732007-10-31 10:17:05 +09002065 dev = ehc->i.dev;
Tejun Heo2695e362008-01-10 13:41:23 +09002066 if (!dev && ((ata_link_max_devices(link) == 1 &&
2067 ata_dev_enabled(link->device))))
2068 dev = link->device;
Tejun Heodfcc1732007-10-31 10:17:05 +09002069
Tejun Heo76326ac2007-11-27 19:28:59 +09002070 if (dev) {
2071 if (dev->flags & ATA_DFLAG_DUBIOUS_XFER)
2072 eflags |= ATA_EFLAG_DUBIOUS_XFER;
Tejun Heo3884f7b2007-11-27 19:28:56 +09002073 ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask);
Tejun Heo76326ac2007-11-27 19:28:59 +09002074 }
Tejun Heodfcc1732007-10-31 10:17:05 +09002075
Tejun Heo022bdb02006-05-15 20:58:22 +09002076 DPRINTK("EXIT\n");
2077}
2078
2079/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09002080 * ata_eh_autopsy - analyze error and determine recovery action
2081 * @ap: host port to perform autopsy on
2082 *
2083 * Analyze all links of @ap and determine why they failed and
2084 * which recovery actions are needed.
2085 *
2086 * LOCKING:
2087 * Kernel thread context (may sleep).
2088 */
Tejun Heofb7fd612007-09-23 13:14:12 +09002089void ata_eh_autopsy(struct ata_port *ap)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002090{
2091 struct ata_link *link;
2092
Tejun Heo1eca4362008-11-03 20:03:17 +09002093 ata_for_each_link(link, ap, EDGE)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002094 ata_eh_link_autopsy(link);
Tejun Heo2695e362008-01-10 13:41:23 +09002095
Tejun Heob1c72912008-07-31 17:02:43 +09002096 /* Handle the frigging slave link. Autopsy is done similarly
2097 * but actions and flags are transferred over to the master
2098 * link and handled from there.
2099 */
2100 if (ap->slave_link) {
2101 struct ata_eh_context *mehc = &ap->link.eh_context;
2102 struct ata_eh_context *sehc = &ap->slave_link->eh_context;
2103
Tejun Heo848e4c62008-10-21 14:26:39 +09002104 /* transfer control flags from master to slave */
2105 sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK;
2106
2107 /* perform autopsy on the slave link */
Tejun Heob1c72912008-07-31 17:02:43 +09002108 ata_eh_link_autopsy(ap->slave_link);
2109
Tejun Heo848e4c62008-10-21 14:26:39 +09002110 /* transfer actions from slave to master and clear slave */
Tejun Heob1c72912008-07-31 17:02:43 +09002111 ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2112 mehc->i.action |= sehc->i.action;
2113 mehc->i.dev_action[1] |= sehc->i.dev_action[1];
2114 mehc->i.flags |= sehc->i.flags;
2115 ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2116 }
2117
Tejun Heo2695e362008-01-10 13:41:23 +09002118 /* Autopsy of fanout ports can affect host link autopsy.
2119 * Perform host link autopsy last.
2120 */
Tejun Heo071f44b2008-04-07 22:47:22 +09002121 if (sata_pmp_attached(ap))
Tejun Heo2695e362008-01-10 13:41:23 +09002122 ata_eh_link_autopsy(&ap->link);
Tejun Heo9b1e2652007-08-06 18:36:24 +09002123}
2124
2125/**
Robert Hancock65211482009-07-14 20:43:39 -06002126 * ata_get_cmd_descript - get description for ATA command
2127 * @command: ATA command code to get description for
2128 *
2129 * Return a textual description of the given command, or NULL if the
2130 * command is not known.
2131 *
2132 * LOCKING:
2133 * None
2134 */
2135const char *ata_get_cmd_descript(u8 command)
2136{
2137#ifdef CONFIG_ATA_VERBOSE_ERROR
2138 static const struct
2139 {
2140 u8 command;
2141 const char *text;
2142 } cmd_descr[] = {
2143 { ATA_CMD_DEV_RESET, "DEVICE RESET" },
2144 { ATA_CMD_CHK_POWER, "CHECK POWER MODE" },
2145 { ATA_CMD_STANDBY, "STANDBY" },
2146 { ATA_CMD_IDLE, "IDLE" },
2147 { ATA_CMD_EDD, "EXECUTE DEVICE DIAGNOSTIC" },
2148 { ATA_CMD_DOWNLOAD_MICRO, "DOWNLOAD MICROCODE" },
2149 { ATA_CMD_NOP, "NOP" },
2150 { ATA_CMD_FLUSH, "FLUSH CACHE" },
2151 { ATA_CMD_FLUSH_EXT, "FLUSH CACHE EXT" },
2152 { ATA_CMD_ID_ATA, "IDENTIFY DEVICE" },
2153 { ATA_CMD_ID_ATAPI, "IDENTIFY PACKET DEVICE" },
2154 { ATA_CMD_SERVICE, "SERVICE" },
2155 { ATA_CMD_READ, "READ DMA" },
2156 { ATA_CMD_READ_EXT, "READ DMA EXT" },
2157 { ATA_CMD_READ_QUEUED, "READ DMA QUEUED" },
2158 { ATA_CMD_READ_STREAM_EXT, "READ STREAM EXT" },
2159 { ATA_CMD_READ_STREAM_DMA_EXT, "READ STREAM DMA EXT" },
2160 { ATA_CMD_WRITE, "WRITE DMA" },
2161 { ATA_CMD_WRITE_EXT, "WRITE DMA EXT" },
2162 { ATA_CMD_WRITE_QUEUED, "WRITE DMA QUEUED EXT" },
2163 { ATA_CMD_WRITE_STREAM_EXT, "WRITE STREAM EXT" },
2164 { ATA_CMD_WRITE_STREAM_DMA_EXT, "WRITE STREAM DMA EXT" },
2165 { ATA_CMD_WRITE_FUA_EXT, "WRITE DMA FUA EXT" },
2166 { ATA_CMD_WRITE_QUEUED_FUA_EXT, "WRITE DMA QUEUED FUA EXT" },
2167 { ATA_CMD_FPDMA_READ, "READ FPDMA QUEUED" },
2168 { ATA_CMD_FPDMA_WRITE, "WRITE FPDMA QUEUED" },
2169 { ATA_CMD_PIO_READ, "READ SECTOR(S)" },
2170 { ATA_CMD_PIO_READ_EXT, "READ SECTOR(S) EXT" },
2171 { ATA_CMD_PIO_WRITE, "WRITE SECTOR(S)" },
2172 { ATA_CMD_PIO_WRITE_EXT, "WRITE SECTOR(S) EXT" },
2173 { ATA_CMD_READ_MULTI, "READ MULTIPLE" },
2174 { ATA_CMD_READ_MULTI_EXT, "READ MULTIPLE EXT" },
2175 { ATA_CMD_WRITE_MULTI, "WRITE MULTIPLE" },
2176 { ATA_CMD_WRITE_MULTI_EXT, "WRITE MULTIPLE EXT" },
2177 { ATA_CMD_WRITE_MULTI_FUA_EXT, "WRITE MULTIPLE FUA EXT" },
2178 { ATA_CMD_SET_FEATURES, "SET FEATURES" },
2179 { ATA_CMD_SET_MULTI, "SET MULTIPLE MODE" },
2180 { ATA_CMD_VERIFY, "READ VERIFY SECTOR(S)" },
2181 { ATA_CMD_VERIFY_EXT, "READ VERIFY SECTOR(S) EXT" },
2182 { ATA_CMD_WRITE_UNCORR_EXT, "WRITE UNCORRECTABLE EXT" },
2183 { ATA_CMD_STANDBYNOW1, "STANDBY IMMEDIATE" },
2184 { ATA_CMD_IDLEIMMEDIATE, "IDLE IMMEDIATE" },
2185 { ATA_CMD_SLEEP, "SLEEP" },
2186 { ATA_CMD_INIT_DEV_PARAMS, "INITIALIZE DEVICE PARAMETERS" },
2187 { ATA_CMD_READ_NATIVE_MAX, "READ NATIVE MAX ADDRESS" },
2188 { ATA_CMD_READ_NATIVE_MAX_EXT, "READ NATIVE MAX ADDRESS EXT" },
2189 { ATA_CMD_SET_MAX, "SET MAX ADDRESS" },
2190 { ATA_CMD_SET_MAX_EXT, "SET MAX ADDRESS EXT" },
2191 { ATA_CMD_READ_LOG_EXT, "READ LOG EXT" },
2192 { ATA_CMD_WRITE_LOG_EXT, "WRITE LOG EXT" },
2193 { ATA_CMD_READ_LOG_DMA_EXT, "READ LOG DMA EXT" },
2194 { ATA_CMD_WRITE_LOG_DMA_EXT, "WRITE LOG DMA EXT" },
2195 { ATA_CMD_TRUSTED_RCV, "TRUSTED RECEIVE" },
2196 { ATA_CMD_TRUSTED_RCV_DMA, "TRUSTED RECEIVE DMA" },
2197 { ATA_CMD_TRUSTED_SND, "TRUSTED SEND" },
2198 { ATA_CMD_TRUSTED_SND_DMA, "TRUSTED SEND DMA" },
2199 { ATA_CMD_PMP_READ, "READ BUFFER" },
2200 { ATA_CMD_PMP_WRITE, "WRITE BUFFER" },
2201 { ATA_CMD_CONF_OVERLAY, "DEVICE CONFIGURATION OVERLAY" },
2202 { ATA_CMD_SEC_SET_PASS, "SECURITY SET PASSWORD" },
2203 { ATA_CMD_SEC_UNLOCK, "SECURITY UNLOCK" },
2204 { ATA_CMD_SEC_ERASE_PREP, "SECURITY ERASE PREPARE" },
2205 { ATA_CMD_SEC_ERASE_UNIT, "SECURITY ERASE UNIT" },
2206 { ATA_CMD_SEC_FREEZE_LOCK, "SECURITY FREEZE LOCK" },
2207 { ATA_CMD_SEC_DISABLE_PASS, "SECURITY DISABLE PASSWORD" },
2208 { ATA_CMD_CONFIG_STREAM, "CONFIGURE STREAM" },
2209 { ATA_CMD_SMART, "SMART" },
2210 { ATA_CMD_MEDIA_LOCK, "DOOR LOCK" },
2211 { ATA_CMD_MEDIA_UNLOCK, "DOOR UNLOCK" },
2212 { ATA_CMD_CHK_MED_CRD_TYP, "CHECK MEDIA CARD TYPE" },
2213 { ATA_CMD_CFA_REQ_EXT_ERR, "CFA REQUEST EXTENDED ERROR" },
2214 { ATA_CMD_CFA_WRITE_NE, "CFA WRITE SECTORS WITHOUT ERASE" },
2215 { ATA_CMD_CFA_TRANS_SECT, "CFA TRANSLATE SECTOR" },
2216 { ATA_CMD_CFA_ERASE, "CFA ERASE SECTORS" },
2217 { ATA_CMD_CFA_WRITE_MULT_NE, "CFA WRITE MULTIPLE WITHOUT ERASE" },
2218 { ATA_CMD_READ_LONG, "READ LONG (with retries)" },
2219 { ATA_CMD_READ_LONG_ONCE, "READ LONG (without retries)" },
2220 { ATA_CMD_WRITE_LONG, "WRITE LONG (with retries)" },
2221 { ATA_CMD_WRITE_LONG_ONCE, "WRITE LONG (without retries)" },
2222 { ATA_CMD_RESTORE, "RECALIBRATE" },
2223 { 0, NULL } /* terminate list */
2224 };
2225
2226 unsigned int i;
2227 for (i = 0; cmd_descr[i].text; i++)
2228 if (cmd_descr[i].command == command)
2229 return cmd_descr[i].text;
2230#endif
2231
2232 return NULL;
2233}
2234
2235/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09002236 * ata_eh_link_report - report error handling to user
Tejun Heo02607312007-08-06 18:36:23 +09002237 * @link: ATA link EH is going on
Tejun Heo022bdb02006-05-15 20:58:22 +09002238 *
2239 * Report EH to user.
2240 *
2241 * LOCKING:
2242 * None.
2243 */
Tejun Heo9b1e2652007-08-06 18:36:24 +09002244static void ata_eh_link_report(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09002245{
Tejun Heo02607312007-08-06 18:36:23 +09002246 struct ata_port *ap = link->ap;
2247 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09002248 const char *frozen, *desc;
Tejun Heoa1e10f72007-08-18 13:28:49 +09002249 char tries_buf[6];
Tejun Heo022bdb02006-05-15 20:58:22 +09002250 int tag, nr_failed = 0;
2251
Tejun Heo94ff3d52007-10-09 14:57:56 +09002252 if (ehc->i.flags & ATA_EHI_QUIET)
2253 return;
2254
Tejun Heo022bdb02006-05-15 20:58:22 +09002255 desc = NULL;
2256 if (ehc->i.desc[0] != '\0')
2257 desc = ehc->i.desc;
2258
2259 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2260 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2261
Tejun Heob1c72912008-07-31 17:02:43 +09002262 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2263 ata_dev_phys_link(qc->dev) != link ||
Tejun Heoe027bd32007-10-26 16:19:26 +09002264 ((qc->flags & ATA_QCFLAG_QUIET) &&
2265 qc->err_mask == AC_ERR_DEV))
Tejun Heo022bdb02006-05-15 20:58:22 +09002266 continue;
2267 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
2268 continue;
2269
2270 nr_failed++;
2271 }
2272
2273 if (!nr_failed && !ehc->i.err_mask)
2274 return;
2275
2276 frozen = "";
Tejun Heob51e9e52006-06-29 01:29:30 +09002277 if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heo022bdb02006-05-15 20:58:22 +09002278 frozen = " frozen";
2279
Tejun Heoa1e10f72007-08-18 13:28:49 +09002280 memset(tries_buf, 0, sizeof(tries_buf));
2281 if (ap->eh_tries < ATA_EH_MAX_TRIES)
2282 snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
2283 ap->eh_tries);
2284
Tejun Heo022bdb02006-05-15 20:58:22 +09002285 if (ehc->i.dev) {
Tejun Heoe8ee8452006-05-15 21:03:46 +09002286 ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x "
Tejun Heoa1e10f72007-08-18 13:28:49 +09002287 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2288 ehc->i.err_mask, link->sactive, ehc->i.serror,
2289 ehc->i.action, frozen, tries_buf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002290 if (desc)
Tejun Heob64bbc32007-07-16 14:29:39 +09002291 ata_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc);
Tejun Heo022bdb02006-05-15 20:58:22 +09002292 } else {
Tejun Heo02607312007-08-06 18:36:23 +09002293 ata_link_printk(link, KERN_ERR, "exception Emask 0x%x "
Tejun Heoa1e10f72007-08-18 13:28:49 +09002294 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2295 ehc->i.err_mask, link->sactive, ehc->i.serror,
2296 ehc->i.action, frozen, tries_buf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002297 if (desc)
Tejun Heo02607312007-08-06 18:36:23 +09002298 ata_link_printk(link, KERN_ERR, "%s\n", desc);
Tejun Heo022bdb02006-05-15 20:58:22 +09002299 }
2300
Robert Hancock65211482009-07-14 20:43:39 -06002301#ifdef CONFIG_ATA_VERBOSE_ERROR
Robert Hancock1333e192007-10-02 11:22:02 -04002302 if (ehc->i.serror)
Tejun Heoda0e21d2008-07-31 16:08:38 +09002303 ata_link_printk(link, KERN_ERR,
Robert Hancock1333e192007-10-02 11:22:02 -04002304 "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
2305 ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
2306 ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
2307 ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
2308 ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
2309 ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
2310 ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
2311 ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
2312 ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
2313 ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
2314 ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
2315 ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
2316 ehc->i.serror & SERR_CRC ? "BadCRC " : "",
2317 ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
2318 ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
2319 ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
2320 ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002321 ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
Robert Hancock65211482009-07-14 20:43:39 -06002322#endif
Robert Hancock1333e192007-10-02 11:22:02 -04002323
Tejun Heo022bdb02006-05-15 20:58:22 +09002324 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2325 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
Tejun Heo8a937582006-11-14 22:36:12 +09002326 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
Tejun Heoabb6a882007-11-28 23:16:09 +09002327 const u8 *cdb = qc->cdb;
2328 char data_buf[20] = "";
2329 char cdb_buf[70] = "";
Tejun Heo022bdb02006-05-15 20:58:22 +09002330
Tejun Heo02607312007-08-06 18:36:23 +09002331 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
Tejun Heob1c72912008-07-31 17:02:43 +09002332 ata_dev_phys_link(qc->dev) != link || !qc->err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09002333 continue;
2334
Tejun Heoabb6a882007-11-28 23:16:09 +09002335 if (qc->dma_dir != DMA_NONE) {
2336 static const char *dma_str[] = {
2337 [DMA_BIDIRECTIONAL] = "bidi",
2338 [DMA_TO_DEVICE] = "out",
2339 [DMA_FROM_DEVICE] = "in",
2340 };
2341 static const char *prot_str[] = {
2342 [ATA_PROT_PIO] = "pio",
2343 [ATA_PROT_DMA] = "dma",
2344 [ATA_PROT_NCQ] = "ncq",
Tejun Heo0dc36882007-12-18 16:34:43 -05002345 [ATAPI_PROT_PIO] = "pio",
2346 [ATAPI_PROT_DMA] = "dma",
Tejun Heoabb6a882007-11-28 23:16:09 +09002347 };
2348
2349 snprintf(data_buf, sizeof(data_buf), " %s %u %s",
2350 prot_str[qc->tf.protocol], qc->nbytes,
2351 dma_str[qc->dma_dir]);
2352 }
2353
Robert Hancock65211482009-07-14 20:43:39 -06002354 if (ata_is_atapi(qc->tf.protocol)) {
2355 if (qc->scsicmd)
2356 scsi_print_command(qc->scsicmd);
2357 else
2358 snprintf(cdb_buf, sizeof(cdb_buf),
Tejun Heoabb6a882007-11-28 23:16:09 +09002359 "cdb %02x %02x %02x %02x %02x %02x %02x %02x "
2360 "%02x %02x %02x %02x %02x %02x %02x %02x\n ",
2361 cdb[0], cdb[1], cdb[2], cdb[3],
2362 cdb[4], cdb[5], cdb[6], cdb[7],
2363 cdb[8], cdb[9], cdb[10], cdb[11],
2364 cdb[12], cdb[13], cdb[14], cdb[15]);
Robert Hancock65211482009-07-14 20:43:39 -06002365 } else {
2366 const char *descr = ata_get_cmd_descript(cmd->command);
2367 if (descr)
2368 ata_dev_printk(qc->dev, KERN_ERR,
2369 "failed command: %s\n", descr);
2370 }
Tejun Heoabb6a882007-11-28 23:16:09 +09002371
Tejun Heo8a937582006-11-14 22:36:12 +09002372 ata_dev_printk(qc->dev, KERN_ERR,
2373 "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
Tejun Heoabb6a882007-11-28 23:16:09 +09002374 "tag %d%s\n %s"
Tejun Heo8a937582006-11-14 22:36:12 +09002375 "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
Tejun Heo5335b722007-07-16 14:29:40 +09002376 "Emask 0x%x (%s)%s\n",
Tejun Heo8a937582006-11-14 22:36:12 +09002377 cmd->command, cmd->feature, cmd->nsect,
2378 cmd->lbal, cmd->lbam, cmd->lbah,
2379 cmd->hob_feature, cmd->hob_nsect,
2380 cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
Tejun Heoabb6a882007-11-28 23:16:09 +09002381 cmd->device, qc->tag, data_buf, cdb_buf,
Tejun Heo8a937582006-11-14 22:36:12 +09002382 res->command, res->feature, res->nsect,
2383 res->lbal, res->lbam, res->lbah,
2384 res->hob_feature, res->hob_nsect,
2385 res->hob_lbal, res->hob_lbam, res->hob_lbah,
Tejun Heo5335b722007-07-16 14:29:40 +09002386 res->device, qc->err_mask, ata_err_string(qc->err_mask),
2387 qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
Robert Hancock1333e192007-10-02 11:22:02 -04002388
Robert Hancock65211482009-07-14 20:43:39 -06002389#ifdef CONFIG_ATA_VERBOSE_ERROR
Robert Hancock1333e192007-10-02 11:22:02 -04002390 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002391 ATA_ERR)) {
Robert Hancock1333e192007-10-02 11:22:02 -04002392 if (res->command & ATA_BUSY)
2393 ata_dev_printk(qc->dev, KERN_ERR,
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002394 "status: { Busy }\n");
Robert Hancock1333e192007-10-02 11:22:02 -04002395 else
2396 ata_dev_printk(qc->dev, KERN_ERR,
2397 "status: { %s%s%s%s}\n",
2398 res->command & ATA_DRDY ? "DRDY " : "",
2399 res->command & ATA_DF ? "DF " : "",
2400 res->command & ATA_DRQ ? "DRQ " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002401 res->command & ATA_ERR ? "ERR " : "");
Robert Hancock1333e192007-10-02 11:22:02 -04002402 }
2403
2404 if (cmd->command != ATA_CMD_PACKET &&
2405 (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
2406 ATA_ABORTED)))
2407 ata_dev_printk(qc->dev, KERN_ERR,
2408 "error: { %s%s%s%s}\n",
2409 res->feature & ATA_ICRC ? "ICRC " : "",
2410 res->feature & ATA_UNC ? "UNC " : "",
2411 res->feature & ATA_IDNF ? "IDNF " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002412 res->feature & ATA_ABORTED ? "ABRT " : "");
Robert Hancock65211482009-07-14 20:43:39 -06002413#endif
Tejun Heo022bdb02006-05-15 20:58:22 +09002414 }
2415}
2416
Tejun Heo9b1e2652007-08-06 18:36:24 +09002417/**
2418 * ata_eh_report - report error handling to user
2419 * @ap: ATA port to report EH about
2420 *
2421 * Report EH to user.
2422 *
2423 * LOCKING:
2424 * None.
2425 */
Tejun Heofb7fd612007-09-23 13:14:12 +09002426void ata_eh_report(struct ata_port *ap)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002427{
2428 struct ata_link *link;
2429
Tejun Heo1eca4362008-11-03 20:03:17 +09002430 ata_for_each_link(link, ap, HOST_FIRST)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002431 ata_eh_link_report(link);
2432}
2433
Tejun Heocc0680a2007-08-06 18:36:23 +09002434static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
Tejun Heob1c72912008-07-31 17:02:43 +09002435 unsigned int *classes, unsigned long deadline,
2436 bool clear_classes)
Tejun Heod87fa382006-05-31 18:28:24 +09002437{
Tejun Heof58229f2007-08-06 18:36:23 +09002438 struct ata_device *dev;
Tejun Heod87fa382006-05-31 18:28:24 +09002439
Tejun Heob1c72912008-07-31 17:02:43 +09002440 if (clear_classes)
Tejun Heo1eca4362008-11-03 20:03:17 +09002441 ata_for_each_dev(dev, link, ALL)
Tejun Heob1c72912008-07-31 17:02:43 +09002442 classes[dev->devno] = ATA_DEV_UNKNOWN;
Tejun Heod87fa382006-05-31 18:28:24 +09002443
Tejun Heof0465192008-05-19 01:15:08 +09002444 return reset(link, classes, deadline);
Tejun Heod87fa382006-05-31 18:28:24 +09002445}
2446
Tejun Heoae791c02007-09-23 13:14:12 +09002447static int ata_eh_followup_srst_needed(struct ata_link *link,
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002448 int rc, const unsigned int *classes)
Tejun Heo664faf02006-05-31 18:27:50 +09002449{
Tejun Heo45db2f62008-04-08 01:46:56 +09002450 if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link))
Tejun Heoae791c02007-09-23 13:14:12 +09002451 return 0;
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002452 if (rc == -EAGAIN)
2453 return 1;
Tejun Heo071f44b2008-04-07 22:47:22 +09002454 if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
Tejun Heo3495de72007-09-23 13:19:53 +09002455 return 1;
Tejun Heo664faf02006-05-31 18:27:50 +09002456 return 0;
2457}
2458
Tejun Heofb7fd612007-09-23 13:14:12 +09002459int ata_eh_reset(struct ata_link *link, int classify,
2460 ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
2461 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
Tejun Heo022bdb02006-05-15 20:58:22 +09002462{
Tejun Heoafaa5c32007-10-09 15:06:10 +09002463 struct ata_port *ap = link->ap;
Tejun Heob1c72912008-07-31 17:02:43 +09002464 struct ata_link *slave = ap->slave_link;
Tejun Heo936fd732007-08-06 18:36:23 +09002465 struct ata_eh_context *ehc = &link->eh_context;
Bartlomiej Zolnierkiewicz705d2012009-07-26 16:21:01 +02002466 struct ata_eh_context *sehc = slave ? &slave->eh_context : NULL;
Tejun Heo664faf02006-05-31 18:27:50 +09002467 unsigned int *classes = ehc->classes;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002468 unsigned int lflags = link->flags;
Tejun Heo1cdaf532006-07-03 16:07:26 +09002469 int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
Tejun Heod8af0eb2008-05-20 02:17:53 +09002470 int max_tries = 0, try = 0;
Tejun Heob1c72912008-07-31 17:02:43 +09002471 struct ata_link *failed_link;
Tejun Heof58229f2007-08-06 18:36:23 +09002472 struct ata_device *dev;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002473 unsigned long deadline, now;
Tejun Heo022bdb02006-05-15 20:58:22 +09002474 ata_reset_fn_t reset;
Tejun Heoafaa5c32007-10-09 15:06:10 +09002475 unsigned long flags;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002476 u32 sstatus;
Tejun Heob1c72912008-07-31 17:02:43 +09002477 int nr_unknown, rc;
Tejun Heo022bdb02006-05-15 20:58:22 +09002478
Tejun Heo932648b2008-05-19 01:15:06 +09002479 /*
2480 * Prepare to reset
2481 */
Tejun Heod8af0eb2008-05-20 02:17:53 +09002482 while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX)
2483 max_tries++;
Tejun Heo05944bd2008-08-13 20:19:09 +09002484 if (link->flags & ATA_LFLAG_NO_HRST)
2485 hardreset = NULL;
2486 if (link->flags & ATA_LFLAG_NO_SRST)
2487 softreset = NULL;
Tejun Heod8af0eb2008-05-20 02:17:53 +09002488
Tejun Heo19b72322008-11-04 17:08:40 +09002489 /* make sure each reset attemp is at least COOL_DOWN apart */
2490 if (ehc->i.flags & ATA_EHI_DID_RESET) {
2491 now = jiffies;
2492 WARN_ON(time_after(ehc->last_reset, now));
2493 deadline = ata_deadline(ehc->last_reset,
2494 ATA_EH_RESET_COOL_DOWN);
2495 if (time_before(now, deadline))
2496 schedule_timeout_uninterruptible(deadline - now);
2497 }
Tejun Heo0a2c0f52008-05-20 02:17:52 +09002498
Tejun Heoafaa5c32007-10-09 15:06:10 +09002499 spin_lock_irqsave(ap->lock, flags);
2500 ap->pflags |= ATA_PFLAG_RESETTING;
2501 spin_unlock_irqrestore(ap->lock, flags);
2502
Tejun Heocf480622008-01-24 00:05:14 +09002503 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
Tejun Heo13abf502006-07-10 23:18:46 +09002504
Tejun Heo1eca4362008-11-03 20:03:17 +09002505 ata_for_each_dev(dev, link, ALL) {
Tejun Heocdeab112007-10-29 16:41:09 +09002506 /* If we issue an SRST then an ATA drive (not ATAPI)
2507 * may change configuration and be in PIO0 timing. If
2508 * we do a hard reset (or are coming from power on)
2509 * this is true for ATA or ATAPI. Until we've set a
2510 * suitable controller mode we should not touch the
2511 * bus as we may be talking too fast.
2512 */
2513 dev->pio_mode = XFER_PIO_0;
2514
2515 /* If the controller has a pio mode setup function
2516 * then use it to set the chipset to rights. Don't
2517 * touch the DMA setup as that will be dealt with when
2518 * configuring devices.
2519 */
2520 if (ap->ops->set_piomode)
2521 ap->ops->set_piomode(ap, dev);
2522 }
2523
Tejun Heocf480622008-01-24 00:05:14 +09002524 /* prefer hardreset */
Tejun Heo932648b2008-05-19 01:15:06 +09002525 reset = NULL;
Tejun Heocf480622008-01-24 00:05:14 +09002526 ehc->i.action &= ~ATA_EH_RESET;
2527 if (hardreset) {
2528 reset = hardreset;
Tejun Heoa6740502008-07-31 16:07:04 +09002529 ehc->i.action |= ATA_EH_HARDRESET;
Tejun Heo4f7faa32008-01-30 18:18:26 +09002530 } else if (softreset) {
Tejun Heocf480622008-01-24 00:05:14 +09002531 reset = softreset;
Tejun Heoa6740502008-07-31 16:07:04 +09002532 ehc->i.action |= ATA_EH_SOFTRESET;
Tejun Heocf480622008-01-24 00:05:14 +09002533 }
Tejun Heof5914a42006-05-31 18:27:48 +09002534
2535 if (prereset) {
Tejun Heob1c72912008-07-31 17:02:43 +09002536 unsigned long deadline = ata_deadline(jiffies,
2537 ATA_EH_PRERESET_TIMEOUT);
2538
2539 if (slave) {
2540 sehc->i.action &= ~ATA_EH_RESET;
2541 sehc->i.action |= ehc->i.action;
2542 }
2543
2544 rc = prereset(link, deadline);
2545
2546 /* If present, do prereset on slave link too. Reset
2547 * is skipped iff both master and slave links report
2548 * -ENOENT or clear ATA_EH_RESET.
2549 */
2550 if (slave && (rc == 0 || rc == -ENOENT)) {
2551 int tmp;
2552
2553 tmp = prereset(slave, deadline);
2554 if (tmp != -ENOENT)
2555 rc = tmp;
2556
2557 ehc->i.action |= sehc->i.action;
2558 }
2559
Tejun Heof5914a42006-05-31 18:27:48 +09002560 if (rc) {
Alan Coxc9619222006-09-26 17:53:38 +01002561 if (rc == -ENOENT) {
Tejun Heocc0680a2007-08-06 18:36:23 +09002562 ata_link_printk(link, KERN_DEBUG,
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002563 "port disabled. ignoring.\n");
Tejun Heocf480622008-01-24 00:05:14 +09002564 ehc->i.action &= ~ATA_EH_RESET;
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002565
Tejun Heo1eca4362008-11-03 20:03:17 +09002566 ata_for_each_dev(dev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +09002567 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002568
2569 rc = 0;
Alan Coxc9619222006-09-26 17:53:38 +01002570 } else
Tejun Heocc0680a2007-08-06 18:36:23 +09002571 ata_link_printk(link, KERN_ERR,
Tejun Heof5914a42006-05-31 18:27:48 +09002572 "prereset failed (errno=%d)\n", rc);
Tejun Heofccb6ea2007-07-16 14:29:41 +09002573 goto out;
Tejun Heof5914a42006-05-31 18:27:48 +09002574 }
Tejun Heof5914a42006-05-31 18:27:48 +09002575
Tejun Heo932648b2008-05-19 01:15:06 +09002576 /* prereset() might have cleared ATA_EH_RESET. If so,
Tejun Heod6515e62009-03-04 15:59:30 +09002577 * bang classes, thaw and return.
Tejun Heo932648b2008-05-19 01:15:06 +09002578 */
2579 if (reset && !(ehc->i.action & ATA_EH_RESET)) {
Tejun Heo1eca4362008-11-03 20:03:17 +09002580 ata_for_each_dev(dev, link, ALL)
Tejun Heo932648b2008-05-19 01:15:06 +09002581 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heod6515e62009-03-04 15:59:30 +09002582 if ((ap->pflags & ATA_PFLAG_FROZEN) &&
2583 ata_is_host_link(link))
2584 ata_eh_thaw_port(ap);
Tejun Heo932648b2008-05-19 01:15:06 +09002585 rc = 0;
2586 goto out;
2587 }
Tejun Heof5914a42006-05-31 18:27:48 +09002588 }
2589
Tejun Heo022bdb02006-05-15 20:58:22 +09002590 retry:
Tejun Heo932648b2008-05-19 01:15:06 +09002591 /*
2592 * Perform reset
2593 */
Tejun Heodc98c322008-05-19 01:15:07 +09002594 if (ata_is_host_link(link))
2595 ata_eh_freeze_port(ap);
2596
Tejun Heo341c2c92008-05-20 02:17:51 +09002597 deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]);
Tejun Heo31daabd2007-02-02 16:50:52 +09002598
Tejun Heo932648b2008-05-19 01:15:06 +09002599 if (reset) {
2600 if (verbose)
2601 ata_link_printk(link, KERN_INFO, "%s resetting link\n",
2602 reset == softreset ? "soft" : "hard");
Tejun Heo022bdb02006-05-15 20:58:22 +09002603
Tejun Heo932648b2008-05-19 01:15:06 +09002604 /* mark that this EH session started with reset */
Tejun Heo19b72322008-11-04 17:08:40 +09002605 ehc->last_reset = jiffies;
Tejun Heo932648b2008-05-19 01:15:06 +09002606 if (reset == hardreset)
2607 ehc->i.flags |= ATA_EHI_DID_HARDRESET;
2608 else
2609 ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09002610
Tejun Heob1c72912008-07-31 17:02:43 +09002611 rc = ata_do_reset(link, reset, classes, deadline, true);
2612 if (rc && rc != -EAGAIN) {
2613 failed_link = link;
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002614 goto fail;
Tejun Heob1c72912008-07-31 17:02:43 +09002615 }
Tejun Heo022bdb02006-05-15 20:58:22 +09002616
Tejun Heob1c72912008-07-31 17:02:43 +09002617 /* hardreset slave link if existent */
2618 if (slave && reset == hardreset) {
2619 int tmp;
2620
2621 if (verbose)
2622 ata_link_printk(slave, KERN_INFO,
2623 "hard resetting link\n");
2624
2625 ata_eh_about_to_do(slave, NULL, ATA_EH_RESET);
2626 tmp = ata_do_reset(slave, reset, classes, deadline,
2627 false);
2628 switch (tmp) {
2629 case -EAGAIN:
2630 rc = -EAGAIN;
2631 case 0:
2632 break;
2633 default:
2634 failed_link = slave;
2635 rc = tmp;
2636 goto fail;
2637 }
2638 }
2639
2640 /* perform follow-up SRST if necessary */
Tejun Heo932648b2008-05-19 01:15:06 +09002641 if (reset == hardreset &&
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002642 ata_eh_followup_srst_needed(link, rc, classes)) {
Tejun Heo932648b2008-05-19 01:15:06 +09002643 reset = softreset;
Tejun Heo664faf02006-05-31 18:27:50 +09002644
Tejun Heo932648b2008-05-19 01:15:06 +09002645 if (!reset) {
2646 ata_link_printk(link, KERN_ERR,
2647 "follow-up softreset required "
2648 "but no softreset avaliable\n");
Tejun Heob1c72912008-07-31 17:02:43 +09002649 failed_link = link;
Tejun Heo932648b2008-05-19 01:15:06 +09002650 rc = -EINVAL;
2651 goto fail;
2652 }
2653
2654 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
Tejun Heob1c72912008-07-31 17:02:43 +09002655 rc = ata_do_reset(link, reset, classes, deadline, true);
Tejun Heofe2c4d02009-07-08 12:16:37 +09002656 if (rc) {
2657 failed_link = link;
2658 goto fail;
2659 }
Tejun Heo664faf02006-05-31 18:27:50 +09002660 }
Tejun Heo932648b2008-05-19 01:15:06 +09002661 } else {
2662 if (verbose)
2663 ata_link_printk(link, KERN_INFO, "no reset method "
2664 "available, skipping reset\n");
2665 if (!(lflags & ATA_LFLAG_ASSUME_CLASS))
2666 lflags |= ATA_LFLAG_ASSUME_ATA;
Tejun Heo664faf02006-05-31 18:27:50 +09002667 }
2668
Tejun Heo932648b2008-05-19 01:15:06 +09002669 /*
2670 * Post-reset processing
2671 */
Tejun Heo1eca4362008-11-03 20:03:17 +09002672 ata_for_each_dev(dev, link, ALL) {
Tejun Heo416dc9e2007-10-31 10:17:03 +09002673 /* After the reset, the device state is PIO 0 and the
2674 * controller state is undefined. Reset also wakes up
2675 * drives from sleeping mode.
2676 */
2677 dev->pio_mode = XFER_PIO_0;
2678 dev->flags &= ~ATA_DFLAG_SLEEPING;
Tejun Heo664faf02006-05-31 18:27:50 +09002679
Tejun Heo3b761d32009-10-06 17:08:40 +09002680 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
2681 continue;
2682
2683 /* apply class override */
2684 if (lflags & ATA_LFLAG_ASSUME_ATA)
2685 classes[dev->devno] = ATA_DEV_ATA;
2686 else if (lflags & ATA_LFLAG_ASSUME_SEMB)
2687 classes[dev->devno] = ATA_DEV_SEMB_UNSUP;
Tejun Heo022bdb02006-05-15 20:58:22 +09002688 }
2689
Tejun Heo416dc9e2007-10-31 10:17:03 +09002690 /* record current link speed */
2691 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
2692 link->sata_spd = (sstatus >> 4) & 0xf;
Tejun Heob1c72912008-07-31 17:02:43 +09002693 if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0)
2694 slave->sata_spd = (sstatus >> 4) & 0xf;
Tejun Heo008a7892007-07-16 14:29:40 +09002695
Tejun Heodc98c322008-05-19 01:15:07 +09002696 /* thaw the port */
2697 if (ata_is_host_link(link))
2698 ata_eh_thaw_port(ap);
2699
Tejun Heof0465192008-05-19 01:15:08 +09002700 /* postreset() should clear hardware SError. Although SError
2701 * is cleared during link resume, clearing SError here is
2702 * necessary as some PHYs raise hotplug events after SRST.
2703 * This introduces race condition where hotplug occurs between
2704 * reset and here. This race is mediated by cross checking
2705 * link onlineness and classification result later.
2706 */
Tejun Heob1c72912008-07-31 17:02:43 +09002707 if (postreset) {
Tejun Heo416dc9e2007-10-31 10:17:03 +09002708 postreset(link, classes);
Tejun Heob1c72912008-07-31 17:02:43 +09002709 if (slave)
2710 postreset(slave, classes);
2711 }
Tejun Heo20952b62006-05-31 18:27:23 +09002712
Tejun Heo1e641062009-07-17 11:58:33 +09002713 /*
2714 * Some controllers can't be frozen very well and may set
2715 * spuruious error conditions during reset. Clear accumulated
2716 * error information. As reset is the final recovery action,
2717 * nothing is lost by doing this.
2718 */
Tejun Heof0465192008-05-19 01:15:08 +09002719 spin_lock_irqsave(link->ap->lock, flags);
Tejun Heo1e641062009-07-17 11:58:33 +09002720 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heob1c72912008-07-31 17:02:43 +09002721 if (slave)
Tejun Heo1e641062009-07-17 11:58:33 +09002722 memset(&slave->eh_info, 0, sizeof(link->eh_info));
2723 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heof0465192008-05-19 01:15:08 +09002724 spin_unlock_irqrestore(link->ap->lock, flags);
2725
Tejun Heo3b761d32009-10-06 17:08:40 +09002726 /*
2727 * Make sure onlineness and classification result correspond.
Tejun Heof0465192008-05-19 01:15:08 +09002728 * Hotplug could have happened during reset and some
2729 * controllers fail to wait while a drive is spinning up after
2730 * being hotplugged causing misdetection. By cross checking
Tejun Heo3b761d32009-10-06 17:08:40 +09002731 * link on/offlineness and classification result, those
2732 * conditions can be reliably detected and retried.
Tejun Heof0465192008-05-19 01:15:08 +09002733 */
Tejun Heob1c72912008-07-31 17:02:43 +09002734 nr_unknown = 0;
Tejun Heo1eca4362008-11-03 20:03:17 +09002735 ata_for_each_dev(dev, link, ALL) {
Tejun Heo3b761d32009-10-06 17:08:40 +09002736 if (ata_phys_link_online(ata_dev_phys_link(dev))) {
2737 if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
2738 ata_dev_printk(dev, KERN_DEBUG, "link online "
2739 "but device misclassifed\n");
2740 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heob1c72912008-07-31 17:02:43 +09002741 nr_unknown++;
Tejun Heo3b761d32009-10-06 17:08:40 +09002742 }
2743 } else if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
2744 if (ata_class_enabled(classes[dev->devno]))
2745 ata_dev_printk(dev, KERN_DEBUG, "link offline, "
2746 "clearing class %d to NONE\n",
2747 classes[dev->devno]);
2748 classes[dev->devno] = ATA_DEV_NONE;
2749 } else if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
2750 ata_dev_printk(dev, KERN_DEBUG, "link status unknown, "
2751 "clearing UNKNOWN to NONE\n");
2752 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heob1c72912008-07-31 17:02:43 +09002753 }
Tejun Heof0465192008-05-19 01:15:08 +09002754 }
2755
Tejun Heob1c72912008-07-31 17:02:43 +09002756 if (classify && nr_unknown) {
Tejun Heof0465192008-05-19 01:15:08 +09002757 if (try < max_tries) {
2758 ata_link_printk(link, KERN_WARNING, "link online but "
Tejun Heo3b761d32009-10-06 17:08:40 +09002759 "%d devices misclassified, retrying\n",
2760 nr_unknown);
Tejun Heob1c72912008-07-31 17:02:43 +09002761 failed_link = link;
Tejun Heof0465192008-05-19 01:15:08 +09002762 rc = -EAGAIN;
2763 goto fail;
2764 }
2765 ata_link_printk(link, KERN_WARNING,
Tejun Heo3b761d32009-10-06 17:08:40 +09002766 "link online but %d devices misclassified, "
2767 "device detection might fail\n", nr_unknown);
Tejun Heof0465192008-05-19 01:15:08 +09002768 }
2769
Tejun Heo416dc9e2007-10-31 10:17:03 +09002770 /* reset successful, schedule revalidation */
Tejun Heocf480622008-01-24 00:05:14 +09002771 ata_eh_done(link, NULL, ATA_EH_RESET);
Tejun Heob1c72912008-07-31 17:02:43 +09002772 if (slave)
2773 ata_eh_done(slave, NULL, ATA_EH_RESET);
Tejun Heo19b72322008-11-04 17:08:40 +09002774 ehc->last_reset = jiffies; /* update to completion time */
Tejun Heo416dc9e2007-10-31 10:17:03 +09002775 ehc->i.action |= ATA_EH_REVALIDATE;
Tejun Heoae791c02007-09-23 13:14:12 +09002776
Tejun Heo416dc9e2007-10-31 10:17:03 +09002777 rc = 0;
Tejun Heofccb6ea2007-07-16 14:29:41 +09002778 out:
2779 /* clear hotplug flag */
2780 ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
Tejun Heob1c72912008-07-31 17:02:43 +09002781 if (slave)
2782 sehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
Tejun Heoafaa5c32007-10-09 15:06:10 +09002783
2784 spin_lock_irqsave(ap->lock, flags);
2785 ap->pflags &= ~ATA_PFLAG_RESETTING;
2786 spin_unlock_irqrestore(ap->lock, flags);
2787
Tejun Heo022bdb02006-05-15 20:58:22 +09002788 return rc;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002789
2790 fail:
Tejun Heo5958e302008-04-07 22:47:20 +09002791 /* if SCR isn't accessible on a fan-out port, PMP needs to be reset */
2792 if (!ata_is_host_link(link) &&
2793 sata_scr_read(link, SCR_STATUS, &sstatus))
2794 rc = -ERESTART;
2795
Tejun Heo416dc9e2007-10-31 10:17:03 +09002796 if (rc == -ERESTART || try >= max_tries)
2797 goto out;
2798
2799 now = jiffies;
2800 if (time_before(now, deadline)) {
2801 unsigned long delta = deadline - now;
2802
Tejun Heob1c72912008-07-31 17:02:43 +09002803 ata_link_printk(failed_link, KERN_WARNING,
Tejun Heo0a2c0f52008-05-20 02:17:52 +09002804 "reset failed (errno=%d), retrying in %u secs\n",
2805 rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));
Tejun Heo416dc9e2007-10-31 10:17:03 +09002806
2807 while (delta)
2808 delta = schedule_timeout_uninterruptible(delta);
2809 }
2810
Tejun Heob1c72912008-07-31 17:02:43 +09002811 if (try == max_tries - 1) {
Tejun Heoa07d4992009-01-29 20:31:33 +09002812 sata_down_spd_limit(link, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002813 if (slave)
Tejun Heoa07d4992009-01-29 20:31:33 +09002814 sata_down_spd_limit(slave, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002815 } else if (rc == -EPIPE)
Tejun Heoa07d4992009-01-29 20:31:33 +09002816 sata_down_spd_limit(failed_link, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002817
Tejun Heo416dc9e2007-10-31 10:17:03 +09002818 if (hardreset)
2819 reset = hardreset;
2820 goto retry;
Tejun Heo022bdb02006-05-15 20:58:22 +09002821}
2822
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02002823static inline void ata_eh_pull_park_action(struct ata_port *ap)
2824{
2825 struct ata_link *link;
2826 struct ata_device *dev;
2827 unsigned long flags;
2828
2829 /*
2830 * This function can be thought of as an extended version of
2831 * ata_eh_about_to_do() specially crafted to accommodate the
2832 * requirements of ATA_EH_PARK handling. Since the EH thread
2833 * does not leave the do {} while () loop in ata_eh_recover as
2834 * long as the timeout for a park request to *one* device on
2835 * the port has not expired, and since we still want to pick
2836 * up park requests to other devices on the same port or
2837 * timeout updates for the same device, we have to pull
2838 * ATA_EH_PARK actions from eh_info into eh_context.i
2839 * ourselves at the beginning of each pass over the loop.
2840 *
2841 * Additionally, all write accesses to &ap->park_req_pending
2842 * through INIT_COMPLETION() (see below) or complete_all()
2843 * (see ata_scsi_park_store()) are protected by the host lock.
2844 * As a result we have that park_req_pending.done is zero on
2845 * exit from this function, i.e. when ATA_EH_PARK actions for
2846 * *all* devices on port ap have been pulled into the
2847 * respective eh_context structs. If, and only if,
2848 * park_req_pending.done is non-zero by the time we reach
2849 * wait_for_completion_timeout(), another ATA_EH_PARK action
2850 * has been scheduled for at least one of the devices on port
2851 * ap and we have to cycle over the do {} while () loop in
2852 * ata_eh_recover() again.
2853 */
2854
2855 spin_lock_irqsave(ap->lock, flags);
2856 INIT_COMPLETION(ap->park_req_pending);
Tejun Heo1eca4362008-11-03 20:03:17 +09002857 ata_for_each_link(link, ap, EDGE) {
2858 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02002859 struct ata_eh_info *ehi = &link->eh_info;
2860
2861 link->eh_context.i.dev_action[dev->devno] |=
2862 ehi->dev_action[dev->devno] & ATA_EH_PARK;
2863 ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK);
2864 }
2865 }
2866 spin_unlock_irqrestore(ap->lock, flags);
2867}
2868
2869static void ata_eh_park_issue_cmd(struct ata_device *dev, int park)
2870{
2871 struct ata_eh_context *ehc = &dev->link->eh_context;
2872 struct ata_taskfile tf;
2873 unsigned int err_mask;
2874
2875 ata_tf_init(dev, &tf);
2876 if (park) {
2877 ehc->unloaded_mask |= 1 << dev->devno;
2878 tf.command = ATA_CMD_IDLEIMMEDIATE;
2879 tf.feature = 0x44;
2880 tf.lbal = 0x4c;
2881 tf.lbam = 0x4e;
2882 tf.lbah = 0x55;
2883 } else {
2884 ehc->unloaded_mask &= ~(1 << dev->devno);
2885 tf.command = ATA_CMD_CHK_POWER;
2886 }
2887
2888 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
2889 tf.protocol |= ATA_PROT_NODATA;
2890 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
2891 if (park && (err_mask || tf.lbal != 0xc4)) {
2892 ata_dev_printk(dev, KERN_ERR, "head unload failed!\n");
2893 ehc->unloaded_mask &= ~(1 << dev->devno);
2894 }
2895}
2896
Tejun Heo02607312007-08-06 18:36:23 +09002897static int ata_eh_revalidate_and_attach(struct ata_link *link,
Tejun Heo084fe632006-05-31 18:28:03 +09002898 struct ata_device **r_failed_dev)
Tejun Heo022bdb02006-05-15 20:58:22 +09002899{
Tejun Heo02607312007-08-06 18:36:23 +09002900 struct ata_port *ap = link->ap;
2901 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09002902 struct ata_device *dev;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002903 unsigned int new_mask = 0;
Tejun Heo084fe632006-05-31 18:28:03 +09002904 unsigned long flags;
Tejun Heof58229f2007-08-06 18:36:23 +09002905 int rc = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09002906
2907 DPRINTK("ENTER\n");
2908
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002909 /* For PATA drive side cable detection to work, IDENTIFY must
2910 * be done backwards such that PDIAG- is released by the slave
2911 * device before the master device is identified.
2912 */
Tejun Heo1eca4362008-11-03 20:03:17 +09002913 ata_for_each_dev(dev, link, ALL_REVERSE) {
Tejun Heof58229f2007-08-06 18:36:23 +09002914 unsigned int action = ata_eh_dev_action(dev);
2915 unsigned int readid_flags = 0;
Tejun Heo47005f22006-06-19 18:27:23 +09002916
Tejun Heobff04642006-11-10 18:08:10 +09002917 if (ehc->i.flags & ATA_EHI_DID_RESET)
2918 readid_flags |= ATA_READID_POSTRESET;
2919
Tejun Heo9666f402007-05-04 21:27:47 +02002920 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
Tejun Heo633273a32007-09-23 13:19:54 +09002921 WARN_ON(dev->class == ATA_DEV_PMP);
2922
Tejun Heob1c72912008-07-31 17:02:43 +09002923 if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
Tejun Heo022bdb02006-05-15 20:58:22 +09002924 rc = -EIO;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002925 goto err;
Tejun Heo022bdb02006-05-15 20:58:22 +09002926 }
2927
Tejun Heo02607312007-08-06 18:36:23 +09002928 ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
Tejun Heo422c9da2007-09-23 13:14:12 +09002929 rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
2930 readid_flags);
Tejun Heo022bdb02006-05-15 20:58:22 +09002931 if (rc)
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002932 goto err;
Tejun Heo022bdb02006-05-15 20:58:22 +09002933
Tejun Heo02607312007-08-06 18:36:23 +09002934 ata_eh_done(link, dev, ATA_EH_REVALIDATE);
Tejun Heo47005f22006-06-19 18:27:23 +09002935
Tejun Heobaa1e782006-11-01 18:39:27 +09002936 /* Configuration may have changed, reconfigure
2937 * transfer mode.
2938 */
2939 ehc->i.flags |= ATA_EHI_SETMODE;
2940
zhao, forrest3057ac32006-06-12 12:01:34 +08002941 /* schedule the scsi_rescan_device() here */
2942 queue_work(ata_aux_wq, &(ap->scsi_rescan_task));
Tejun Heo084fe632006-05-31 18:28:03 +09002943 } else if (dev->class == ATA_DEV_UNKNOWN &&
2944 ehc->tries[dev->devno] &&
2945 ata_class_enabled(ehc->classes[dev->devno])) {
Tejun Heo842faa62009-05-10 01:06:54 +09002946 /* Temporarily set dev->class, it will be
2947 * permanently set once all configurations are
2948 * complete. This is necessary because new
2949 * device configuration is done in two
2950 * separate loops.
2951 */
Tejun Heo084fe632006-05-31 18:28:03 +09002952 dev->class = ehc->classes[dev->devno];
2953
Tejun Heo633273a32007-09-23 13:19:54 +09002954 if (dev->class == ATA_DEV_PMP)
2955 rc = sata_pmp_attach(dev);
2956 else
2957 rc = ata_dev_read_id(dev, &dev->class,
2958 readid_flags, dev->id);
Tejun Heo842faa62009-05-10 01:06:54 +09002959
2960 /* read_id might have changed class, store and reset */
2961 ehc->classes[dev->devno] = dev->class;
2962 dev->class = ATA_DEV_UNKNOWN;
2963
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002964 switch (rc) {
2965 case 0:
Tejun Heo99cf6102009-01-29 20:31:32 +09002966 /* clear error info accumulated during probe */
2967 ata_ering_clear(&dev->ering);
Tejun Heof58229f2007-08-06 18:36:23 +09002968 new_mask |= 1 << dev->devno;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002969 break;
2970 case -ENOENT:
Tejun Heo55a8e2c2006-11-10 18:08:10 +09002971 /* IDENTIFY was issued to non-existent
2972 * device. No need to reset. Just
Tejun Heo842faa62009-05-10 01:06:54 +09002973 * thaw and ignore the device.
Tejun Heo55a8e2c2006-11-10 18:08:10 +09002974 */
2975 ata_eh_thaw_port(ap);
Tejun Heo084fe632006-05-31 18:28:03 +09002976 break;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002977 default:
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002978 goto err;
Tejun Heo55a8e2c2006-11-10 18:08:10 +09002979 }
Tejun Heo022bdb02006-05-15 20:58:22 +09002980 }
2981 }
2982
Tejun Heoc1c4e8d2007-04-23 02:05:53 +09002983 /* PDIAG- should have been released, ask cable type if post-reset */
Tejun Heo33267322008-02-13 09:15:09 +09002984 if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) {
2985 if (ap->ops->cable_detect)
2986 ap->cbl = ap->ops->cable_detect(ap);
2987 ata_force_cbl(ap);
2988 }
Tejun Heoc1c4e8d2007-04-23 02:05:53 +09002989
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002990 /* Configure new devices forward such that user doesn't see
2991 * device detection messages backwards.
2992 */
Tejun Heo1eca4362008-11-03 20:03:17 +09002993 ata_for_each_dev(dev, link, ALL) {
Tejun Heo4f7c2872009-10-15 23:37:32 +09002994 if (!(new_mask & (1 << dev->devno)))
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002995 continue;
2996
Tejun Heo842faa62009-05-10 01:06:54 +09002997 dev->class = ehc->classes[dev->devno];
2998
Tejun Heo4f7c2872009-10-15 23:37:32 +09002999 if (dev->class == ATA_DEV_PMP)
3000 continue;
3001
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003002 ehc->i.flags |= ATA_EHI_PRINTINFO;
3003 rc = ata_dev_configure(dev);
3004 ehc->i.flags &= ~ATA_EHI_PRINTINFO;
Tejun Heo842faa62009-05-10 01:06:54 +09003005 if (rc) {
3006 dev->class = ATA_DEV_UNKNOWN;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003007 goto err;
Tejun Heo842faa62009-05-10 01:06:54 +09003008 }
Tejun Heo8c3c52a2007-03-22 22:24:19 +09003009
3010 spin_lock_irqsave(ap->lock, flags);
3011 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
3012 spin_unlock_irqrestore(ap->lock, flags);
3013
3014 /* new device discovered, configure xfermode */
3015 ehc->i.flags |= ATA_EHI_SETMODE;
3016 }
3017
3018 return 0;
3019
3020 err:
3021 *r_failed_dev = dev;
3022 DPRINTK("EXIT rc=%d\n", rc);
Tejun Heo022bdb02006-05-15 20:58:22 +09003023 return rc;
3024}
3025
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003026/**
3027 * ata_set_mode - Program timings and issue SET FEATURES - XFER
3028 * @link: link on which timings will be programmed
Martin Olsson98a17082009-04-22 18:21:29 +02003029 * @r_failed_dev: out parameter for failed device
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003030 *
3031 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If
3032 * ata_set_mode() fails, pointer to the failing device is
3033 * returned in @r_failed_dev.
3034 *
3035 * LOCKING:
3036 * PCI/etc. bus probe sem.
3037 *
3038 * RETURNS:
3039 * 0 on success, negative errno otherwise
3040 */
3041int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3042{
3043 struct ata_port *ap = link->ap;
Tejun Heo00115e02007-11-27 19:28:58 +09003044 struct ata_device *dev;
3045 int rc;
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003046
Tejun Heo76326ac2007-11-27 19:28:59 +09003047 /* if data transfer is verified, clear DUBIOUS_XFER on ering top */
Tejun Heo1eca4362008-11-03 20:03:17 +09003048 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo76326ac2007-11-27 19:28:59 +09003049 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) {
3050 struct ata_ering_entry *ent;
3051
3052 ent = ata_ering_top(&dev->ering);
3053 if (ent)
3054 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER;
3055 }
3056 }
3057
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003058 /* has private set_mode? */
3059 if (ap->ops->set_mode)
Tejun Heo00115e02007-11-27 19:28:58 +09003060 rc = ap->ops->set_mode(link, r_failed_dev);
3061 else
3062 rc = ata_do_set_mode(link, r_failed_dev);
3063
3064 /* if transfer mode has changed, set DUBIOUS_XFER on device */
Tejun Heo1eca4362008-11-03 20:03:17 +09003065 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo00115e02007-11-27 19:28:58 +09003066 struct ata_eh_context *ehc = &link->eh_context;
3067 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno];
3068 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno));
3069
3070 if (dev->xfer_mode != saved_xfer_mode ||
3071 ata_ncq_enabled(dev) != saved_ncq)
3072 dev->flags |= ATA_DFLAG_DUBIOUS_XFER;
3073 }
3074
3075 return rc;
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003076}
3077
Tejun Heo11fc33d2008-08-30 14:20:01 +02003078/**
3079 * atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset
3080 * @dev: ATAPI device to clear UA for
3081 *
3082 * Resets and other operations can make an ATAPI device raise
3083 * UNIT ATTENTION which causes the next operation to fail. This
3084 * function clears UA.
3085 *
3086 * LOCKING:
3087 * EH context (may sleep).
3088 *
3089 * RETURNS:
3090 * 0 on success, -errno on failure.
3091 */
3092static int atapi_eh_clear_ua(struct ata_device *dev)
3093{
3094 int i;
3095
3096 for (i = 0; i < ATA_EH_UA_TRIES; i++) {
Tejun Heob5357082009-03-02 18:55:16 +09003097 u8 *sense_buffer = dev->link->ap->sector_buf;
Tejun Heo11fc33d2008-08-30 14:20:01 +02003098 u8 sense_key = 0;
3099 unsigned int err_mask;
3100
3101 err_mask = atapi_eh_tur(dev, &sense_key);
3102 if (err_mask != 0 && err_mask != AC_ERR_DEV) {
3103 ata_dev_printk(dev, KERN_WARNING, "TEST_UNIT_READY "
3104 "failed (err_mask=0x%x)\n", err_mask);
3105 return -EIO;
3106 }
3107
3108 if (!err_mask || sense_key != UNIT_ATTENTION)
3109 return 0;
3110
3111 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key);
3112 if (err_mask) {
3113 ata_dev_printk(dev, KERN_WARNING, "failed to clear "
3114 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask);
3115 return -EIO;
3116 }
3117 }
3118
3119 ata_dev_printk(dev, KERN_WARNING,
3120 "UNIT ATTENTION persists after %d tries\n", ATA_EH_UA_TRIES);
3121
3122 return 0;
3123}
3124
Tejun Heo6013efd2009-11-19 15:36:45 +09003125/**
3126 * ata_eh_maybe_retry_flush - Retry FLUSH if necessary
3127 * @dev: ATA device which may need FLUSH retry
3128 *
3129 * If @dev failed FLUSH, it needs to be reported upper layer
3130 * immediately as it means that @dev failed to remap and already
3131 * lost at least a sector and further FLUSH retrials won't make
3132 * any difference to the lost sector. However, if FLUSH failed
3133 * for other reasons, for example transmission error, FLUSH needs
3134 * to be retried.
3135 *
3136 * This function determines whether FLUSH failure retry is
3137 * necessary and performs it if so.
3138 *
3139 * RETURNS:
3140 * 0 if EH can continue, -errno if EH needs to be repeated.
3141 */
3142static int ata_eh_maybe_retry_flush(struct ata_device *dev)
3143{
3144 struct ata_link *link = dev->link;
3145 struct ata_port *ap = link->ap;
3146 struct ata_queued_cmd *qc;
3147 struct ata_taskfile tf;
3148 unsigned int err_mask;
3149 int rc = 0;
3150
3151 /* did flush fail for this device? */
3152 if (!ata_tag_valid(link->active_tag))
3153 return 0;
3154
3155 qc = __ata_qc_from_tag(ap, link->active_tag);
3156 if (qc->dev != dev || (qc->tf.command != ATA_CMD_FLUSH_EXT &&
3157 qc->tf.command != ATA_CMD_FLUSH))
3158 return 0;
3159
3160 /* if the device failed it, it should be reported to upper layers */
3161 if (qc->err_mask & AC_ERR_DEV)
3162 return 0;
3163
3164 /* flush failed for some other reason, give it another shot */
3165 ata_tf_init(dev, &tf);
3166
3167 tf.command = qc->tf.command;
3168 tf.flags |= ATA_TFLAG_DEVICE;
3169 tf.protocol = ATA_PROT_NODATA;
3170
3171 ata_dev_printk(dev, KERN_WARNING, "retrying FLUSH 0x%x Emask 0x%x\n",
3172 tf.command, qc->err_mask);
3173
3174 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
3175 if (!err_mask) {
3176 /*
3177 * FLUSH is complete but there's no way to
3178 * successfully complete a failed command from EH.
3179 * Making sure retry is allowed at least once and
3180 * retrying it should do the trick - whatever was in
3181 * the cache is already on the platter and this won't
3182 * cause infinite loop.
3183 */
3184 qc->scsicmd->allowed = max(qc->scsicmd->allowed, 1);
3185 } else {
3186 ata_dev_printk(dev, KERN_WARNING, "FLUSH failed Emask 0x%x\n",
3187 err_mask);
3188 rc = -EIO;
3189
3190 /* if device failed it, report it to upper layers */
3191 if (err_mask & AC_ERR_DEV) {
3192 qc->err_mask |= AC_ERR_DEV;
3193 qc->result_tf = tf;
3194 if (!(ap->pflags & ATA_PFLAG_FROZEN))
3195 rc = 0;
3196 }
3197 }
3198 return rc;
3199}
3200
Tejun Heo02607312007-08-06 18:36:23 +09003201static int ata_link_nr_enabled(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09003202{
Tejun Heof58229f2007-08-06 18:36:23 +09003203 struct ata_device *dev;
3204 int cnt = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003205
Tejun Heo1eca4362008-11-03 20:03:17 +09003206 ata_for_each_dev(dev, link, ENABLED)
3207 cnt++;
Tejun Heo022bdb02006-05-15 20:58:22 +09003208 return cnt;
3209}
3210
Tejun Heo02607312007-08-06 18:36:23 +09003211static int ata_link_nr_vacant(struct ata_link *link)
Tejun Heo084fe632006-05-31 18:28:03 +09003212{
Tejun Heof58229f2007-08-06 18:36:23 +09003213 struct ata_device *dev;
3214 int cnt = 0;
Tejun Heo084fe632006-05-31 18:28:03 +09003215
Tejun Heo1eca4362008-11-03 20:03:17 +09003216 ata_for_each_dev(dev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +09003217 if (dev->class == ATA_DEV_UNKNOWN)
Tejun Heo084fe632006-05-31 18:28:03 +09003218 cnt++;
3219 return cnt;
3220}
3221
Tejun Heo02607312007-08-06 18:36:23 +09003222static int ata_eh_skip_recovery(struct ata_link *link)
Tejun Heo084fe632006-05-31 18:28:03 +09003223{
Tejun Heo672b2d62008-01-24 00:05:14 +09003224 struct ata_port *ap = link->ap;
Tejun Heo02607312007-08-06 18:36:23 +09003225 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heof58229f2007-08-06 18:36:23 +09003226 struct ata_device *dev;
Tejun Heo084fe632006-05-31 18:28:03 +09003227
Tejun Heof9df58c2007-09-23 13:14:13 +09003228 /* skip disabled links */
3229 if (link->flags & ATA_LFLAG_DISABLED)
3230 return 1;
3231
Tejun Heo672b2d62008-01-24 00:05:14 +09003232 /* thaw frozen port and recover failed devices */
3233 if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link))
3234 return 0;
3235
3236 /* reset at least once if reset is requested */
3237 if ((ehc->i.action & ATA_EH_RESET) &&
3238 !(ehc->i.flags & ATA_EHI_DID_RESET))
Tejun Heo084fe632006-05-31 18:28:03 +09003239 return 0;
3240
3241 /* skip if class codes for all vacant slots are ATA_DEV_NONE */
Tejun Heo1eca4362008-11-03 20:03:17 +09003242 ata_for_each_dev(dev, link, ALL) {
Tejun Heo084fe632006-05-31 18:28:03 +09003243 if (dev->class == ATA_DEV_UNKNOWN &&
3244 ehc->classes[dev->devno] != ATA_DEV_NONE)
3245 return 0;
3246 }
3247
3248 return 1;
3249}
3250
Tejun Heoc2c7a892009-01-29 20:31:34 +09003251static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg)
3252{
3253 u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL);
3254 u64 now = get_jiffies_64();
3255 int *trials = void_arg;
3256
3257 if (ent->timestamp < now - min(now, interval))
3258 return -1;
3259
3260 (*trials)++;
3261 return 0;
3262}
3263
Tejun Heo02c05a22007-11-27 19:28:54 +09003264static int ata_eh_schedule_probe(struct ata_device *dev)
3265{
3266 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heoc2c7a892009-01-29 20:31:34 +09003267 struct ata_link *link = ata_dev_phys_link(dev);
3268 int trials = 0;
Tejun Heo02c05a22007-11-27 19:28:54 +09003269
3270 if (!(ehc->i.probe_mask & (1 << dev->devno)) ||
3271 (ehc->did_probe_mask & (1 << dev->devno)))
3272 return 0;
3273
3274 ata_eh_detach_dev(dev);
3275 ata_dev_init(dev);
3276 ehc->did_probe_mask |= (1 << dev->devno);
Tejun Heocf480622008-01-24 00:05:14 +09003277 ehc->i.action |= ATA_EH_RESET;
Tejun Heo00115e02007-11-27 19:28:58 +09003278 ehc->saved_xfer_mode[dev->devno] = 0;
3279 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
Tejun Heo02c05a22007-11-27 19:28:54 +09003280
Tejun Heoc2c7a892009-01-29 20:31:34 +09003281 /* Record and count probe trials on the ering. The specific
3282 * error mask used is irrelevant. Because a successful device
3283 * detection clears the ering, this count accumulates only if
3284 * there are consecutive failed probes.
3285 *
3286 * If the count is equal to or higher than ATA_EH_PROBE_TRIALS
3287 * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is
3288 * forced to 1.5Gbps.
3289 *
3290 * This is to work around cases where failed link speed
3291 * negotiation results in device misdetection leading to
3292 * infinite DEVXCHG or PHRDY CHG events.
3293 */
3294 ata_ering_record(&dev->ering, 0, AC_ERR_OTHER);
3295 ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials);
3296
3297 if (trials > ATA_EH_PROBE_TRIALS)
3298 sata_down_spd_limit(link, 1);
3299
Tejun Heo02c05a22007-11-27 19:28:54 +09003300 return 1;
3301}
3302
Tejun Heo9b1e2652007-08-06 18:36:24 +09003303static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
Tejun Heofee7ca72007-07-01 19:05:58 +09003304{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09003305 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heofee7ca72007-07-01 19:05:58 +09003306
Tejun Heocf9a5902009-01-29 20:31:35 +09003307 /* -EAGAIN from EH routine indicates retry without prejudice.
3308 * The requester is responsible for ensuring forward progress.
3309 */
3310 if (err != -EAGAIN)
3311 ehc->tries[dev->devno]--;
Tejun Heofee7ca72007-07-01 19:05:58 +09003312
3313 switch (err) {
3314 case -ENODEV:
3315 /* device missing or wrong IDENTIFY data, schedule probing */
3316 ehc->i.probe_mask |= (1 << dev->devno);
3317 case -EINVAL:
3318 /* give it just one more chance */
3319 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
3320 case -EIO:
Tejun Heod89293a2009-01-29 20:31:29 +09003321 if (ehc->tries[dev->devno] == 1) {
Tejun Heofee7ca72007-07-01 19:05:58 +09003322 /* This is the last chance, better to slow
3323 * down than lose it.
3324 */
Tejun Heoa07d4992009-01-29 20:31:33 +09003325 sata_down_spd_limit(ata_dev_phys_link(dev), 0);
Tejun Heod89293a2009-01-29 20:31:29 +09003326 if (dev->pio_mode > XFER_PIO_0)
3327 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
Tejun Heofee7ca72007-07-01 19:05:58 +09003328 }
3329 }
3330
3331 if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
3332 /* disable device if it has used up all its chances */
3333 ata_dev_disable(dev);
3334
3335 /* detach if offline */
Tejun Heob1c72912008-07-31 17:02:43 +09003336 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
Tejun Heofee7ca72007-07-01 19:05:58 +09003337 ata_eh_detach_dev(dev);
3338
Tejun Heo02c05a22007-11-27 19:28:54 +09003339 /* schedule probe if necessary */
Tejun Heo87fbc5a2008-05-20 02:17:54 +09003340 if (ata_eh_schedule_probe(dev)) {
Tejun Heofee7ca72007-07-01 19:05:58 +09003341 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
Tejun Heo87fbc5a2008-05-20 02:17:54 +09003342 memset(ehc->cmd_timeout_idx[dev->devno], 0,
3343 sizeof(ehc->cmd_timeout_idx[dev->devno]));
3344 }
Tejun Heo9b1e2652007-08-06 18:36:24 +09003345
3346 return 1;
Tejun Heofee7ca72007-07-01 19:05:58 +09003347 } else {
Tejun Heocf480622008-01-24 00:05:14 +09003348 ehc->i.action |= ATA_EH_RESET;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003349 return 0;
Tejun Heofee7ca72007-07-01 19:05:58 +09003350 }
3351}
3352
Tejun Heo022bdb02006-05-15 20:58:22 +09003353/**
3354 * ata_eh_recover - recover host port after error
3355 * @ap: host port to recover
Tejun Heof5914a42006-05-31 18:27:48 +09003356 * @prereset: prereset method (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09003357 * @softreset: softreset method (can be NULL)
3358 * @hardreset: hardreset method (can be NULL)
3359 * @postreset: postreset method (can be NULL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003360 * @r_failed_link: out parameter for failed link
Tejun Heo022bdb02006-05-15 20:58:22 +09003361 *
3362 * This is the alpha and omega, eum and yang, heart and soul of
3363 * libata exception handling. On entry, actions required to
Tejun Heo9b1e2652007-08-06 18:36:24 +09003364 * recover each link and hotplug requests are recorded in the
3365 * link's eh_context. This function executes all the operations
3366 * with appropriate retrials and fallbacks to resurrect failed
Tejun Heo084fe632006-05-31 18:28:03 +09003367 * devices, detach goners and greet newcomers.
Tejun Heo022bdb02006-05-15 20:58:22 +09003368 *
3369 * LOCKING:
3370 * Kernel thread context (may sleep).
3371 *
3372 * RETURNS:
3373 * 0 on success, -errno on failure.
3374 */
Tejun Heofb7fd612007-09-23 13:14:12 +09003375int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
3376 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3377 ata_postreset_fn_t postreset,
3378 struct ata_link **r_failed_link)
Tejun Heo022bdb02006-05-15 20:58:22 +09003379{
Tejun Heo9b1e2652007-08-06 18:36:24 +09003380 struct ata_link *link;
Tejun Heo022bdb02006-05-15 20:58:22 +09003381 struct ata_device *dev;
Tejun Heo0a2c0f52008-05-20 02:17:52 +09003382 int nr_failed_devs;
Tejun Heodc98c322008-05-19 01:15:07 +09003383 int rc;
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003384 unsigned long flags, deadline;
Tejun Heo022bdb02006-05-15 20:58:22 +09003385
3386 DPRINTK("ENTER\n");
3387
3388 /* prep for recovery */
Tejun Heo1eca4362008-11-03 20:03:17 +09003389 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003390 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo084fe632006-05-31 18:28:03 +09003391
Tejun Heof9df58c2007-09-23 13:14:13 +09003392 /* re-enable link? */
3393 if (ehc->i.action & ATA_EH_ENABLE_LINK) {
3394 ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
3395 spin_lock_irqsave(ap->lock, flags);
3396 link->flags &= ~ATA_LFLAG_DISABLED;
3397 spin_unlock_irqrestore(ap->lock, flags);
3398 ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
3399 }
3400
Tejun Heo1eca4362008-11-03 20:03:17 +09003401 ata_for_each_dev(dev, link, ALL) {
Tejun Heofd995f72007-09-23 13:14:12 +09003402 if (link->flags & ATA_LFLAG_NO_RETRY)
3403 ehc->tries[dev->devno] = 1;
3404 else
3405 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
Tejun Heo79a55b72007-01-18 17:22:18 +09003406
Tejun Heo9b1e2652007-08-06 18:36:24 +09003407 /* collect port action mask recorded in dev actions */
3408 ehc->i.action |= ehc->i.dev_action[dev->devno] &
3409 ~ATA_EH_PERDEV_MASK;
3410 ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
Tejun Heo084fe632006-05-31 18:28:03 +09003411
Tejun Heo9b1e2652007-08-06 18:36:24 +09003412 /* process hotplug request */
3413 if (dev->flags & ATA_DFLAG_DETACH)
3414 ata_eh_detach_dev(dev);
3415
Tejun Heo02c05a22007-11-27 19:28:54 +09003416 /* schedule probe if necessary */
3417 if (!ata_dev_enabled(dev))
3418 ata_eh_schedule_probe(dev);
Tejun Heo084fe632006-05-31 18:28:03 +09003419 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003420 }
3421
3422 retry:
Tejun Heo022bdb02006-05-15 20:58:22 +09003423 rc = 0;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003424 nr_failed_devs = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003425
Tejun Heoaeb2ecd2006-06-12 14:11:43 +09003426 /* if UNLOADING, finish immediately */
Tejun Heob51e9e52006-06-29 01:29:30 +09003427 if (ap->pflags & ATA_PFLAG_UNLOADING)
Tejun Heoaeb2ecd2006-06-12 14:11:43 +09003428 goto out;
3429
Tejun Heo9b1e2652007-08-06 18:36:24 +09003430 /* prep for EH */
Tejun Heo1eca4362008-11-03 20:03:17 +09003431 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003432 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003433
Tejun Heo9b1e2652007-08-06 18:36:24 +09003434 /* skip EH if possible. */
3435 if (ata_eh_skip_recovery(link))
3436 ehc->i.action = 0;
3437
Tejun Heo1eca4362008-11-03 20:03:17 +09003438 ata_for_each_dev(dev, link, ALL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003439 ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
3440 }
Tejun Heo084fe632006-05-31 18:28:03 +09003441
Tejun Heo022bdb02006-05-15 20:58:22 +09003442 /* reset */
Tejun Heo1eca4362008-11-03 20:03:17 +09003443 ata_for_each_link(link, ap, EDGE) {
Tejun Heodc98c322008-05-19 01:15:07 +09003444 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003445
Tejun Heodc98c322008-05-19 01:15:07 +09003446 if (!(ehc->i.action & ATA_EH_RESET))
3447 continue;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003448
Tejun Heodc98c322008-05-19 01:15:07 +09003449 rc = ata_eh_reset(link, ata_link_nr_vacant(link),
3450 prereset, softreset, hardreset, postreset);
3451 if (rc) {
3452 ata_link_printk(link, KERN_ERR,
3453 "reset failed, giving up\n");
3454 goto out;
Tejun Heo022bdb02006-05-15 20:58:22 +09003455 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003456 }
3457
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003458 do {
3459 unsigned long now;
3460
3461 /*
3462 * clears ATA_EH_PARK in eh_info and resets
3463 * ap->park_req_pending
3464 */
3465 ata_eh_pull_park_action(ap);
3466
3467 deadline = jiffies;
Tejun Heo1eca4362008-11-03 20:03:17 +09003468 ata_for_each_link(link, ap, EDGE) {
3469 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003470 struct ata_eh_context *ehc = &link->eh_context;
3471 unsigned long tmp;
3472
3473 if (dev->class != ATA_DEV_ATA)
3474 continue;
3475 if (!(ehc->i.dev_action[dev->devno] &
3476 ATA_EH_PARK))
3477 continue;
3478 tmp = dev->unpark_deadline;
3479 if (time_before(deadline, tmp))
3480 deadline = tmp;
3481 else if (time_before_eq(tmp, jiffies))
3482 continue;
3483 if (ehc->unloaded_mask & (1 << dev->devno))
3484 continue;
3485
3486 ata_eh_park_issue_cmd(dev, 1);
3487 }
3488 }
3489
3490 now = jiffies;
3491 if (time_before_eq(deadline, now))
3492 break;
3493
3494 deadline = wait_for_completion_timeout(&ap->park_req_pending,
3495 deadline - now);
3496 } while (deadline);
Tejun Heo1eca4362008-11-03 20:03:17 +09003497 ata_for_each_link(link, ap, EDGE) {
3498 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003499 if (!(link->eh_context.unloaded_mask &
3500 (1 << dev->devno)))
3501 continue;
3502
3503 ata_eh_park_issue_cmd(dev, 0);
3504 ata_eh_done(link, dev, ATA_EH_PARK);
3505 }
3506 }
3507
Tejun Heo9b1e2652007-08-06 18:36:24 +09003508 /* the rest */
Tejun Heo1eca4362008-11-03 20:03:17 +09003509 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003510 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003511
Tejun Heo9b1e2652007-08-06 18:36:24 +09003512 /* revalidate existing devices and attach new ones */
3513 rc = ata_eh_revalidate_and_attach(link, &dev);
Tejun Heo4ae72a12007-02-02 16:22:30 +09003514 if (rc)
Tejun Heo022bdb02006-05-15 20:58:22 +09003515 goto dev_fail;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003516
Tejun Heo633273a32007-09-23 13:19:54 +09003517 /* if PMP got attached, return, pmp EH will take care of it */
3518 if (link->device->class == ATA_DEV_PMP) {
3519 ehc->i.action = 0;
3520 return 0;
3521 }
3522
Tejun Heo9b1e2652007-08-06 18:36:24 +09003523 /* configure transfer mode if necessary */
3524 if (ehc->i.flags & ATA_EHI_SETMODE) {
3525 rc = ata_set_mode(link, &dev);
3526 if (rc)
3527 goto dev_fail;
3528 ehc->i.flags &= ~ATA_EHI_SETMODE;
3529 }
3530
Tejun Heo11fc33d2008-08-30 14:20:01 +02003531 /* If reset has been issued, clear UA to avoid
3532 * disrupting the current users of the device.
3533 */
3534 if (ehc->i.flags & ATA_EHI_DID_RESET) {
Tejun Heo1eca4362008-11-03 20:03:17 +09003535 ata_for_each_dev(dev, link, ALL) {
Tejun Heo11fc33d2008-08-30 14:20:01 +02003536 if (dev->class != ATA_DEV_ATAPI)
3537 continue;
3538 rc = atapi_eh_clear_ua(dev);
3539 if (rc)
3540 goto dev_fail;
3541 }
3542 }
3543
Tejun Heo6013efd2009-11-19 15:36:45 +09003544 /* retry flush if necessary */
3545 ata_for_each_dev(dev, link, ALL) {
3546 if (dev->class != ATA_DEV_ATA)
3547 continue;
3548 rc = ata_eh_maybe_retry_flush(dev);
3549 if (rc)
3550 goto dev_fail;
3551 }
3552
Tejun Heo11fc33d2008-08-30 14:20:01 +02003553 /* configure link power saving */
Tejun Heo3ec25eb2008-03-27 18:37:14 +09003554 if (ehc->i.action & ATA_EH_LPM)
Tejun Heo1eca4362008-11-03 20:03:17 +09003555 ata_for_each_dev(dev, link, ALL)
Kristen Carlson Accardica773292007-10-25 00:58:59 -04003556 ata_dev_enable_pm(dev, ap->pm_policy);
3557
Tejun Heo9b1e2652007-08-06 18:36:24 +09003558 /* this link is okay now */
3559 ehc->i.flags = 0;
3560 continue;
3561
Jeff Garzik2dcb4072007-10-19 06:42:56 -04003562dev_fail:
Tejun Heo9b1e2652007-08-06 18:36:24 +09003563 nr_failed_devs++;
Tejun Heo0a2c0f52008-05-20 02:17:52 +09003564 ata_eh_handle_dev_fail(dev, rc);
Tejun Heo9b1e2652007-08-06 18:36:24 +09003565
Tejun Heob06ce3e2007-10-09 15:06:48 +09003566 if (ap->pflags & ATA_PFLAG_FROZEN) {
3567 /* PMP reset requires working host port.
3568 * Can't retry if it's frozen.
3569 */
Tejun Heo071f44b2008-04-07 22:47:22 +09003570 if (sata_pmp_attached(ap))
Tejun Heob06ce3e2007-10-09 15:06:48 +09003571 goto out;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003572 break;
Tejun Heob06ce3e2007-10-09 15:06:48 +09003573 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003574 }
3575
Tejun Heo0a2c0f52008-05-20 02:17:52 +09003576 if (nr_failed_devs)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003577 goto retry;
Tejun Heo022bdb02006-05-15 20:58:22 +09003578
Tejun Heo022bdb02006-05-15 20:58:22 +09003579 out:
Tejun Heo9b1e2652007-08-06 18:36:24 +09003580 if (rc && r_failed_link)
3581 *r_failed_link = link;
Tejun Heo022bdb02006-05-15 20:58:22 +09003582
3583 DPRINTK("EXIT, rc=%d\n", rc);
3584 return rc;
3585}
3586
3587/**
3588 * ata_eh_finish - finish up EH
3589 * @ap: host port to finish EH for
3590 *
3591 * Recovery is complete. Clean up EH states and retry or finish
3592 * failed qcs.
3593 *
3594 * LOCKING:
3595 * None.
3596 */
Tejun Heofb7fd612007-09-23 13:14:12 +09003597void ata_eh_finish(struct ata_port *ap)
Tejun Heo022bdb02006-05-15 20:58:22 +09003598{
3599 int tag;
3600
3601 /* retry or finish qcs */
3602 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
3603 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
3604
3605 if (!(qc->flags & ATA_QCFLAG_FAILED))
3606 continue;
3607
3608 if (qc->err_mask) {
3609 /* FIXME: Once EH migration is complete,
3610 * generate sense data in this function,
3611 * considering both err_mask and tf.
3612 */
Tejun Heo03faab72008-03-27 19:14:24 +09003613 if (qc->flags & ATA_QCFLAG_RETRY)
Tejun Heo022bdb02006-05-15 20:58:22 +09003614 ata_eh_qc_retry(qc);
Tejun Heo03faab72008-03-27 19:14:24 +09003615 else
3616 ata_eh_qc_complete(qc);
Tejun Heo022bdb02006-05-15 20:58:22 +09003617 } else {
3618 if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
3619 ata_eh_qc_complete(qc);
3620 } else {
3621 /* feed zero TF to sense generation */
3622 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
3623 ata_eh_qc_retry(qc);
3624 }
3625 }
3626 }
Tejun Heoda917d62007-09-23 13:14:12 +09003627
3628 /* make sure nr_active_links is zero after EH */
3629 WARN_ON(ap->nr_active_links);
3630 ap->nr_active_links = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003631}
3632
3633/**
3634 * ata_do_eh - do standard error handling
3635 * @ap: host port to handle error for
Tejun Heoa1efdab2008-03-25 12:22:50 +09003636 *
Tejun Heof5914a42006-05-31 18:27:48 +09003637 * @prereset: prereset method (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09003638 * @softreset: softreset method (can be NULL)
3639 * @hardreset: hardreset method (can be NULL)
3640 * @postreset: postreset method (can be NULL)
3641 *
3642 * Perform standard error handling sequence.
3643 *
3644 * LOCKING:
3645 * Kernel thread context (may sleep).
3646 */
Tejun Heof5914a42006-05-31 18:27:48 +09003647void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
3648 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3649 ata_postreset_fn_t postreset)
Tejun Heo022bdb02006-05-15 20:58:22 +09003650{
Tejun Heo9b1e2652007-08-06 18:36:24 +09003651 struct ata_device *dev;
3652 int rc;
3653
3654 ata_eh_autopsy(ap);
3655 ata_eh_report(ap);
3656
3657 rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
3658 NULL);
3659 if (rc) {
Tejun Heo1eca4362008-11-03 20:03:17 +09003660 ata_for_each_dev(dev, &ap->link, ALL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003661 ata_dev_disable(dev);
3662 }
3663
Tejun Heo022bdb02006-05-15 20:58:22 +09003664 ata_eh_finish(ap);
3665}
Tejun Heo500530f2006-07-03 16:07:27 +09003666
Tejun Heoa1efdab2008-03-25 12:22:50 +09003667/**
3668 * ata_std_error_handler - standard error handler
3669 * @ap: host port to handle error for
3670 *
3671 * Standard error handler
3672 *
3673 * LOCKING:
3674 * Kernel thread context (may sleep).
3675 */
3676void ata_std_error_handler(struct ata_port *ap)
3677{
3678 struct ata_port_operations *ops = ap->ops;
3679 ata_reset_fn_t hardreset = ops->hardreset;
3680
Tejun Heo57c9efd2008-04-07 22:47:19 +09003681 /* ignore built-in hardreset if SCR access is not available */
3682 if (ata_is_builtin_hardreset(hardreset) && !sata_scr_valid(&ap->link))
Tejun Heoa1efdab2008-03-25 12:22:50 +09003683 hardreset = NULL;
3684
3685 ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);
3686}
3687
Tejun Heo6ffa01d2007-03-02 17:32:47 +09003688#ifdef CONFIG_PM
Tejun Heo500530f2006-07-03 16:07:27 +09003689/**
3690 * ata_eh_handle_port_suspend - perform port suspend operation
3691 * @ap: port to suspend
3692 *
3693 * Suspend @ap.
3694 *
3695 * LOCKING:
3696 * Kernel thread context (may sleep).
3697 */
3698static void ata_eh_handle_port_suspend(struct ata_port *ap)
3699{
3700 unsigned long flags;
3701 int rc = 0;
3702
3703 /* are we suspending? */
3704 spin_lock_irqsave(ap->lock, flags);
3705 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
3706 ap->pm_mesg.event == PM_EVENT_ON) {
3707 spin_unlock_irqrestore(ap->lock, flags);
3708 return;
3709 }
3710 spin_unlock_irqrestore(ap->lock, flags);
3711
3712 WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
3713
Tejun Heo64578a32007-05-15 03:28:16 +09003714 /* tell ACPI we're suspending */
3715 rc = ata_acpi_on_suspend(ap);
3716 if (rc)
3717 goto out;
3718
Tejun Heo500530f2006-07-03 16:07:27 +09003719 /* suspend */
3720 ata_eh_freeze_port(ap);
3721
3722 if (ap->ops->port_suspend)
3723 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
3724
Shaohua Libd3adca2007-11-02 09:32:38 +08003725 ata_acpi_set_state(ap, PMSG_SUSPEND);
Tejun Heo64578a32007-05-15 03:28:16 +09003726 out:
Tejun Heo500530f2006-07-03 16:07:27 +09003727 /* report result */
3728 spin_lock_irqsave(ap->lock, flags);
3729
3730 ap->pflags &= ~ATA_PFLAG_PM_PENDING;
3731 if (rc == 0)
3732 ap->pflags |= ATA_PFLAG_SUSPENDED;
Tejun Heo64578a32007-05-15 03:28:16 +09003733 else if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heo500530f2006-07-03 16:07:27 +09003734 ata_port_schedule_eh(ap);
3735
3736 if (ap->pm_result) {
3737 *ap->pm_result = rc;
3738 ap->pm_result = NULL;
3739 }
3740
3741 spin_unlock_irqrestore(ap->lock, flags);
3742
3743 return;
3744}
3745
3746/**
3747 * ata_eh_handle_port_resume - perform port resume operation
3748 * @ap: port to resume
3749 *
3750 * Resume @ap.
3751 *
Tejun Heo500530f2006-07-03 16:07:27 +09003752 * LOCKING:
3753 * Kernel thread context (may sleep).
3754 */
3755static void ata_eh_handle_port_resume(struct ata_port *ap)
3756{
Tejun Heo6f9c1ea2009-04-23 09:55:28 +09003757 struct ata_link *link;
3758 struct ata_device *dev;
Tejun Heo500530f2006-07-03 16:07:27 +09003759 unsigned long flags;
Tejun Heo9666f402007-05-04 21:27:47 +02003760 int rc = 0;
Tejun Heo500530f2006-07-03 16:07:27 +09003761
3762 /* are we resuming? */
3763 spin_lock_irqsave(ap->lock, flags);
3764 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
3765 ap->pm_mesg.event != PM_EVENT_ON) {
3766 spin_unlock_irqrestore(ap->lock, flags);
3767 return;
3768 }
3769 spin_unlock_irqrestore(ap->lock, flags);
3770
Tejun Heo9666f402007-05-04 21:27:47 +02003771 WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
Tejun Heo500530f2006-07-03 16:07:27 +09003772
Tejun Heo6f9c1ea2009-04-23 09:55:28 +09003773 /*
3774 * Error timestamps are in jiffies which doesn't run while
3775 * suspended and PHY events during resume isn't too uncommon.
3776 * When the two are combined, it can lead to unnecessary speed
3777 * downs if the machine is suspended and resumed repeatedly.
3778 * Clear error history.
3779 */
3780 ata_for_each_link(link, ap, HOST_FIRST)
3781 ata_for_each_dev(dev, link, ALL)
3782 ata_ering_clear(&dev->ering);
3783
Shaohua Libd3adca2007-11-02 09:32:38 +08003784 ata_acpi_set_state(ap, PMSG_ON);
3785
Tejun Heo500530f2006-07-03 16:07:27 +09003786 if (ap->ops->port_resume)
3787 rc = ap->ops->port_resume(ap);
3788
Tejun Heo67465442007-05-15 03:28:16 +09003789 /* tell ACPI that we're resuming */
3790 ata_acpi_on_resume(ap);
3791
Tejun Heo9666f402007-05-04 21:27:47 +02003792 /* report result */
Tejun Heo500530f2006-07-03 16:07:27 +09003793 spin_lock_irqsave(ap->lock, flags);
3794 ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
3795 if (ap->pm_result) {
3796 *ap->pm_result = rc;
3797 ap->pm_result = NULL;
3798 }
3799 spin_unlock_irqrestore(ap->lock, flags);
3800}
Tejun Heo6ffa01d2007-03-02 17:32:47 +09003801#endif /* CONFIG_PM */