blob: a04488f0de882f2f38b30ade8a8c6defd1b7edcb [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
113static const unsigned long ata_eh_other_timeouts[] = {
114 5000, /* same rationale as identify timeout */
115 10000, /* ditto */
116 /* but no merciful 30sec for other commands, it just isn't worth it */
117 ULONG_MAX,
118};
119
120struct ata_eh_cmd_timeout_ent {
121 const u8 *commands;
122 const unsigned long *timeouts;
123};
124
125/* The following table determines timeouts to use for EH internal
126 * commands. Each table entry is a command class and matches the
127 * commands the entry applies to and the timeout table to use.
128 *
129 * On the retry after a command timed out, the next timeout value from
130 * the table is used. If the table doesn't contain further entries,
131 * the last value is used.
132 *
133 * ehc->cmd_timeout_idx keeps track of which timeout to use per
134 * command class, so if SET_FEATURES times out on the first try, the
135 * next try will use the second timeout value only for that class.
136 */
137#define CMDS(cmds...) (const u8 []){ cmds, 0 }
138static const struct ata_eh_cmd_timeout_ent
139ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = {
140 { .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI),
141 .timeouts = ata_eh_identify_timeouts, },
142 { .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT),
143 .timeouts = ata_eh_other_timeouts, },
144 { .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT),
145 .timeouts = ata_eh_other_timeouts, },
146 { .commands = CMDS(ATA_CMD_SET_FEATURES),
147 .timeouts = ata_eh_other_timeouts, },
148 { .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS),
149 .timeouts = ata_eh_other_timeouts, },
150};
151#undef CMDS
152
Tejun Heoad9e2762006-05-15 20:58:12 +0900153static void __ata_port_freeze(struct ata_port *ap);
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900154#ifdef CONFIG_PM
Tejun Heo500530f2006-07-03 16:07:27 +0900155static void ata_eh_handle_port_suspend(struct ata_port *ap);
156static void ata_eh_handle_port_resume(struct ata_port *ap);
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900157#else /* CONFIG_PM */
158static void ata_eh_handle_port_suspend(struct ata_port *ap)
159{ }
160
161static void ata_eh_handle_port_resume(struct ata_port *ap)
162{ }
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900163#endif /* CONFIG_PM */
Tejun Heoad9e2762006-05-15 20:58:12 +0900164
Tejun Heob64bbc32007-07-16 14:29:39 +0900165static void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, const char *fmt,
166 va_list args)
167{
168 ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
169 ATA_EH_DESC_LEN - ehi->desc_len,
170 fmt, args);
171}
172
173/**
174 * __ata_ehi_push_desc - push error description without adding separator
175 * @ehi: target EHI
176 * @fmt: printf format string
177 *
178 * Format string according to @fmt and append it to @ehi->desc.
179 *
180 * LOCKING:
181 * spin_lock_irqsave(host lock)
182 */
183void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
184{
185 va_list args;
186
187 va_start(args, fmt);
188 __ata_ehi_pushv_desc(ehi, fmt, args);
189 va_end(args);
190}
191
192/**
193 * ata_ehi_push_desc - push error description with separator
194 * @ehi: target EHI
195 * @fmt: printf format string
196 *
197 * Format string according to @fmt and append it to @ehi->desc.
198 * If @ehi->desc is not empty, ", " is added in-between.
199 *
200 * LOCKING:
201 * spin_lock_irqsave(host lock)
202 */
203void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
204{
205 va_list args;
206
207 if (ehi->desc_len)
208 __ata_ehi_push_desc(ehi, ", ");
209
210 va_start(args, fmt);
211 __ata_ehi_pushv_desc(ehi, fmt, args);
212 va_end(args);
213}
214
215/**
216 * ata_ehi_clear_desc - clean error description
217 * @ehi: target EHI
218 *
219 * Clear @ehi->desc.
220 *
221 * LOCKING:
222 * spin_lock_irqsave(host lock)
223 */
224void ata_ehi_clear_desc(struct ata_eh_info *ehi)
225{
226 ehi->desc[0] = '\0';
227 ehi->desc_len = 0;
228}
229
Tejun Heocbcdd872007-08-18 13:14:55 +0900230/**
231 * ata_port_desc - append port description
232 * @ap: target ATA port
233 * @fmt: printf format string
234 *
235 * Format string according to @fmt and append it to port
236 * description. If port description is not empty, " " is added
237 * in-between. This function is to be used while initializing
238 * ata_host. The description is printed on host registration.
239 *
240 * LOCKING:
241 * None.
242 */
243void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
244{
245 va_list args;
246
247 WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
248
249 if (ap->link.eh_info.desc_len)
250 __ata_ehi_push_desc(&ap->link.eh_info, " ");
251
252 va_start(args, fmt);
253 __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
254 va_end(args);
255}
256
257#ifdef CONFIG_PCI
258
259/**
260 * ata_port_pbar_desc - append PCI BAR description
261 * @ap: target ATA port
262 * @bar: target PCI BAR
263 * @offset: offset into PCI BAR
264 * @name: name of the area
265 *
266 * If @offset is negative, this function formats a string which
267 * contains the name, address, size and type of the BAR and
268 * appends it to the port description. If @offset is zero or
269 * positive, only name and offsetted address is appended.
270 *
271 * LOCKING:
272 * None.
273 */
274void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
275 const char *name)
276{
277 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
278 char *type = "";
279 unsigned long long start, len;
280
281 if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
282 type = "m";
283 else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
284 type = "i";
285
286 start = (unsigned long long)pci_resource_start(pdev, bar);
287 len = (unsigned long long)pci_resource_len(pdev, bar);
288
289 if (offset < 0)
290 ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
291 else
Andrew Mortone6a73ab2007-12-13 16:01:37 -0800292 ata_port_desc(ap, "%s 0x%llx", name,
293 start + (unsigned long long)offset);
Tejun Heocbcdd872007-08-18 13:14:55 +0900294}
295
296#endif /* CONFIG_PCI */
297
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900298static int ata_lookup_timeout_table(u8 cmd)
299{
300 int i;
301
302 for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) {
303 const u8 *cur;
304
305 for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++)
306 if (*cur == cmd)
307 return i;
308 }
309
310 return -1;
311}
312
313/**
314 * ata_internal_cmd_timeout - determine timeout for an internal command
315 * @dev: target device
316 * @cmd: internal command to be issued
317 *
318 * Determine timeout for internal command @cmd for @dev.
319 *
320 * LOCKING:
321 * EH context.
322 *
323 * RETURNS:
324 * Determined timeout.
325 */
326unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd)
327{
328 struct ata_eh_context *ehc = &dev->link->eh_context;
329 int ent = ata_lookup_timeout_table(cmd);
330 int idx;
331
332 if (ent < 0)
333 return ATA_EH_CMD_DFL_TIMEOUT;
334
335 idx = ehc->cmd_timeout_idx[dev->devno][ent];
336 return ata_eh_cmd_timeout_table[ent].timeouts[idx];
337}
338
339/**
340 * ata_internal_cmd_timed_out - notification for internal command timeout
341 * @dev: target device
342 * @cmd: internal command which timed out
343 *
344 * Notify EH that internal command @cmd for @dev timed out. This
345 * function should be called only for commands whose timeouts are
346 * determined using ata_internal_cmd_timeout().
347 *
348 * LOCKING:
349 * EH context.
350 */
351void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd)
352{
353 struct ata_eh_context *ehc = &dev->link->eh_context;
354 int ent = ata_lookup_timeout_table(cmd);
355 int idx;
356
357 if (ent < 0)
358 return;
359
360 idx = ehc->cmd_timeout_idx[dev->devno][ent];
361 if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX)
362 ehc->cmd_timeout_idx[dev->devno][ent]++;
363}
364
Tejun Heo3884f7b2007-11-27 19:28:56 +0900365static void ata_ering_record(struct ata_ering *ering, unsigned int eflags,
Tejun Heo0c247c52006-05-15 20:58:19 +0900366 unsigned int err_mask)
367{
368 struct ata_ering_entry *ent;
369
370 WARN_ON(!err_mask);
371
372 ering->cursor++;
373 ering->cursor %= ATA_ERING_SIZE;
374
375 ent = &ering->ring[ering->cursor];
Tejun Heo3884f7b2007-11-27 19:28:56 +0900376 ent->eflags = eflags;
Tejun Heo0c247c52006-05-15 20:58:19 +0900377 ent->err_mask = err_mask;
378 ent->timestamp = get_jiffies_64();
379}
380
Tejun Heo76326ac2007-11-27 19:28:59 +0900381static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
382{
383 struct ata_ering_entry *ent = &ering->ring[ering->cursor];
384
385 if (ent->err_mask)
386 return ent;
387 return NULL;
388}
389
Tejun Heo7d47e8d2007-02-02 16:22:31 +0900390static void ata_ering_clear(struct ata_ering *ering)
Tejun Heo0c247c52006-05-15 20:58:19 +0900391{
Tejun Heo7d47e8d2007-02-02 16:22:31 +0900392 memset(ering, 0, sizeof(*ering));
Tejun Heo0c247c52006-05-15 20:58:19 +0900393}
394
395static int ata_ering_map(struct ata_ering *ering,
396 int (*map_fn)(struct ata_ering_entry *, void *),
397 void *arg)
398{
399 int idx, rc = 0;
400 struct ata_ering_entry *ent;
401
402 idx = ering->cursor;
403 do {
404 ent = &ering->ring[idx];
405 if (!ent->err_mask)
406 break;
407 rc = map_fn(ent, arg);
408 if (rc)
409 break;
410 idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
411 } while (idx != ering->cursor);
412
413 return rc;
414}
415
Tejun Heo64f65ca2006-06-24 20:30:18 +0900416static unsigned int ata_eh_dev_action(struct ata_device *dev)
417{
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900418 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heo64f65ca2006-06-24 20:30:18 +0900419
420 return ehc->i.action | ehc->i.dev_action[dev->devno];
421}
422
Tejun Heof58229f2007-08-06 18:36:23 +0900423static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
Tejun Heoaf181c22006-06-24 20:30:18 +0900424 struct ata_eh_info *ehi, unsigned int action)
425{
Tejun Heof58229f2007-08-06 18:36:23 +0900426 struct ata_device *tdev;
Tejun Heoaf181c22006-06-24 20:30:18 +0900427
428 if (!dev) {
429 ehi->action &= ~action;
Tejun Heo1eca4362008-11-03 20:03:17 +0900430 ata_for_each_dev(tdev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +0900431 ehi->dev_action[tdev->devno] &= ~action;
Tejun Heoaf181c22006-06-24 20:30:18 +0900432 } else {
433 /* doesn't make sense for port-wide EH actions */
434 WARN_ON(!(action & ATA_EH_PERDEV_MASK));
435
436 /* break ehi->action into ehi->dev_action */
437 if (ehi->action & action) {
Tejun Heo1eca4362008-11-03 20:03:17 +0900438 ata_for_each_dev(tdev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +0900439 ehi->dev_action[tdev->devno] |=
440 ehi->action & action;
Tejun Heoaf181c22006-06-24 20:30:18 +0900441 ehi->action &= ~action;
442 }
443
444 /* turn off the specified per-dev action */
445 ehi->dev_action[dev->devno] &= ~action;
446 }
447}
448
Tejun Heoece1d632006-04-02 18:51:53 +0900449/**
450 * ata_scsi_timed_out - SCSI layer time out callback
451 * @cmd: timed out SCSI command
452 *
453 * Handles SCSI layer timeout. We race with normal completion of
454 * the qc for @cmd. If the qc is already gone, we lose and let
455 * the scsi command finish (EH_HANDLED). Otherwise, the qc has
456 * timed out and EH should be invoked. Prevent ata_qc_complete()
457 * from finishing it by setting EH_SCHEDULED and return
458 * EH_NOT_HANDLED.
459 *
Tejun Heoad9e2762006-05-15 20:58:12 +0900460 * TODO: kill this function once old EH is gone.
461 *
Tejun Heoece1d632006-04-02 18:51:53 +0900462 * LOCKING:
463 * Called from timer context
464 *
465 * RETURNS:
466 * EH_HANDLED or EH_NOT_HANDLED
467 */
Jens Axboe242f9dc2008-09-14 05:55:09 -0700468enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
Tejun Heoece1d632006-04-02 18:51:53 +0900469{
470 struct Scsi_Host *host = cmd->device->host;
Jeff Garzik35bb94b2006-04-11 13:12:34 -0400471 struct ata_port *ap = ata_shost_to_port(host);
Tejun Heoece1d632006-04-02 18:51:53 +0900472 unsigned long flags;
473 struct ata_queued_cmd *qc;
Jens Axboe242f9dc2008-09-14 05:55:09 -0700474 enum blk_eh_timer_return ret;
Tejun Heoece1d632006-04-02 18:51:53 +0900475
476 DPRINTK("ENTER\n");
477
Tejun Heoad9e2762006-05-15 20:58:12 +0900478 if (ap->ops->error_handler) {
Jens Axboe242f9dc2008-09-14 05:55:09 -0700479 ret = BLK_EH_NOT_HANDLED;
Tejun Heoad9e2762006-05-15 20:58:12 +0900480 goto out;
481 }
482
Jens Axboe242f9dc2008-09-14 05:55:09 -0700483 ret = BLK_EH_HANDLED;
Jeff Garzikba6a1302006-06-22 23:46:10 -0400484 spin_lock_irqsave(ap->lock, flags);
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900485 qc = ata_qc_from_tag(ap, ap->link.active_tag);
Tejun Heoece1d632006-04-02 18:51:53 +0900486 if (qc) {
487 WARN_ON(qc->scsicmd != cmd);
488 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
489 qc->err_mask |= AC_ERR_TIMEOUT;
Jens Axboe242f9dc2008-09-14 05:55:09 -0700490 ret = BLK_EH_NOT_HANDLED;
Tejun Heoece1d632006-04-02 18:51:53 +0900491 }
Jeff Garzikba6a1302006-06-22 23:46:10 -0400492 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +0900493
Tejun Heoad9e2762006-05-15 20:58:12 +0900494 out:
Tejun Heoece1d632006-04-02 18:51:53 +0900495 DPRINTK("EXIT, ret=%d\n", ret);
496 return ret;
497}
498
Tejun Heoece180d2008-11-03 20:04:37 +0900499static void ata_eh_unload(struct ata_port *ap)
500{
501 struct ata_link *link;
502 struct ata_device *dev;
503 unsigned long flags;
504
505 /* Restore SControl IPM and SPD for the next driver and
506 * disable attached devices.
507 */
508 ata_for_each_link(link, ap, PMP_FIRST) {
509 sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);
510 ata_for_each_dev(dev, link, ALL)
511 ata_dev_disable(dev);
512 }
513
514 /* freeze and set UNLOADED */
515 spin_lock_irqsave(ap->lock, flags);
516
517 ata_port_freeze(ap); /* won't be thawed */
518 ap->pflags &= ~ATA_PFLAG_EH_PENDING; /* clear pending from freeze */
519 ap->pflags |= ATA_PFLAG_UNLOADED;
520
521 spin_unlock_irqrestore(ap->lock, flags);
522}
523
Tejun Heoece1d632006-04-02 18:51:53 +0900524/**
525 * ata_scsi_error - SCSI layer error handler callback
526 * @host: SCSI host on which error occurred
527 *
528 * Handles SCSI-layer-thrown error events.
529 *
530 * LOCKING:
531 * Inherited from SCSI layer (none, can sleep)
532 *
533 * RETURNS:
534 * Zero.
535 */
Jeff Garzik381544b2006-04-11 13:04:39 -0400536void ata_scsi_error(struct Scsi_Host *host)
Tejun Heoece1d632006-04-02 18:51:53 +0900537{
Jeff Garzik35bb94b2006-04-11 13:12:34 -0400538 struct ata_port *ap = ata_shost_to_port(host);
Tejun Heoa1e10f72007-08-18 13:28:49 +0900539 int i;
Tejun Heoad9e2762006-05-15 20:58:12 +0900540 unsigned long flags;
Tejun Heoece1d632006-04-02 18:51:53 +0900541
542 DPRINTK("ENTER\n");
543
Tejun Heoad9e2762006-05-15 20:58:12 +0900544 /* synchronize with port task */
Tejun Heoece1d632006-04-02 18:51:53 +0900545 ata_port_flush_task(ap);
546
Jeff Garzikcca39742006-08-24 03:19:22 -0400547 /* synchronize with host lock and sort out timeouts */
Tejun Heoece1d632006-04-02 18:51:53 +0900548
Tejun Heoad9e2762006-05-15 20:58:12 +0900549 /* For new EH, all qcs are finished in one of three ways -
550 * normal completion, error completion, and SCSI timeout.
Alan Coxc96f1732009-03-24 10:23:46 +0000551 * Both completions can race against SCSI timeout. When normal
Tejun Heoad9e2762006-05-15 20:58:12 +0900552 * completion wins, the qc never reaches EH. When error
553 * completion wins, the qc has ATA_QCFLAG_FAILED set.
554 *
555 * When SCSI timeout wins, things are a bit more complex.
556 * Normal or error completion can occur after the timeout but
557 * before this point. In such cases, both types of
558 * completions are honored. A scmd is determined to have
559 * timed out iff its associated qc is active and not failed.
560 */
561 if (ap->ops->error_handler) {
562 struct scsi_cmnd *scmd, *tmp;
563 int nr_timedout = 0;
Tejun Heoece1d632006-04-02 18:51:53 +0900564
Tejun Heoe30349d2006-07-03 03:02:15 +0900565 spin_lock_irqsave(ap->lock, flags);
Alan Coxc96f1732009-03-24 10:23:46 +0000566
567 /* This must occur under the ap->lock as we don't want
568 a polled recovery to race the real interrupt handler
569
570 The lost_interrupt handler checks for any completed but
571 non-notified command and completes much like an IRQ handler.
572
573 We then fall into the error recovery code which will treat
574 this as if normal completion won the race */
Tejun Heoad9e2762006-05-15 20:58:12 +0900575
Alan Coxc96f1732009-03-24 10:23:46 +0000576 if (ap->ops->lost_interrupt)
577 ap->ops->lost_interrupt(ap);
578
Tejun Heoad9e2762006-05-15 20:58:12 +0900579 list_for_each_entry_safe(scmd, tmp, &host->eh_cmd_q, eh_entry) {
580 struct ata_queued_cmd *qc;
581
582 for (i = 0; i < ATA_MAX_QUEUE; i++) {
583 qc = __ata_qc_from_tag(ap, i);
584 if (qc->flags & ATA_QCFLAG_ACTIVE &&
585 qc->scsicmd == scmd)
586 break;
587 }
588
589 if (i < ATA_MAX_QUEUE) {
590 /* the scmd has an associated qc */
591 if (!(qc->flags & ATA_QCFLAG_FAILED)) {
592 /* which hasn't failed yet, timeout */
593 qc->err_mask |= AC_ERR_TIMEOUT;
594 qc->flags |= ATA_QCFLAG_FAILED;
595 nr_timedout++;
596 }
597 } else {
598 /* Normal completion occurred after
599 * SCSI timeout but before this point.
600 * Successfully complete it.
601 */
602 scmd->retries = scmd->allowed;
603 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
604 }
605 }
606
607 /* If we have timed out qcs. They belong to EH from
608 * this point but the state of the controller is
609 * unknown. Freeze the port to make sure the IRQ
610 * handler doesn't diddle with those qcs. This must
611 * be done atomically w.r.t. setting QCFLAG_FAILED.
612 */
613 if (nr_timedout)
614 __ata_port_freeze(ap);
615
Tejun Heoe30349d2006-07-03 03:02:15 +0900616 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoa1e10f72007-08-18 13:28:49 +0900617
618 /* initialize eh_tries */
619 ap->eh_tries = ATA_EH_MAX_TRIES;
Tejun Heoad9e2762006-05-15 20:58:12 +0900620 } else
Tejun Heoe30349d2006-07-03 03:02:15 +0900621 spin_unlock_wait(ap->lock);
Alan Coxc96f1732009-03-24 10:23:46 +0000622
623 /* If we timed raced normal completion and there is nothing to
624 recover nr_timedout == 0 why exactly are we doing error recovery ? */
Tejun Heoad9e2762006-05-15 20:58:12 +0900625
626 repeat:
627 /* invoke error handler */
628 if (ap->ops->error_handler) {
Tejun Heocf1b86c2007-08-06 18:36:23 +0900629 struct ata_link *link;
630
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900631 /* kill fast drain timer */
632 del_timer_sync(&ap->fastdrain_timer);
633
Tejun Heo500530f2006-07-03 16:07:27 +0900634 /* process port resume request */
635 ata_eh_handle_port_resume(ap);
636
Tejun Heof3e81b12006-05-15 20:58:21 +0900637 /* fetch & clear EH info */
Tejun Heoe30349d2006-07-03 03:02:15 +0900638 spin_lock_irqsave(ap->lock, flags);
Tejun Heof3e81b12006-05-15 20:58:21 +0900639
Tejun Heo1eca4362008-11-03 20:03:17 +0900640 ata_for_each_link(link, ap, HOST_FIRST) {
Tejun Heo00115e02007-11-27 19:28:58 +0900641 struct ata_eh_context *ehc = &link->eh_context;
642 struct ata_device *dev;
643
Tejun Heocf1b86c2007-08-06 18:36:23 +0900644 memset(&link->eh_context, 0, sizeof(link->eh_context));
645 link->eh_context.i = link->eh_info;
646 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heo00115e02007-11-27 19:28:58 +0900647
Tejun Heo1eca4362008-11-03 20:03:17 +0900648 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo00115e02007-11-27 19:28:58 +0900649 int devno = dev->devno;
650
651 ehc->saved_xfer_mode[devno] = dev->xfer_mode;
652 if (ata_ncq_enabled(dev))
653 ehc->saved_ncq_enabled |= 1 << devno;
654 }
Tejun Heocf1b86c2007-08-06 18:36:23 +0900655 }
Tejun Heof3e81b12006-05-15 20:58:21 +0900656
Tejun Heob51e9e52006-06-29 01:29:30 +0900657 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
658 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heoda917d62007-09-23 13:14:12 +0900659 ap->excl_link = NULL; /* don't maintain exclusion over EH */
Tejun Heof3e81b12006-05-15 20:58:21 +0900660
Tejun Heoe30349d2006-07-03 03:02:15 +0900661 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900662
Tejun Heo500530f2006-07-03 16:07:27 +0900663 /* invoke EH, skip if unloading or suspended */
664 if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
Tejun Heo720ba122006-05-31 18:28:13 +0900665 ap->ops->error_handler(ap);
Tejun Heoece180d2008-11-03 20:04:37 +0900666 else {
667 /* if unloading, commence suicide */
668 if ((ap->pflags & ATA_PFLAG_UNLOADING) &&
669 !(ap->pflags & ATA_PFLAG_UNLOADED))
670 ata_eh_unload(ap);
Tejun Heo720ba122006-05-31 18:28:13 +0900671 ata_eh_finish(ap);
Tejun Heoece180d2008-11-03 20:04:37 +0900672 }
Tejun Heoad9e2762006-05-15 20:58:12 +0900673
Tejun Heo500530f2006-07-03 16:07:27 +0900674 /* process port suspend request */
675 ata_eh_handle_port_suspend(ap);
676
Tejun Heoad9e2762006-05-15 20:58:12 +0900677 /* Exception might have happend after ->error_handler
678 * recovered the port but before this point. Repeat
679 * EH in such case.
680 */
Tejun Heoe30349d2006-07-03 03:02:15 +0900681 spin_lock_irqsave(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900682
Tejun Heob51e9e52006-06-29 01:29:30 +0900683 if (ap->pflags & ATA_PFLAG_EH_PENDING) {
Tejun Heoa1e10f72007-08-18 13:28:49 +0900684 if (--ap->eh_tries) {
Tejun Heoe30349d2006-07-03 03:02:15 +0900685 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900686 goto repeat;
687 }
688 ata_port_printk(ap, KERN_ERR, "EH pending after %d "
Tejun Heoa1e10f72007-08-18 13:28:49 +0900689 "tries, giving up\n", ATA_EH_MAX_TRIES);
Tejun Heo914616a2007-06-25 21:47:11 +0900690 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heoad9e2762006-05-15 20:58:12 +0900691 }
692
Tejun Heof3e81b12006-05-15 20:58:21 +0900693 /* this run is complete, make sure EH info is clear */
Tejun Heo1eca4362008-11-03 20:03:17 +0900694 ata_for_each_link(link, ap, HOST_FIRST)
Tejun Heocf1b86c2007-08-06 18:36:23 +0900695 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heof3e81b12006-05-15 20:58:21 +0900696
Tejun Heoe30349d2006-07-03 03:02:15 +0900697 /* Clear host_eh_scheduled while holding ap->lock such
Tejun Heoad9e2762006-05-15 20:58:12 +0900698 * that if exception occurs after this point but
699 * before EH completion, SCSI midlayer will
700 * re-initiate EH.
701 */
702 host->host_eh_scheduled = 0;
703
Tejun Heoe30349d2006-07-03 03:02:15 +0900704 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900705 } else {
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900706 WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
Tejun Heoad9e2762006-05-15 20:58:12 +0900707 ap->ops->eng_timeout(ap);
708 }
709
710 /* finish or retry handled scmd's and clean up */
Tejun Heoece1d632006-04-02 18:51:53 +0900711 WARN_ON(host->host_failed || !list_empty(&host->eh_cmd_q));
712
713 scsi_eh_flush_done_q(&ap->eh_done_q);
714
Tejun Heoad9e2762006-05-15 20:58:12 +0900715 /* clean up */
Tejun Heoe30349d2006-07-03 03:02:15 +0900716 spin_lock_irqsave(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900717
Tejun Heo1cdaf532006-07-03 16:07:26 +0900718 if (ap->pflags & ATA_PFLAG_LOADING)
Tejun Heob51e9e52006-06-29 01:29:30 +0900719 ap->pflags &= ~ATA_PFLAG_LOADING;
Tejun Heo1cdaf532006-07-03 16:07:26 +0900720 else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
David Howells52bad642006-11-22 14:54:01 +0000721 queue_delayed_work(ata_aux_wq, &ap->hotplug_task, 0);
Tejun Heo1cdaf532006-07-03 16:07:26 +0900722
723 if (ap->pflags & ATA_PFLAG_RECOVERED)
724 ata_port_printk(ap, KERN_INFO, "EH complete\n");
Tejun Heo580b21022006-05-31 18:28:05 +0900725
Tejun Heob51e9e52006-06-29 01:29:30 +0900726 ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
Tejun Heoad9e2762006-05-15 20:58:12 +0900727
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900728 /* tell wait_eh that we're done */
Tejun Heob51e9e52006-06-29 01:29:30 +0900729 ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900730 wake_up_all(&ap->eh_wait_q);
731
Tejun Heoe30349d2006-07-03 03:02:15 +0900732 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900733
Tejun Heoece1d632006-04-02 18:51:53 +0900734 DPRINTK("EXIT\n");
Tejun Heoece1d632006-04-02 18:51:53 +0900735}
736
737/**
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900738 * ata_port_wait_eh - Wait for the currently pending EH to complete
739 * @ap: Port to wait EH for
740 *
741 * Wait until the currently pending EH is complete.
742 *
743 * LOCKING:
744 * Kernel thread context (may sleep).
745 */
746void ata_port_wait_eh(struct ata_port *ap)
747{
748 unsigned long flags;
749 DEFINE_WAIT(wait);
750
751 retry:
Jeff Garzikba6a1302006-06-22 23:46:10 -0400752 spin_lock_irqsave(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900753
Tejun Heob51e9e52006-06-29 01:29:30 +0900754 while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900755 prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
Jeff Garzikba6a1302006-06-22 23:46:10 -0400756 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900757 schedule();
Jeff Garzikba6a1302006-06-22 23:46:10 -0400758 spin_lock_irqsave(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900759 }
Tejun Heo0a1b6222006-06-11 11:01:38 +0900760 finish_wait(&ap->eh_wait_q, &wait);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900761
Jeff Garzikba6a1302006-06-22 23:46:10 -0400762 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900763
764 /* make sure SCSI EH is complete */
Jeff Garzikcca39742006-08-24 03:19:22 -0400765 if (scsi_host_in_recovery(ap->scsi_host)) {
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900766 msleep(10);
767 goto retry;
768 }
769}
770
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900771static int ata_eh_nr_in_flight(struct ata_port *ap)
772{
773 unsigned int tag;
774 int nr = 0;
775
776 /* count only non-internal commands */
777 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
778 if (ata_qc_from_tag(ap, tag))
779 nr++;
780
781 return nr;
782}
783
784void ata_eh_fastdrain_timerfn(unsigned long arg)
785{
786 struct ata_port *ap = (void *)arg;
787 unsigned long flags;
788 int cnt;
789
790 spin_lock_irqsave(ap->lock, flags);
791
792 cnt = ata_eh_nr_in_flight(ap);
793
794 /* are we done? */
795 if (!cnt)
796 goto out_unlock;
797
798 if (cnt == ap->fastdrain_cnt) {
799 unsigned int tag;
800
801 /* No progress during the last interval, tag all
802 * in-flight qcs as timed out and freeze the port.
803 */
804 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
805 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
806 if (qc)
807 qc->err_mask |= AC_ERR_TIMEOUT;
808 }
809
810 ata_port_freeze(ap);
811 } else {
812 /* some qcs have finished, give it another chance */
813 ap->fastdrain_cnt = cnt;
814 ap->fastdrain_timer.expires =
Tejun Heo341c2c92008-05-20 02:17:51 +0900815 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900816 add_timer(&ap->fastdrain_timer);
817 }
818
819 out_unlock:
820 spin_unlock_irqrestore(ap->lock, flags);
821}
822
823/**
824 * ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
825 * @ap: target ATA port
826 * @fastdrain: activate fast drain
827 *
828 * Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
829 * is non-zero and EH wasn't pending before. Fast drain ensures
830 * that EH kicks in in timely manner.
831 *
832 * LOCKING:
833 * spin_lock_irqsave(host lock)
834 */
835static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
836{
837 int cnt;
838
839 /* already scheduled? */
840 if (ap->pflags & ATA_PFLAG_EH_PENDING)
841 return;
842
843 ap->pflags |= ATA_PFLAG_EH_PENDING;
844
845 if (!fastdrain)
846 return;
847
848 /* do we have in-flight qcs? */
849 cnt = ata_eh_nr_in_flight(ap);
850 if (!cnt)
851 return;
852
853 /* activate fast drain */
854 ap->fastdrain_cnt = cnt;
Tejun Heo341c2c92008-05-20 02:17:51 +0900855 ap->fastdrain_timer.expires =
856 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900857 add_timer(&ap->fastdrain_timer);
858}
859
Tejun Heof686bcb2006-05-15 20:58:05 +0900860/**
861 * ata_qc_schedule_eh - schedule qc for error handling
862 * @qc: command to schedule error handling for
863 *
864 * Schedule error handling for @qc. EH will kick in as soon as
865 * other commands are drained.
866 *
867 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400868 * spin_lock_irqsave(host lock)
Tejun Heof686bcb2006-05-15 20:58:05 +0900869 */
870void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
871{
872 struct ata_port *ap = qc->ap;
873
874 WARN_ON(!ap->ops->error_handler);
875
876 qc->flags |= ATA_QCFLAG_FAILED;
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900877 ata_eh_set_pending(ap, 1);
Tejun Heof686bcb2006-05-15 20:58:05 +0900878
879 /* The following will fail if timeout has already expired.
880 * ata_scsi_error() takes care of such scmds on EH entry.
881 * Note that ATA_QCFLAG_FAILED is unconditionally set after
882 * this function completes.
883 */
Jens Axboe242f9dc2008-09-14 05:55:09 -0700884 blk_abort_request(qc->scsicmd->request);
Tejun Heof686bcb2006-05-15 20:58:05 +0900885}
886
Tejun Heo7b70fc02006-05-15 20:58:07 +0900887/**
888 * ata_port_schedule_eh - schedule error handling without a qc
889 * @ap: ATA port to schedule EH for
890 *
891 * Schedule error handling for @ap. EH will kick in as soon as
892 * all commands are drained.
893 *
894 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400895 * spin_lock_irqsave(host lock)
Tejun Heo7b70fc02006-05-15 20:58:07 +0900896 */
897void ata_port_schedule_eh(struct ata_port *ap)
898{
899 WARN_ON(!ap->ops->error_handler);
900
Tejun Heof4d6d002007-05-01 11:50:15 +0200901 if (ap->pflags & ATA_PFLAG_INITIALIZING)
902 return;
903
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900904 ata_eh_set_pending(ap, 1);
Jeff Garzikcca39742006-08-24 03:19:22 -0400905 scsi_schedule_eh(ap->scsi_host);
Tejun Heo7b70fc02006-05-15 20:58:07 +0900906
907 DPRINTK("port EH scheduled\n");
908}
909
Tejun Heodbd82612007-08-06 18:36:23 +0900910static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
Tejun Heo7b70fc02006-05-15 20:58:07 +0900911{
912 int tag, nr_aborted = 0;
913
914 WARN_ON(!ap->ops->error_handler);
915
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900916 /* we're gonna abort all commands, no need for fast drain */
917 ata_eh_set_pending(ap, 0);
918
Tejun Heo7b70fc02006-05-15 20:58:07 +0900919 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
920 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
921
Tejun Heodbd82612007-08-06 18:36:23 +0900922 if (qc && (!link || qc->dev->link == link)) {
Tejun Heo7b70fc02006-05-15 20:58:07 +0900923 qc->flags |= ATA_QCFLAG_FAILED;
924 ata_qc_complete(qc);
925 nr_aborted++;
926 }
927 }
928
929 if (!nr_aborted)
930 ata_port_schedule_eh(ap);
931
932 return nr_aborted;
933}
934
Tejun Heoe3180492006-05-15 20:58:09 +0900935/**
Tejun Heodbd82612007-08-06 18:36:23 +0900936 * ata_link_abort - abort all qc's on the link
937 * @link: ATA link to abort qc's for
938 *
939 * Abort all active qc's active on @link and schedule EH.
940 *
941 * LOCKING:
942 * spin_lock_irqsave(host lock)
943 *
944 * RETURNS:
945 * Number of aborted qc's.
946 */
947int ata_link_abort(struct ata_link *link)
948{
949 return ata_do_link_abort(link->ap, link);
950}
951
952/**
953 * ata_port_abort - abort all qc's on the port
954 * @ap: ATA port to abort qc's for
955 *
956 * Abort all active qc's of @ap and schedule EH.
957 *
958 * LOCKING:
959 * spin_lock_irqsave(host_set lock)
960 *
961 * RETURNS:
962 * Number of aborted qc's.
963 */
964int ata_port_abort(struct ata_port *ap)
965{
966 return ata_do_link_abort(ap, NULL);
967}
968
969/**
Tejun Heoe3180492006-05-15 20:58:09 +0900970 * __ata_port_freeze - freeze port
971 * @ap: ATA port to freeze
972 *
973 * This function is called when HSM violation or some other
974 * condition disrupts normal operation of the port. Frozen port
975 * is not allowed to perform any operation until the port is
976 * thawed, which usually follows a successful reset.
977 *
978 * ap->ops->freeze() callback can be used for freezing the port
979 * hardware-wise (e.g. mask interrupt and stop DMA engine). If a
980 * port cannot be frozen hardware-wise, the interrupt handler
981 * must ack and clear interrupts unconditionally while the port
982 * is frozen.
983 *
984 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400985 * spin_lock_irqsave(host lock)
Tejun Heoe3180492006-05-15 20:58:09 +0900986 */
987static void __ata_port_freeze(struct ata_port *ap)
988{
989 WARN_ON(!ap->ops->error_handler);
990
991 if (ap->ops->freeze)
992 ap->ops->freeze(ap);
993
Tejun Heob51e9e52006-06-29 01:29:30 +0900994 ap->pflags |= ATA_PFLAG_FROZEN;
Tejun Heoe3180492006-05-15 20:58:09 +0900995
Tejun Heo44877b42007-02-21 01:06:51 +0900996 DPRINTK("ata%u port frozen\n", ap->print_id);
Tejun Heoe3180492006-05-15 20:58:09 +0900997}
998
999/**
1000 * ata_port_freeze - abort & freeze port
1001 * @ap: ATA port to freeze
1002 *
Jeff Garzik54c38442009-04-07 19:13:15 -04001003 * Abort and freeze @ap. The freeze operation must be called
1004 * first, because some hardware requires special operations
1005 * before the taskfile registers are accessible.
Tejun Heoe3180492006-05-15 20:58:09 +09001006 *
1007 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001008 * spin_lock_irqsave(host lock)
Tejun Heoe3180492006-05-15 20:58:09 +09001009 *
1010 * RETURNS:
1011 * Number of aborted commands.
1012 */
1013int ata_port_freeze(struct ata_port *ap)
1014{
1015 int nr_aborted;
1016
1017 WARN_ON(!ap->ops->error_handler);
1018
Tejun Heoe3180492006-05-15 20:58:09 +09001019 __ata_port_freeze(ap);
Jeff Garzik54c38442009-04-07 19:13:15 -04001020 nr_aborted = ata_port_abort(ap);
Tejun Heoe3180492006-05-15 20:58:09 +09001021
1022 return nr_aborted;
1023}
1024
1025/**
Tejun Heo7d77b242007-09-23 13:14:13 +09001026 * sata_async_notification - SATA async notification handler
1027 * @ap: ATA port where async notification is received
1028 *
1029 * Handler to be called when async notification via SDB FIS is
1030 * received. This function schedules EH if necessary.
1031 *
1032 * LOCKING:
1033 * spin_lock_irqsave(host lock)
1034 *
1035 * RETURNS:
1036 * 1 if EH is scheduled, 0 otherwise.
1037 */
1038int sata_async_notification(struct ata_port *ap)
1039{
1040 u32 sntf;
1041 int rc;
1042
1043 if (!(ap->flags & ATA_FLAG_AN))
1044 return 0;
1045
1046 rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1047 if (rc == 0)
1048 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1049
Tejun Heo071f44b2008-04-07 22:47:22 +09001050 if (!sata_pmp_attached(ap) || rc) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001051 /* PMP is not attached or SNTF is not available */
Tejun Heo071f44b2008-04-07 22:47:22 +09001052 if (!sata_pmp_attached(ap)) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001053 /* PMP is not attached. Check whether ATAPI
1054 * AN is configured. If so, notify media
1055 * change.
1056 */
1057 struct ata_device *dev = ap->link.device;
1058
1059 if ((dev->class == ATA_DEV_ATAPI) &&
1060 (dev->flags & ATA_DFLAG_AN))
1061 ata_scsi_media_change_notify(dev);
1062 return 0;
1063 } else {
1064 /* PMP is attached but SNTF is not available.
1065 * ATAPI async media change notification is
1066 * not used. The PMP must be reporting PHY
1067 * status change, schedule EH.
1068 */
1069 ata_port_schedule_eh(ap);
1070 return 1;
1071 }
1072 } else {
1073 /* PMP is attached and SNTF is available */
1074 struct ata_link *link;
1075
1076 /* check and notify ATAPI AN */
Tejun Heo1eca4362008-11-03 20:03:17 +09001077 ata_for_each_link(link, ap, EDGE) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001078 if (!(sntf & (1 << link->pmp)))
1079 continue;
1080
1081 if ((link->device->class == ATA_DEV_ATAPI) &&
1082 (link->device->flags & ATA_DFLAG_AN))
1083 ata_scsi_media_change_notify(link->device);
1084 }
1085
1086 /* If PMP is reporting that PHY status of some
1087 * downstream ports has changed, schedule EH.
1088 */
1089 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
1090 ata_port_schedule_eh(ap);
1091 return 1;
1092 }
1093
1094 return 0;
1095 }
1096}
1097
1098/**
Tejun Heoe3180492006-05-15 20:58:09 +09001099 * ata_eh_freeze_port - EH helper to freeze port
1100 * @ap: ATA port to freeze
1101 *
1102 * Freeze @ap.
1103 *
1104 * LOCKING:
1105 * None.
1106 */
1107void ata_eh_freeze_port(struct ata_port *ap)
1108{
1109 unsigned long flags;
1110
1111 if (!ap->ops->error_handler)
1112 return;
1113
Jeff Garzikba6a1302006-06-22 23:46:10 -04001114 spin_lock_irqsave(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001115 __ata_port_freeze(ap);
Jeff Garzikba6a1302006-06-22 23:46:10 -04001116 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001117}
1118
1119/**
1120 * ata_port_thaw_port - EH helper to thaw port
1121 * @ap: ATA port to thaw
1122 *
1123 * Thaw frozen port @ap.
1124 *
1125 * LOCKING:
1126 * None.
1127 */
1128void ata_eh_thaw_port(struct ata_port *ap)
1129{
1130 unsigned long flags;
1131
1132 if (!ap->ops->error_handler)
1133 return;
1134
Jeff Garzikba6a1302006-06-22 23:46:10 -04001135 spin_lock_irqsave(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001136
Tejun Heob51e9e52006-06-29 01:29:30 +09001137 ap->pflags &= ~ATA_PFLAG_FROZEN;
Tejun Heoe3180492006-05-15 20:58:09 +09001138
1139 if (ap->ops->thaw)
1140 ap->ops->thaw(ap);
1141
Jeff Garzikba6a1302006-06-22 23:46:10 -04001142 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001143
Tejun Heo44877b42007-02-21 01:06:51 +09001144 DPRINTK("ata%u port thawed\n", ap->print_id);
Tejun Heoe3180492006-05-15 20:58:09 +09001145}
1146
Tejun Heoece1d632006-04-02 18:51:53 +09001147static void ata_eh_scsidone(struct scsi_cmnd *scmd)
1148{
1149 /* nada */
1150}
1151
1152static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
1153{
1154 struct ata_port *ap = qc->ap;
1155 struct scsi_cmnd *scmd = qc->scsicmd;
1156 unsigned long flags;
1157
Jeff Garzikba6a1302006-06-22 23:46:10 -04001158 spin_lock_irqsave(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +09001159 qc->scsidone = ata_eh_scsidone;
1160 __ata_qc_complete(qc);
1161 WARN_ON(ata_tag_valid(qc->tag));
Jeff Garzikba6a1302006-06-22 23:46:10 -04001162 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +09001163
1164 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
1165}
1166
1167/**
1168 * ata_eh_qc_complete - Complete an active ATA command from EH
1169 * @qc: Command to complete
1170 *
1171 * Indicate to the mid and upper layers that an ATA command has
1172 * completed. To be used from EH.
1173 */
1174void ata_eh_qc_complete(struct ata_queued_cmd *qc)
1175{
1176 struct scsi_cmnd *scmd = qc->scsicmd;
1177 scmd->retries = scmd->allowed;
1178 __ata_eh_qc_complete(qc);
1179}
1180
1181/**
1182 * ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
1183 * @qc: Command to retry
1184 *
1185 * Indicate to the mid and upper layers that an ATA command
1186 * should be retried. To be used from EH.
1187 *
1188 * SCSI midlayer limits the number of retries to scmd->allowed.
1189 * scmd->retries is decremented for commands which get retried
1190 * due to unrelated failures (qc->err_mask is zero).
1191 */
1192void ata_eh_qc_retry(struct ata_queued_cmd *qc)
1193{
1194 struct scsi_cmnd *scmd = qc->scsicmd;
1195 if (!qc->err_mask && scmd->retries)
1196 scmd->retries--;
1197 __ata_eh_qc_complete(qc);
1198}
Tejun Heo022bdb02006-05-15 20:58:22 +09001199
1200/**
Tejun Heo678afac2009-01-29 20:31:30 +09001201 * ata_dev_disable - disable ATA device
1202 * @dev: ATA device to disable
1203 *
1204 * Disable @dev.
1205 *
1206 * Locking:
1207 * EH context.
1208 */
1209void ata_dev_disable(struct ata_device *dev)
1210{
1211 if (!ata_dev_enabled(dev))
1212 return;
1213
1214 if (ata_msg_drv(dev->link->ap))
1215 ata_dev_printk(dev, KERN_WARNING, "disabled\n");
1216 ata_acpi_on_disable(dev);
1217 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET);
1218 dev->class++;
Tejun Heo99cf6102009-01-29 20:31:32 +09001219
1220 /* From now till the next successful probe, ering is used to
1221 * track probe failures. Clear accumulated device error info.
1222 */
1223 ata_ering_clear(&dev->ering);
Tejun Heo678afac2009-01-29 20:31:30 +09001224}
1225
1226/**
Tejun Heo0ea035a2006-05-31 18:28:01 +09001227 * ata_eh_detach_dev - detach ATA device
1228 * @dev: ATA device to detach
1229 *
1230 * Detach @dev.
1231 *
1232 * LOCKING:
1233 * None.
1234 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001235void ata_eh_detach_dev(struct ata_device *dev)
Tejun Heo0ea035a2006-05-31 18:28:01 +09001236{
Tejun Heof58229f2007-08-06 18:36:23 +09001237 struct ata_link *link = dev->link;
1238 struct ata_port *ap = link->ap;
Tejun Heo90484eb2008-10-26 15:43:03 +09001239 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo0ea035a2006-05-31 18:28:01 +09001240 unsigned long flags;
1241
1242 ata_dev_disable(dev);
1243
Jeff Garzikba6a1302006-06-22 23:46:10 -04001244 spin_lock_irqsave(ap->lock, flags);
Tejun Heo0ea035a2006-05-31 18:28:01 +09001245
1246 dev->flags &= ~ATA_DFLAG_DETACH;
1247
1248 if (ata_scsi_offline_dev(dev)) {
1249 dev->flags |= ATA_DFLAG_DETACHED;
Tejun Heob51e9e52006-06-29 01:29:30 +09001250 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
Tejun Heo0ea035a2006-05-31 18:28:01 +09001251 }
1252
Tejun Heo90484eb2008-10-26 15:43:03 +09001253 /* clear per-dev EH info */
Tejun Heof58229f2007-08-06 18:36:23 +09001254 ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
1255 ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
Tejun Heo90484eb2008-10-26 15:43:03 +09001256 ehc->saved_xfer_mode[dev->devno] = 0;
1257 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
Tejun Heobeb07c12006-06-24 20:30:19 +09001258
Jeff Garzikba6a1302006-06-22 23:46:10 -04001259 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo0ea035a2006-05-31 18:28:01 +09001260}
1261
1262/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001263 * ata_eh_about_to_do - about to perform eh_action
Tejun Heo955e57d2007-08-06 18:36:23 +09001264 * @link: target ATA link
Tejun Heo47005f22006-06-19 18:27:23 +09001265 * @dev: target ATA dev for per-dev action (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09001266 * @action: action about to be performed
1267 *
1268 * Called just before performing EH actions to clear related bits
Tejun Heo955e57d2007-08-06 18:36:23 +09001269 * in @link->eh_info such that eh actions are not unnecessarily
1270 * repeated.
Tejun Heo022bdb02006-05-15 20:58:22 +09001271 *
1272 * LOCKING:
1273 * None.
1274 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001275void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
1276 unsigned int action)
Tejun Heo022bdb02006-05-15 20:58:22 +09001277{
Tejun Heo955e57d2007-08-06 18:36:23 +09001278 struct ata_port *ap = link->ap;
1279 struct ata_eh_info *ehi = &link->eh_info;
1280 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09001281 unsigned long flags;
1282
Jeff Garzikba6a1302006-06-22 23:46:10 -04001283 spin_lock_irqsave(ap->lock, flags);
Tejun Heo1cdaf532006-07-03 16:07:26 +09001284
Tejun Heo955e57d2007-08-06 18:36:23 +09001285 ata_eh_clear_action(link, dev, ehi, action);
Tejun Heo13abf502006-07-10 23:18:46 +09001286
Tejun Heoa568d1d2008-10-21 20:37:21 +09001287 /* About to take EH action, set RECOVERED. Ignore actions on
1288 * slave links as master will do them again.
1289 */
1290 if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link)
Tejun Heo1cdaf532006-07-03 16:07:26 +09001291 ap->pflags |= ATA_PFLAG_RECOVERED;
1292
Jeff Garzikba6a1302006-06-22 23:46:10 -04001293 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo022bdb02006-05-15 20:58:22 +09001294}
1295
1296/**
Tejun Heo47005f22006-06-19 18:27:23 +09001297 * ata_eh_done - EH action complete
Tejun Heo955e57d2007-08-06 18:36:23 +09001298* @ap: target ATA port
Tejun Heo47005f22006-06-19 18:27:23 +09001299 * @dev: target ATA dev for per-dev action (can be NULL)
1300 * @action: action just completed
1301 *
1302 * Called right after performing EH actions to clear related bits
Tejun Heo955e57d2007-08-06 18:36:23 +09001303 * in @link->eh_context.
Tejun Heo47005f22006-06-19 18:27:23 +09001304 *
1305 * LOCKING:
1306 * None.
1307 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001308void ata_eh_done(struct ata_link *link, struct ata_device *dev,
1309 unsigned int action)
Tejun Heo47005f22006-06-19 18:27:23 +09001310{
Tejun Heo955e57d2007-08-06 18:36:23 +09001311 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001312
Tejun Heo955e57d2007-08-06 18:36:23 +09001313 ata_eh_clear_action(link, dev, &ehc->i, action);
Tejun Heo47005f22006-06-19 18:27:23 +09001314}
1315
1316/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001317 * ata_err_string - convert err_mask to descriptive string
1318 * @err_mask: error mask to convert to string
1319 *
1320 * Convert @err_mask to descriptive string. Errors are
1321 * prioritized according to severity and only the most severe
1322 * error is reported.
1323 *
1324 * LOCKING:
1325 * None.
1326 *
1327 * RETURNS:
1328 * Descriptive string for @err_mask
1329 */
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001330static const char *ata_err_string(unsigned int err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09001331{
1332 if (err_mask & AC_ERR_HOST_BUS)
1333 return "host bus error";
1334 if (err_mask & AC_ERR_ATA_BUS)
1335 return "ATA bus error";
1336 if (err_mask & AC_ERR_TIMEOUT)
1337 return "timeout";
1338 if (err_mask & AC_ERR_HSM)
1339 return "HSM violation";
1340 if (err_mask & AC_ERR_SYSTEM)
1341 return "internal error";
1342 if (err_mask & AC_ERR_MEDIA)
1343 return "media error";
1344 if (err_mask & AC_ERR_INVALID)
1345 return "invalid argument";
1346 if (err_mask & AC_ERR_DEV)
1347 return "device error";
1348 return "unknown error";
1349}
1350
1351/**
Tejun Heoe8ee8452006-05-15 21:03:46 +09001352 * ata_read_log_page - read a specific log page
1353 * @dev: target device
1354 * @page: page to read
1355 * @buf: buffer to store read page
1356 * @sectors: number of sectors to read
1357 *
1358 * Read log page using READ_LOG_EXT command.
1359 *
1360 * LOCKING:
1361 * Kernel thread context (may sleep).
1362 *
1363 * RETURNS:
1364 * 0 on success, AC_ERR_* mask otherwise.
1365 */
1366static unsigned int ata_read_log_page(struct ata_device *dev,
1367 u8 page, void *buf, unsigned int sectors)
1368{
1369 struct ata_taskfile tf;
1370 unsigned int err_mask;
1371
1372 DPRINTK("read log page - page %d\n", page);
1373
1374 ata_tf_init(dev, &tf);
1375 tf.command = ATA_CMD_READ_LOG_EXT;
1376 tf.lbal = page;
1377 tf.nsect = sectors;
1378 tf.hob_nsect = sectors >> 8;
1379 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
1380 tf.protocol = ATA_PROT_PIO;
1381
1382 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
Tejun Heo2b789102007-10-09 15:05:44 +09001383 buf, sectors * ATA_SECT_SIZE, 0);
Tejun Heoe8ee8452006-05-15 21:03:46 +09001384
1385 DPRINTK("EXIT, err_mask=%x\n", err_mask);
1386 return err_mask;
1387}
1388
1389/**
1390 * ata_eh_read_log_10h - Read log page 10h for NCQ error details
1391 * @dev: Device to read log page 10h from
1392 * @tag: Resulting tag of the failed command
1393 * @tf: Resulting taskfile registers of the failed command
1394 *
1395 * Read log page 10h to obtain NCQ error details and clear error
1396 * condition.
1397 *
1398 * LOCKING:
1399 * Kernel thread context (may sleep).
1400 *
1401 * RETURNS:
1402 * 0 on success, -errno otherwise.
1403 */
1404static int ata_eh_read_log_10h(struct ata_device *dev,
1405 int *tag, struct ata_taskfile *tf)
1406{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001407 u8 *buf = dev->link->ap->sector_buf;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001408 unsigned int err_mask;
1409 u8 csum;
1410 int i;
1411
1412 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1);
1413 if (err_mask)
1414 return -EIO;
1415
1416 csum = 0;
1417 for (i = 0; i < ATA_SECT_SIZE; i++)
1418 csum += buf[i];
1419 if (csum)
1420 ata_dev_printk(dev, KERN_WARNING,
1421 "invalid checksum 0x%x on log page 10h\n", csum);
1422
1423 if (buf[0] & 0x80)
1424 return -ENOENT;
1425
1426 *tag = buf[0] & 0x1f;
1427
1428 tf->command = buf[2];
1429 tf->feature = buf[3];
1430 tf->lbal = buf[4];
1431 tf->lbam = buf[5];
1432 tf->lbah = buf[6];
1433 tf->device = buf[7];
1434 tf->hob_lbal = buf[8];
1435 tf->hob_lbam = buf[9];
1436 tf->hob_lbah = buf[10];
1437 tf->nsect = buf[12];
1438 tf->hob_nsect = buf[13];
1439
1440 return 0;
1441}
1442
1443/**
Tejun Heo11fc33d2008-08-30 14:20:01 +02001444 * atapi_eh_tur - perform ATAPI TEST_UNIT_READY
1445 * @dev: target ATAPI device
1446 * @r_sense_key: out parameter for sense_key
1447 *
1448 * Perform ATAPI TEST_UNIT_READY.
1449 *
1450 * LOCKING:
1451 * EH context (may sleep).
1452 *
1453 * RETURNS:
1454 * 0 on success, AC_ERR_* mask on failure.
1455 */
1456static unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
1457{
1458 u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 };
1459 struct ata_taskfile tf;
1460 unsigned int err_mask;
1461
1462 ata_tf_init(dev, &tf);
1463
1464 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1465 tf.command = ATA_CMD_PACKET;
1466 tf.protocol = ATAPI_PROT_NODATA;
1467
1468 err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
1469 if (err_mask == AC_ERR_DEV)
1470 *r_sense_key = tf.feature >> 4;
1471 return err_mask;
1472}
1473
1474/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001475 * atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
1476 * @dev: device to perform REQUEST_SENSE to
1477 * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
Tejun Heo3eabddb2008-06-10 18:28:05 +09001478 * @dfl_sense_key: default sense key to use
Tejun Heo022bdb02006-05-15 20:58:22 +09001479 *
1480 * Perform ATAPI REQUEST_SENSE after the device reported CHECK
1481 * SENSE. This function is EH helper.
1482 *
1483 * LOCKING:
1484 * Kernel thread context (may sleep).
1485 *
1486 * RETURNS:
1487 * 0 on success, AC_ERR_* mask on failure
1488 */
Tejun Heo3eabddb2008-06-10 18:28:05 +09001489static unsigned int atapi_eh_request_sense(struct ata_device *dev,
1490 u8 *sense_buf, u8 dfl_sense_key)
Tejun Heo022bdb02006-05-15 20:58:22 +09001491{
Tejun Heo3eabddb2008-06-10 18:28:05 +09001492 u8 cdb[ATAPI_CDB_LEN] =
1493 { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 };
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001494 struct ata_port *ap = dev->link->ap;
Tejun Heo022bdb02006-05-15 20:58:22 +09001495 struct ata_taskfile tf;
Tejun Heo022bdb02006-05-15 20:58:22 +09001496
1497 DPRINTK("ATAPI request sense\n");
1498
Tejun Heo022bdb02006-05-15 20:58:22 +09001499 /* FIXME: is this needed? */
1500 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
1501
Albert Lee56287762007-04-02 11:30:46 +08001502 /* initialize sense_buf with the error register,
1503 * for the case where they are -not- overwritten
1504 */
Tejun Heo022bdb02006-05-15 20:58:22 +09001505 sense_buf[0] = 0x70;
Tejun Heo3eabddb2008-06-10 18:28:05 +09001506 sense_buf[2] = dfl_sense_key;
Albert Lee56287762007-04-02 11:30:46 +08001507
Jeff Garzika617c092007-05-21 20:14:23 -04001508 /* some devices time out if garbage left in tf */
Albert Lee56287762007-04-02 11:30:46 +08001509 ata_tf_init(dev, &tf);
Tejun Heo022bdb02006-05-15 20:58:22 +09001510
Tejun Heo022bdb02006-05-15 20:58:22 +09001511 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1512 tf.command = ATA_CMD_PACKET;
1513
1514 /* is it pointless to prefer PIO for "safety reasons"? */
1515 if (ap->flags & ATA_FLAG_PIO_DMA) {
Tejun Heo0dc36882007-12-18 16:34:43 -05001516 tf.protocol = ATAPI_PROT_DMA;
Tejun Heo022bdb02006-05-15 20:58:22 +09001517 tf.feature |= ATAPI_PKT_DMA;
1518 } else {
Tejun Heo0dc36882007-12-18 16:34:43 -05001519 tf.protocol = ATAPI_PROT_PIO;
Tejun Heof2dfc1a2007-12-12 12:12:46 +09001520 tf.lbam = SCSI_SENSE_BUFFERSIZE;
1521 tf.lbah = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09001522 }
1523
1524 return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
Tejun Heo2b789102007-10-09 15:05:44 +09001525 sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
Tejun Heo022bdb02006-05-15 20:58:22 +09001526}
1527
1528/**
1529 * ata_eh_analyze_serror - analyze SError for a failed port
Tejun Heo02607312007-08-06 18:36:23 +09001530 * @link: ATA link to analyze SError for
Tejun Heo022bdb02006-05-15 20:58:22 +09001531 *
1532 * Analyze SError if available and further determine cause of
1533 * failure.
1534 *
1535 * LOCKING:
1536 * None.
1537 */
Tejun Heo02607312007-08-06 18:36:23 +09001538static void ata_eh_analyze_serror(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09001539{
Tejun Heo02607312007-08-06 18:36:23 +09001540 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09001541 u32 serror = ehc->i.serror;
1542 unsigned int err_mask = 0, action = 0;
Tejun Heof9df58c2007-09-23 13:14:13 +09001543 u32 hotplug_mask;
Tejun Heo022bdb02006-05-15 20:58:22 +09001544
Tejun Heoe0614db2008-05-19 01:15:09 +09001545 if (serror & (SERR_PERSISTENT | SERR_DATA)) {
Tejun Heo022bdb02006-05-15 20:58:22 +09001546 err_mask |= AC_ERR_ATA_BUS;
Tejun Heocf480622008-01-24 00:05:14 +09001547 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001548 }
1549 if (serror & SERR_PROTOCOL) {
1550 err_mask |= AC_ERR_HSM;
Tejun Heocf480622008-01-24 00:05:14 +09001551 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001552 }
1553 if (serror & SERR_INTERNAL) {
1554 err_mask |= AC_ERR_SYSTEM;
Tejun Heocf480622008-01-24 00:05:14 +09001555 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001556 }
Tejun Heof9df58c2007-09-23 13:14:13 +09001557
1558 /* Determine whether a hotplug event has occurred. Both
1559 * SError.N/X are considered hotplug events for enabled or
1560 * host links. For disabled PMP links, only N bit is
1561 * considered as X bit is left at 1 for link plugging.
1562 */
1563 hotplug_mask = 0;
1564
1565 if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
1566 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
1567 else
1568 hotplug_mask = SERR_PHYRDY_CHG;
1569
1570 if (serror & hotplug_mask)
Tejun Heo084fe632006-05-31 18:28:03 +09001571 ata_ehi_hotplugged(&ehc->i);
Tejun Heo022bdb02006-05-15 20:58:22 +09001572
1573 ehc->i.err_mask |= err_mask;
1574 ehc->i.action |= action;
1575}
1576
1577/**
Tejun Heoe8ee8452006-05-15 21:03:46 +09001578 * ata_eh_analyze_ncq_error - analyze NCQ error
Tejun Heo02607312007-08-06 18:36:23 +09001579 * @link: ATA link to analyze NCQ error for
Tejun Heoe8ee8452006-05-15 21:03:46 +09001580 *
1581 * Read log page 10h, determine the offending qc and acquire
1582 * error status TF. For NCQ device errors, all LLDDs have to do
1583 * is setting AC_ERR_DEV in ehi->err_mask. This function takes
1584 * care of the rest.
1585 *
1586 * LOCKING:
1587 * Kernel thread context (may sleep).
1588 */
Mark Lord10acf3b2008-05-02 02:14:53 -04001589void ata_eh_analyze_ncq_error(struct ata_link *link)
Tejun Heoe8ee8452006-05-15 21:03:46 +09001590{
Tejun Heo02607312007-08-06 18:36:23 +09001591 struct ata_port *ap = link->ap;
1592 struct ata_eh_context *ehc = &link->eh_context;
1593 struct ata_device *dev = link->device;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001594 struct ata_queued_cmd *qc;
1595 struct ata_taskfile tf;
1596 int tag, rc;
1597
1598 /* if frozen, we can't do much */
Tejun Heob51e9e52006-06-29 01:29:30 +09001599 if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heoe8ee8452006-05-15 21:03:46 +09001600 return;
1601
1602 /* is it NCQ device error? */
Tejun Heo02607312007-08-06 18:36:23 +09001603 if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
Tejun Heoe8ee8452006-05-15 21:03:46 +09001604 return;
1605
1606 /* has LLDD analyzed already? */
1607 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1608 qc = __ata_qc_from_tag(ap, tag);
1609
1610 if (!(qc->flags & ATA_QCFLAG_FAILED))
1611 continue;
1612
1613 if (qc->err_mask)
1614 return;
1615 }
1616
1617 /* okay, this error is ours */
1618 rc = ata_eh_read_log_10h(dev, &tag, &tf);
1619 if (rc) {
Tejun Heo02607312007-08-06 18:36:23 +09001620 ata_link_printk(link, KERN_ERR, "failed to read log page 10h "
Tejun Heoe8ee8452006-05-15 21:03:46 +09001621 "(errno=%d)\n", rc);
1622 return;
1623 }
1624
Tejun Heo02607312007-08-06 18:36:23 +09001625 if (!(link->sactive & (1 << tag))) {
1626 ata_link_printk(link, KERN_ERR, "log page 10h reported "
Tejun Heoe8ee8452006-05-15 21:03:46 +09001627 "inactive tag %d\n", tag);
1628 return;
1629 }
1630
1631 /* we've got the perpetrator, condemn it */
1632 qc = __ata_qc_from_tag(ap, tag);
1633 memcpy(&qc->result_tf, &tf, sizeof(tf));
Mark Lorda6116c92008-04-23 22:36:25 -04001634 qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
Tejun Heo5335b722007-07-16 14:29:40 +09001635 qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001636 ehc->i.err_mask &= ~AC_ERR_DEV;
1637}
1638
1639/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001640 * ata_eh_analyze_tf - analyze taskfile of a failed qc
1641 * @qc: qc to analyze
1642 * @tf: Taskfile registers to analyze
1643 *
1644 * Analyze taskfile of @qc and further determine cause of
1645 * failure. This function also requests ATAPI sense data if
1646 * avaliable.
1647 *
1648 * LOCKING:
1649 * Kernel thread context (may sleep).
1650 *
1651 * RETURNS:
1652 * Determined recovery action
1653 */
1654static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
1655 const struct ata_taskfile *tf)
1656{
1657 unsigned int tmp, action = 0;
1658 u8 stat = tf->command, err = tf->feature;
1659
1660 if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
1661 qc->err_mask |= AC_ERR_HSM;
Tejun Heocf480622008-01-24 00:05:14 +09001662 return ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001663 }
1664
Tejun Heoa51d6442007-03-20 15:24:11 +09001665 if (stat & (ATA_ERR | ATA_DF))
1666 qc->err_mask |= AC_ERR_DEV;
1667 else
Tejun Heo022bdb02006-05-15 20:58:22 +09001668 return 0;
1669
1670 switch (qc->dev->class) {
1671 case ATA_DEV_ATA:
1672 if (err & ATA_ICRC)
1673 qc->err_mask |= AC_ERR_ATA_BUS;
1674 if (err & ATA_UNC)
1675 qc->err_mask |= AC_ERR_MEDIA;
1676 if (err & ATA_IDNF)
1677 qc->err_mask |= AC_ERR_INVALID;
1678 break;
1679
1680 case ATA_DEV_ATAPI:
Tejun Heoa569a302006-11-21 10:40:51 +09001681 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
Tejun Heo3eabddb2008-06-10 18:28:05 +09001682 tmp = atapi_eh_request_sense(qc->dev,
1683 qc->scsicmd->sense_buffer,
1684 qc->result_tf.feature >> 4);
Tejun Heoa569a302006-11-21 10:40:51 +09001685 if (!tmp) {
1686 /* ATA_QCFLAG_SENSE_VALID is used to
1687 * tell atapi_qc_complete() that sense
1688 * data is already valid.
1689 *
1690 * TODO: interpret sense data and set
1691 * appropriate err_mask.
1692 */
1693 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1694 } else
1695 qc->err_mask |= tmp;
1696 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001697 }
1698
1699 if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
Tejun Heocf480622008-01-24 00:05:14 +09001700 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001701
1702 return action;
1703}
1704
Tejun Heo76326ac2007-11-27 19:28:59 +09001705static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
1706 int *xfer_ok)
Tejun Heo022bdb02006-05-15 20:58:22 +09001707{
Tejun Heo76326ac2007-11-27 19:28:59 +09001708 int base = 0;
1709
1710 if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
1711 *xfer_ok = 1;
1712
1713 if (!*xfer_ok)
Tejun Heo75f9caf2008-01-03 01:21:14 +09001714 base = ATA_ECAT_DUBIOUS_NONE;
Tejun Heo76326ac2007-11-27 19:28:59 +09001715
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001716 if (err_mask & AC_ERR_ATA_BUS)
Tejun Heo76326ac2007-11-27 19:28:59 +09001717 return base + ATA_ECAT_ATA_BUS;
Tejun Heo022bdb02006-05-15 20:58:22 +09001718
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001719 if (err_mask & AC_ERR_TIMEOUT)
Tejun Heo76326ac2007-11-27 19:28:59 +09001720 return base + ATA_ECAT_TOUT_HSM;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001721
Tejun Heo3884f7b2007-11-27 19:28:56 +09001722 if (eflags & ATA_EFLAG_IS_IO) {
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001723 if (err_mask & AC_ERR_HSM)
Tejun Heo76326ac2007-11-27 19:28:59 +09001724 return base + ATA_ECAT_TOUT_HSM;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001725 if ((err_mask &
1726 (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
Tejun Heo76326ac2007-11-27 19:28:59 +09001727 return base + ATA_ECAT_UNK_DEV;
Tejun Heo022bdb02006-05-15 20:58:22 +09001728 }
1729
1730 return 0;
1731}
1732
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001733struct speed_down_verdict_arg {
Tejun Heo022bdb02006-05-15 20:58:22 +09001734 u64 since;
Tejun Heo76326ac2007-11-27 19:28:59 +09001735 int xfer_ok;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001736 int nr_errors[ATA_ECAT_NR];
Tejun Heo022bdb02006-05-15 20:58:22 +09001737};
1738
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001739static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
Tejun Heo022bdb02006-05-15 20:58:22 +09001740{
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001741 struct speed_down_verdict_arg *arg = void_arg;
Tejun Heo76326ac2007-11-27 19:28:59 +09001742 int cat;
Tejun Heo022bdb02006-05-15 20:58:22 +09001743
1744 if (ent->timestamp < arg->since)
1745 return -1;
1746
Tejun Heo76326ac2007-11-27 19:28:59 +09001747 cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
1748 &arg->xfer_ok);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001749 arg->nr_errors[cat]++;
Tejun Heo76326ac2007-11-27 19:28:59 +09001750
Tejun Heo022bdb02006-05-15 20:58:22 +09001751 return 0;
1752}
1753
1754/**
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001755 * ata_eh_speed_down_verdict - Determine speed down verdict
Tejun Heo022bdb02006-05-15 20:58:22 +09001756 * @dev: Device of interest
1757 *
1758 * This function examines error ring of @dev and determines
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001759 * whether NCQ needs to be turned off, transfer speed should be
1760 * stepped down, or falling back to PIO is necessary.
Tejun Heo022bdb02006-05-15 20:58:22 +09001761 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001762 * ECAT_ATA_BUS : ATA_BUS error for any command
Tejun Heo022bdb02006-05-15 20:58:22 +09001763 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001764 * ECAT_TOUT_HSM : TIMEOUT for any command or HSM violation for
1765 * IO commands
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001766 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001767 * ECAT_UNK_DEV : Unknown DEV error for IO commands
Tejun Heo022bdb02006-05-15 20:58:22 +09001768 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001769 * ECAT_DUBIOUS_* : Identical to above three but occurred while
1770 * data transfer hasn't been verified.
1771 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001772 * Verdicts are
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001773 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001774 * NCQ_OFF : Turn off NCQ.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001775 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001776 * SPEED_DOWN : Speed down transfer speed but don't fall back
1777 * to PIO.
1778 *
1779 * FALLBACK_TO_PIO : Fall back to PIO.
1780 *
1781 * Even if multiple verdicts are returned, only one action is
Tejun Heo76326ac2007-11-27 19:28:59 +09001782 * taken per error. An action triggered by non-DUBIOUS errors
1783 * clears ering, while one triggered by DUBIOUS_* errors doesn't.
1784 * This is to expedite speed down decisions right after device is
1785 * initially configured.
Tejun Heo3884f7b2007-11-27 19:28:56 +09001786 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001787 * The followings are speed down rules. #1 and #2 deal with
1788 * DUBIOUS errors.
1789 *
1790 * 1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors
1791 * occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO.
1792 *
1793 * 2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors
1794 * occurred during last 5 mins, NCQ_OFF.
1795 *
1796 * 3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
Tejun Heo3884f7b2007-11-27 19:28:56 +09001797 * ocurred during last 5 mins, FALLBACK_TO_PIO
1798 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001799 * 4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
Tejun Heo3884f7b2007-11-27 19:28:56 +09001800 * during last 10 mins, NCQ_OFF.
1801 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001802 * 5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6
Tejun Heo3884f7b2007-11-27 19:28:56 +09001803 * UNK_DEV errors occurred during last 10 mins, SPEED_DOWN.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001804 *
Tejun Heo022bdb02006-05-15 20:58:22 +09001805 * LOCKING:
1806 * Inherited from caller.
1807 *
1808 * RETURNS:
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001809 * OR of ATA_EH_SPDN_* flags.
Tejun Heo022bdb02006-05-15 20:58:22 +09001810 */
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001811static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
Tejun Heo022bdb02006-05-15 20:58:22 +09001812{
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001813 const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
1814 u64 j64 = get_jiffies_64();
1815 struct speed_down_verdict_arg arg;
1816 unsigned int verdict = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09001817
Tejun Heo3884f7b2007-11-27 19:28:56 +09001818 /* scan past 5 mins of error history */
1819 memset(&arg, 0, sizeof(arg));
1820 arg.since = j64 - min(j64, j5mins);
1821 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1822
Tejun Heo76326ac2007-11-27 19:28:59 +09001823 if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
1824 arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
1825 verdict |= ATA_EH_SPDN_SPEED_DOWN |
1826 ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
1827
1828 if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
1829 arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
1830 verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
1831
Tejun Heo3884f7b2007-11-27 19:28:56 +09001832 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1833 arg.nr_errors[ATA_ECAT_TOUT_HSM] +
Tejun Heo663f99b2007-11-27 19:28:57 +09001834 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
Tejun Heo3884f7b2007-11-27 19:28:56 +09001835 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
1836
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001837 /* scan past 10 mins of error history */
Tejun Heo022bdb02006-05-15 20:58:22 +09001838 memset(&arg, 0, sizeof(arg));
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001839 arg.since = j64 - min(j64, j10mins);
1840 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
Tejun Heo022bdb02006-05-15 20:58:22 +09001841
Tejun Heo3884f7b2007-11-27 19:28:56 +09001842 if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1843 arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001844 verdict |= ATA_EH_SPDN_NCQ_OFF;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001845
1846 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1847 arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
Tejun Heo663f99b2007-11-27 19:28:57 +09001848 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001849 verdict |= ATA_EH_SPDN_SPEED_DOWN;
Tejun Heo022bdb02006-05-15 20:58:22 +09001850
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001851 return verdict;
Tejun Heo022bdb02006-05-15 20:58:22 +09001852}
1853
1854/**
1855 * ata_eh_speed_down - record error and speed down if necessary
1856 * @dev: Failed device
Tejun Heo3884f7b2007-11-27 19:28:56 +09001857 * @eflags: mask of ATA_EFLAG_* flags
Tejun Heo022bdb02006-05-15 20:58:22 +09001858 * @err_mask: err_mask of the error
1859 *
1860 * Record error and examine error history to determine whether
1861 * adjusting transmission speed is necessary. It also sets
1862 * transmission limits appropriately if such adjustment is
1863 * necessary.
1864 *
1865 * LOCKING:
1866 * Kernel thread context (may sleep).
1867 *
1868 * RETURNS:
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001869 * Determined recovery action.
Tejun Heo022bdb02006-05-15 20:58:22 +09001870 */
Tejun Heo3884f7b2007-11-27 19:28:56 +09001871static unsigned int ata_eh_speed_down(struct ata_device *dev,
1872 unsigned int eflags, unsigned int err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09001873{
Tejun Heob1c72912008-07-31 17:02:43 +09001874 struct ata_link *link = ata_dev_phys_link(dev);
Tejun Heo76326ac2007-11-27 19:28:59 +09001875 int xfer_ok = 0;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001876 unsigned int verdict;
1877 unsigned int action = 0;
1878
1879 /* don't bother if Cat-0 error */
Tejun Heo76326ac2007-11-27 19:28:59 +09001880 if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
Tejun Heo022bdb02006-05-15 20:58:22 +09001881 return 0;
1882
1883 /* record error and determine whether speed down is necessary */
Tejun Heo3884f7b2007-11-27 19:28:56 +09001884 ata_ering_record(&dev->ering, eflags, err_mask);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001885 verdict = ata_eh_speed_down_verdict(dev);
Tejun Heo022bdb02006-05-15 20:58:22 +09001886
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001887 /* turn off NCQ? */
1888 if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
1889 (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
1890 ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
1891 dev->flags |= ATA_DFLAG_NCQ_OFF;
1892 ata_dev_printk(dev, KERN_WARNING,
1893 "NCQ disabled due to excessive errors\n");
1894 goto done;
1895 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001896
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001897 /* speed down? */
1898 if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
1899 /* speed down SATA link speed if possible */
Tejun Heoa07d4992009-01-29 20:31:33 +09001900 if (sata_down_spd_limit(link, 0) == 0) {
Tejun Heocf480622008-01-24 00:05:14 +09001901 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001902 goto done;
1903 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001904
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001905 /* lower transfer mode */
1906 if (dev->spdn_cnt < 2) {
1907 static const int dma_dnxfer_sel[] =
1908 { ATA_DNXFER_DMA, ATA_DNXFER_40C };
1909 static const int pio_dnxfer_sel[] =
1910 { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
1911 int sel;
Tejun Heo022bdb02006-05-15 20:58:22 +09001912
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001913 if (dev->xfer_shift != ATA_SHIFT_PIO)
1914 sel = dma_dnxfer_sel[dev->spdn_cnt];
1915 else
1916 sel = pio_dnxfer_sel[dev->spdn_cnt];
1917
1918 dev->spdn_cnt++;
1919
1920 if (ata_down_xfermask_limit(dev, sel) == 0) {
Tejun Heocf480622008-01-24 00:05:14 +09001921 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001922 goto done;
1923 }
1924 }
1925 }
1926
1927 /* Fall back to PIO? Slowing down to PIO is meaningless for
Tejun Heo663f99b2007-11-27 19:28:57 +09001928 * SATA ATA devices. Consider it only for PATA and SATAPI.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001929 */
1930 if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
Tejun Heo663f99b2007-11-27 19:28:57 +09001931 (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) &&
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001932 (dev->xfer_shift != ATA_SHIFT_PIO)) {
1933 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
1934 dev->spdn_cnt = 0;
Tejun Heocf480622008-01-24 00:05:14 +09001935 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001936 goto done;
1937 }
1938 }
1939
Tejun Heo022bdb02006-05-15 20:58:22 +09001940 return 0;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001941 done:
1942 /* device has been slowed down, blow error history */
Tejun Heo76326ac2007-11-27 19:28:59 +09001943 if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS))
1944 ata_ering_clear(&dev->ering);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001945 return action;
Tejun Heo022bdb02006-05-15 20:58:22 +09001946}
1947
1948/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09001949 * ata_eh_link_autopsy - analyze error and determine recovery action
1950 * @link: host link to perform autopsy on
Tejun Heo022bdb02006-05-15 20:58:22 +09001951 *
Tejun Heo02607312007-08-06 18:36:23 +09001952 * Analyze why @link failed and determine which recovery actions
1953 * are needed. This function also sets more detailed AC_ERR_*
1954 * values and fills sense data for ATAPI CHECK SENSE.
Tejun Heo022bdb02006-05-15 20:58:22 +09001955 *
1956 * LOCKING:
1957 * Kernel thread context (may sleep).
1958 */
Tejun Heo9b1e2652007-08-06 18:36:24 +09001959static void ata_eh_link_autopsy(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09001960{
Tejun Heo02607312007-08-06 18:36:23 +09001961 struct ata_port *ap = link->ap;
Tejun Heo936fd732007-08-06 18:36:23 +09001962 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heodfcc1732007-10-31 10:17:05 +09001963 struct ata_device *dev;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001964 unsigned int all_err_mask = 0, eflags = 0;
1965 int tag;
Tejun Heo022bdb02006-05-15 20:58:22 +09001966 u32 serror;
1967 int rc;
1968
1969 DPRINTK("ENTER\n");
1970
Tejun Heo1cdaf532006-07-03 16:07:26 +09001971 if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
1972 return;
1973
Tejun Heo022bdb02006-05-15 20:58:22 +09001974 /* obtain and analyze SError */
Tejun Heo936fd732007-08-06 18:36:23 +09001975 rc = sata_scr_read(link, SCR_ERROR, &serror);
Tejun Heo022bdb02006-05-15 20:58:22 +09001976 if (rc == 0) {
1977 ehc->i.serror |= serror;
Tejun Heo02607312007-08-06 18:36:23 +09001978 ata_eh_analyze_serror(link);
Tejun Heo4e57c512007-07-16 14:29:41 +09001979 } else if (rc != -EOPNOTSUPP) {
Tejun Heocf480622008-01-24 00:05:14 +09001980 /* SError read failed, force reset and probing */
Tejun Heob558edd2008-01-24 00:05:14 +09001981 ehc->i.probe_mask |= ATA_ALL_DEVICES;
Tejun Heocf480622008-01-24 00:05:14 +09001982 ehc->i.action |= ATA_EH_RESET;
Tejun Heo4e57c512007-07-16 14:29:41 +09001983 ehc->i.err_mask |= AC_ERR_OTHER;
1984 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001985
Tejun Heoe8ee8452006-05-15 21:03:46 +09001986 /* analyze NCQ failure */
Tejun Heo02607312007-08-06 18:36:23 +09001987 ata_eh_analyze_ncq_error(link);
Tejun Heoe8ee8452006-05-15 21:03:46 +09001988
Tejun Heo022bdb02006-05-15 20:58:22 +09001989 /* any real error trumps AC_ERR_OTHER */
1990 if (ehc->i.err_mask & ~AC_ERR_OTHER)
1991 ehc->i.err_mask &= ~AC_ERR_OTHER;
1992
1993 all_err_mask |= ehc->i.err_mask;
1994
1995 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1996 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1997
Tejun Heob1c72912008-07-31 17:02:43 +09001998 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
1999 ata_dev_phys_link(qc->dev) != link)
Tejun Heo022bdb02006-05-15 20:58:22 +09002000 continue;
2001
2002 /* inherit upper level err_mask */
2003 qc->err_mask |= ehc->i.err_mask;
2004
Tejun Heo022bdb02006-05-15 20:58:22 +09002005 /* analyze TF */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002006 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002007
2008 /* DEV errors are probably spurious in case of ATA_BUS error */
2009 if (qc->err_mask & AC_ERR_ATA_BUS)
2010 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
2011 AC_ERR_INVALID);
2012
2013 /* any real error trumps unknown error */
2014 if (qc->err_mask & ~AC_ERR_OTHER)
2015 qc->err_mask &= ~AC_ERR_OTHER;
2016
2017 /* SENSE_VALID trumps dev/unknown error and revalidation */
Tejun Heof90f0822007-10-26 16:12:41 +09002018 if (qc->flags & ATA_QCFLAG_SENSE_VALID)
Tejun Heo022bdb02006-05-15 20:58:22 +09002019 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
Tejun Heo022bdb02006-05-15 20:58:22 +09002020
Tejun Heo03faab72008-03-27 19:14:24 +09002021 /* determine whether the command is worth retrying */
2022 if (!(qc->err_mask & AC_ERR_INVALID) &&
2023 ((qc->flags & ATA_QCFLAG_IO) || qc->err_mask != AC_ERR_DEV))
2024 qc->flags |= ATA_QCFLAG_RETRY;
2025
Tejun Heo022bdb02006-05-15 20:58:22 +09002026 /* accumulate error info */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002027 ehc->i.dev = qc->dev;
Tejun Heo022bdb02006-05-15 20:58:22 +09002028 all_err_mask |= qc->err_mask;
2029 if (qc->flags & ATA_QCFLAG_IO)
Tejun Heo3884f7b2007-11-27 19:28:56 +09002030 eflags |= ATA_EFLAG_IS_IO;
Tejun Heo022bdb02006-05-15 20:58:22 +09002031 }
2032
Tejun Heoa20f33f2006-05-16 12:58:24 +09002033 /* enforce default EH actions */
Tejun Heob51e9e52006-06-29 01:29:30 +09002034 if (ap->pflags & ATA_PFLAG_FROZEN ||
Tejun Heoa20f33f2006-05-16 12:58:24 +09002035 all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
Tejun Heocf480622008-01-24 00:05:14 +09002036 ehc->i.action |= ATA_EH_RESET;
Tejun Heo3884f7b2007-11-27 19:28:56 +09002037 else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) ||
2038 (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV)))
Tejun Heo4528e4d2006-07-08 20:17:26 +09002039 ehc->i.action |= ATA_EH_REVALIDATE;
Tejun Heo022bdb02006-05-15 20:58:22 +09002040
Tejun Heodfcc1732007-10-31 10:17:05 +09002041 /* If we have offending qcs and the associated failed device,
2042 * perform per-dev EH action only on the offending device.
2043 */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002044 if (ehc->i.dev) {
Tejun Heo4528e4d2006-07-08 20:17:26 +09002045 ehc->i.dev_action[ehc->i.dev->devno] |=
2046 ehc->i.action & ATA_EH_PERDEV_MASK;
2047 ehc->i.action &= ~ATA_EH_PERDEV_MASK;
Tejun Heo47005f22006-06-19 18:27:23 +09002048 }
2049
Tejun Heo2695e362008-01-10 13:41:23 +09002050 /* propagate timeout to host link */
2051 if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link))
2052 ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT;
2053
2054 /* record error and consider speeding down */
Tejun Heodfcc1732007-10-31 10:17:05 +09002055 dev = ehc->i.dev;
Tejun Heo2695e362008-01-10 13:41:23 +09002056 if (!dev && ((ata_link_max_devices(link) == 1 &&
2057 ata_dev_enabled(link->device))))
2058 dev = link->device;
Tejun Heodfcc1732007-10-31 10:17:05 +09002059
Tejun Heo76326ac2007-11-27 19:28:59 +09002060 if (dev) {
2061 if (dev->flags & ATA_DFLAG_DUBIOUS_XFER)
2062 eflags |= ATA_EFLAG_DUBIOUS_XFER;
Tejun Heo3884f7b2007-11-27 19:28:56 +09002063 ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask);
Tejun Heo76326ac2007-11-27 19:28:59 +09002064 }
Tejun Heodfcc1732007-10-31 10:17:05 +09002065
Tejun Heo022bdb02006-05-15 20:58:22 +09002066 DPRINTK("EXIT\n");
2067}
2068
2069/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09002070 * ata_eh_autopsy - analyze error and determine recovery action
2071 * @ap: host port to perform autopsy on
2072 *
2073 * Analyze all links of @ap and determine why they failed and
2074 * which recovery actions are needed.
2075 *
2076 * LOCKING:
2077 * Kernel thread context (may sleep).
2078 */
Tejun Heofb7fd612007-09-23 13:14:12 +09002079void ata_eh_autopsy(struct ata_port *ap)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002080{
2081 struct ata_link *link;
2082
Tejun Heo1eca4362008-11-03 20:03:17 +09002083 ata_for_each_link(link, ap, EDGE)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002084 ata_eh_link_autopsy(link);
Tejun Heo2695e362008-01-10 13:41:23 +09002085
Tejun Heob1c72912008-07-31 17:02:43 +09002086 /* Handle the frigging slave link. Autopsy is done similarly
2087 * but actions and flags are transferred over to the master
2088 * link and handled from there.
2089 */
2090 if (ap->slave_link) {
2091 struct ata_eh_context *mehc = &ap->link.eh_context;
2092 struct ata_eh_context *sehc = &ap->slave_link->eh_context;
2093
Tejun Heo848e4c62008-10-21 14:26:39 +09002094 /* transfer control flags from master to slave */
2095 sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK;
2096
2097 /* perform autopsy on the slave link */
Tejun Heob1c72912008-07-31 17:02:43 +09002098 ata_eh_link_autopsy(ap->slave_link);
2099
Tejun Heo848e4c62008-10-21 14:26:39 +09002100 /* transfer actions from slave to master and clear slave */
Tejun Heob1c72912008-07-31 17:02:43 +09002101 ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2102 mehc->i.action |= sehc->i.action;
2103 mehc->i.dev_action[1] |= sehc->i.dev_action[1];
2104 mehc->i.flags |= sehc->i.flags;
2105 ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2106 }
2107
Tejun Heo2695e362008-01-10 13:41:23 +09002108 /* Autopsy of fanout ports can affect host link autopsy.
2109 * Perform host link autopsy last.
2110 */
Tejun Heo071f44b2008-04-07 22:47:22 +09002111 if (sata_pmp_attached(ap))
Tejun Heo2695e362008-01-10 13:41:23 +09002112 ata_eh_link_autopsy(&ap->link);
Tejun Heo9b1e2652007-08-06 18:36:24 +09002113}
2114
2115/**
Robert Hancock65211482009-07-14 20:43:39 -06002116 * ata_get_cmd_descript - get description for ATA command
2117 * @command: ATA command code to get description for
2118 *
2119 * Return a textual description of the given command, or NULL if the
2120 * command is not known.
2121 *
2122 * LOCKING:
2123 * None
2124 */
2125const char *ata_get_cmd_descript(u8 command)
2126{
2127#ifdef CONFIG_ATA_VERBOSE_ERROR
2128 static const struct
2129 {
2130 u8 command;
2131 const char *text;
2132 } cmd_descr[] = {
2133 { ATA_CMD_DEV_RESET, "DEVICE RESET" },
2134 { ATA_CMD_CHK_POWER, "CHECK POWER MODE" },
2135 { ATA_CMD_STANDBY, "STANDBY" },
2136 { ATA_CMD_IDLE, "IDLE" },
2137 { ATA_CMD_EDD, "EXECUTE DEVICE DIAGNOSTIC" },
2138 { ATA_CMD_DOWNLOAD_MICRO, "DOWNLOAD MICROCODE" },
2139 { ATA_CMD_NOP, "NOP" },
2140 { ATA_CMD_FLUSH, "FLUSH CACHE" },
2141 { ATA_CMD_FLUSH_EXT, "FLUSH CACHE EXT" },
2142 { ATA_CMD_ID_ATA, "IDENTIFY DEVICE" },
2143 { ATA_CMD_ID_ATAPI, "IDENTIFY PACKET DEVICE" },
2144 { ATA_CMD_SERVICE, "SERVICE" },
2145 { ATA_CMD_READ, "READ DMA" },
2146 { ATA_CMD_READ_EXT, "READ DMA EXT" },
2147 { ATA_CMD_READ_QUEUED, "READ DMA QUEUED" },
2148 { ATA_CMD_READ_STREAM_EXT, "READ STREAM EXT" },
2149 { ATA_CMD_READ_STREAM_DMA_EXT, "READ STREAM DMA EXT" },
2150 { ATA_CMD_WRITE, "WRITE DMA" },
2151 { ATA_CMD_WRITE_EXT, "WRITE DMA EXT" },
2152 { ATA_CMD_WRITE_QUEUED, "WRITE DMA QUEUED EXT" },
2153 { ATA_CMD_WRITE_STREAM_EXT, "WRITE STREAM EXT" },
2154 { ATA_CMD_WRITE_STREAM_DMA_EXT, "WRITE STREAM DMA EXT" },
2155 { ATA_CMD_WRITE_FUA_EXT, "WRITE DMA FUA EXT" },
2156 { ATA_CMD_WRITE_QUEUED_FUA_EXT, "WRITE DMA QUEUED FUA EXT" },
2157 { ATA_CMD_FPDMA_READ, "READ FPDMA QUEUED" },
2158 { ATA_CMD_FPDMA_WRITE, "WRITE FPDMA QUEUED" },
2159 { ATA_CMD_PIO_READ, "READ SECTOR(S)" },
2160 { ATA_CMD_PIO_READ_EXT, "READ SECTOR(S) EXT" },
2161 { ATA_CMD_PIO_WRITE, "WRITE SECTOR(S)" },
2162 { ATA_CMD_PIO_WRITE_EXT, "WRITE SECTOR(S) EXT" },
2163 { ATA_CMD_READ_MULTI, "READ MULTIPLE" },
2164 { ATA_CMD_READ_MULTI_EXT, "READ MULTIPLE EXT" },
2165 { ATA_CMD_WRITE_MULTI, "WRITE MULTIPLE" },
2166 { ATA_CMD_WRITE_MULTI_EXT, "WRITE MULTIPLE EXT" },
2167 { ATA_CMD_WRITE_MULTI_FUA_EXT, "WRITE MULTIPLE FUA EXT" },
2168 { ATA_CMD_SET_FEATURES, "SET FEATURES" },
2169 { ATA_CMD_SET_MULTI, "SET MULTIPLE MODE" },
2170 { ATA_CMD_VERIFY, "READ VERIFY SECTOR(S)" },
2171 { ATA_CMD_VERIFY_EXT, "READ VERIFY SECTOR(S) EXT" },
2172 { ATA_CMD_WRITE_UNCORR_EXT, "WRITE UNCORRECTABLE EXT" },
2173 { ATA_CMD_STANDBYNOW1, "STANDBY IMMEDIATE" },
2174 { ATA_CMD_IDLEIMMEDIATE, "IDLE IMMEDIATE" },
2175 { ATA_CMD_SLEEP, "SLEEP" },
2176 { ATA_CMD_INIT_DEV_PARAMS, "INITIALIZE DEVICE PARAMETERS" },
2177 { ATA_CMD_READ_NATIVE_MAX, "READ NATIVE MAX ADDRESS" },
2178 { ATA_CMD_READ_NATIVE_MAX_EXT, "READ NATIVE MAX ADDRESS EXT" },
2179 { ATA_CMD_SET_MAX, "SET MAX ADDRESS" },
2180 { ATA_CMD_SET_MAX_EXT, "SET MAX ADDRESS EXT" },
2181 { ATA_CMD_READ_LOG_EXT, "READ LOG EXT" },
2182 { ATA_CMD_WRITE_LOG_EXT, "WRITE LOG EXT" },
2183 { ATA_CMD_READ_LOG_DMA_EXT, "READ LOG DMA EXT" },
2184 { ATA_CMD_WRITE_LOG_DMA_EXT, "WRITE LOG DMA EXT" },
2185 { ATA_CMD_TRUSTED_RCV, "TRUSTED RECEIVE" },
2186 { ATA_CMD_TRUSTED_RCV_DMA, "TRUSTED RECEIVE DMA" },
2187 { ATA_CMD_TRUSTED_SND, "TRUSTED SEND" },
2188 { ATA_CMD_TRUSTED_SND_DMA, "TRUSTED SEND DMA" },
2189 { ATA_CMD_PMP_READ, "READ BUFFER" },
2190 { ATA_CMD_PMP_WRITE, "WRITE BUFFER" },
2191 { ATA_CMD_CONF_OVERLAY, "DEVICE CONFIGURATION OVERLAY" },
2192 { ATA_CMD_SEC_SET_PASS, "SECURITY SET PASSWORD" },
2193 { ATA_CMD_SEC_UNLOCK, "SECURITY UNLOCK" },
2194 { ATA_CMD_SEC_ERASE_PREP, "SECURITY ERASE PREPARE" },
2195 { ATA_CMD_SEC_ERASE_UNIT, "SECURITY ERASE UNIT" },
2196 { ATA_CMD_SEC_FREEZE_LOCK, "SECURITY FREEZE LOCK" },
2197 { ATA_CMD_SEC_DISABLE_PASS, "SECURITY DISABLE PASSWORD" },
2198 { ATA_CMD_CONFIG_STREAM, "CONFIGURE STREAM" },
2199 { ATA_CMD_SMART, "SMART" },
2200 { ATA_CMD_MEDIA_LOCK, "DOOR LOCK" },
2201 { ATA_CMD_MEDIA_UNLOCK, "DOOR UNLOCK" },
2202 { ATA_CMD_CHK_MED_CRD_TYP, "CHECK MEDIA CARD TYPE" },
2203 { ATA_CMD_CFA_REQ_EXT_ERR, "CFA REQUEST EXTENDED ERROR" },
2204 { ATA_CMD_CFA_WRITE_NE, "CFA WRITE SECTORS WITHOUT ERASE" },
2205 { ATA_CMD_CFA_TRANS_SECT, "CFA TRANSLATE SECTOR" },
2206 { ATA_CMD_CFA_ERASE, "CFA ERASE SECTORS" },
2207 { ATA_CMD_CFA_WRITE_MULT_NE, "CFA WRITE MULTIPLE WITHOUT ERASE" },
2208 { ATA_CMD_READ_LONG, "READ LONG (with retries)" },
2209 { ATA_CMD_READ_LONG_ONCE, "READ LONG (without retries)" },
2210 { ATA_CMD_WRITE_LONG, "WRITE LONG (with retries)" },
2211 { ATA_CMD_WRITE_LONG_ONCE, "WRITE LONG (without retries)" },
2212 { ATA_CMD_RESTORE, "RECALIBRATE" },
2213 { 0, NULL } /* terminate list */
2214 };
2215
2216 unsigned int i;
2217 for (i = 0; cmd_descr[i].text; i++)
2218 if (cmd_descr[i].command == command)
2219 return cmd_descr[i].text;
2220#endif
2221
2222 return NULL;
2223}
2224
2225/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09002226 * ata_eh_link_report - report error handling to user
Tejun Heo02607312007-08-06 18:36:23 +09002227 * @link: ATA link EH is going on
Tejun Heo022bdb02006-05-15 20:58:22 +09002228 *
2229 * Report EH to user.
2230 *
2231 * LOCKING:
2232 * None.
2233 */
Tejun Heo9b1e2652007-08-06 18:36:24 +09002234static void ata_eh_link_report(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09002235{
Tejun Heo02607312007-08-06 18:36:23 +09002236 struct ata_port *ap = link->ap;
2237 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09002238 const char *frozen, *desc;
Tejun Heoa1e10f72007-08-18 13:28:49 +09002239 char tries_buf[6];
Tejun Heo022bdb02006-05-15 20:58:22 +09002240 int tag, nr_failed = 0;
2241
Tejun Heo94ff3d52007-10-09 14:57:56 +09002242 if (ehc->i.flags & ATA_EHI_QUIET)
2243 return;
2244
Tejun Heo022bdb02006-05-15 20:58:22 +09002245 desc = NULL;
2246 if (ehc->i.desc[0] != '\0')
2247 desc = ehc->i.desc;
2248
2249 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2250 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2251
Tejun Heob1c72912008-07-31 17:02:43 +09002252 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2253 ata_dev_phys_link(qc->dev) != link ||
Tejun Heoe027bd32007-10-26 16:19:26 +09002254 ((qc->flags & ATA_QCFLAG_QUIET) &&
2255 qc->err_mask == AC_ERR_DEV))
Tejun Heo022bdb02006-05-15 20:58:22 +09002256 continue;
2257 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
2258 continue;
2259
2260 nr_failed++;
2261 }
2262
2263 if (!nr_failed && !ehc->i.err_mask)
2264 return;
2265
2266 frozen = "";
Tejun Heob51e9e52006-06-29 01:29:30 +09002267 if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heo022bdb02006-05-15 20:58:22 +09002268 frozen = " frozen";
2269
Tejun Heoa1e10f72007-08-18 13:28:49 +09002270 memset(tries_buf, 0, sizeof(tries_buf));
2271 if (ap->eh_tries < ATA_EH_MAX_TRIES)
2272 snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
2273 ap->eh_tries);
2274
Tejun Heo022bdb02006-05-15 20:58:22 +09002275 if (ehc->i.dev) {
Tejun Heoe8ee8452006-05-15 21:03:46 +09002276 ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x "
Tejun Heoa1e10f72007-08-18 13:28:49 +09002277 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2278 ehc->i.err_mask, link->sactive, ehc->i.serror,
2279 ehc->i.action, frozen, tries_buf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002280 if (desc)
Tejun Heob64bbc32007-07-16 14:29:39 +09002281 ata_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc);
Tejun Heo022bdb02006-05-15 20:58:22 +09002282 } else {
Tejun Heo02607312007-08-06 18:36:23 +09002283 ata_link_printk(link, KERN_ERR, "exception Emask 0x%x "
Tejun Heoa1e10f72007-08-18 13:28:49 +09002284 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2285 ehc->i.err_mask, link->sactive, ehc->i.serror,
2286 ehc->i.action, frozen, tries_buf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002287 if (desc)
Tejun Heo02607312007-08-06 18:36:23 +09002288 ata_link_printk(link, KERN_ERR, "%s\n", desc);
Tejun Heo022bdb02006-05-15 20:58:22 +09002289 }
2290
Robert Hancock65211482009-07-14 20:43:39 -06002291#ifdef CONFIG_ATA_VERBOSE_ERROR
Robert Hancock1333e192007-10-02 11:22:02 -04002292 if (ehc->i.serror)
Tejun Heoda0e21d2008-07-31 16:08:38 +09002293 ata_link_printk(link, KERN_ERR,
Robert Hancock1333e192007-10-02 11:22:02 -04002294 "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
2295 ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
2296 ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
2297 ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
2298 ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
2299 ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
2300 ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
2301 ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
2302 ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
2303 ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
2304 ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
2305 ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
2306 ehc->i.serror & SERR_CRC ? "BadCRC " : "",
2307 ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
2308 ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
2309 ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
2310 ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002311 ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
Robert Hancock65211482009-07-14 20:43:39 -06002312#endif
Robert Hancock1333e192007-10-02 11:22:02 -04002313
Tejun Heo022bdb02006-05-15 20:58:22 +09002314 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2315 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
Tejun Heo8a937582006-11-14 22:36:12 +09002316 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
Tejun Heoabb6a882007-11-28 23:16:09 +09002317 const u8 *cdb = qc->cdb;
2318 char data_buf[20] = "";
2319 char cdb_buf[70] = "";
Tejun Heo022bdb02006-05-15 20:58:22 +09002320
Tejun Heo02607312007-08-06 18:36:23 +09002321 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
Tejun Heob1c72912008-07-31 17:02:43 +09002322 ata_dev_phys_link(qc->dev) != link || !qc->err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09002323 continue;
2324
Tejun Heoabb6a882007-11-28 23:16:09 +09002325 if (qc->dma_dir != DMA_NONE) {
2326 static const char *dma_str[] = {
2327 [DMA_BIDIRECTIONAL] = "bidi",
2328 [DMA_TO_DEVICE] = "out",
2329 [DMA_FROM_DEVICE] = "in",
2330 };
2331 static const char *prot_str[] = {
2332 [ATA_PROT_PIO] = "pio",
2333 [ATA_PROT_DMA] = "dma",
2334 [ATA_PROT_NCQ] = "ncq",
Tejun Heo0dc36882007-12-18 16:34:43 -05002335 [ATAPI_PROT_PIO] = "pio",
2336 [ATAPI_PROT_DMA] = "dma",
Tejun Heoabb6a882007-11-28 23:16:09 +09002337 };
2338
2339 snprintf(data_buf, sizeof(data_buf), " %s %u %s",
2340 prot_str[qc->tf.protocol], qc->nbytes,
2341 dma_str[qc->dma_dir]);
2342 }
2343
Robert Hancock65211482009-07-14 20:43:39 -06002344 if (ata_is_atapi(qc->tf.protocol)) {
2345 if (qc->scsicmd)
2346 scsi_print_command(qc->scsicmd);
2347 else
2348 snprintf(cdb_buf, sizeof(cdb_buf),
Tejun Heoabb6a882007-11-28 23:16:09 +09002349 "cdb %02x %02x %02x %02x %02x %02x %02x %02x "
2350 "%02x %02x %02x %02x %02x %02x %02x %02x\n ",
2351 cdb[0], cdb[1], cdb[2], cdb[3],
2352 cdb[4], cdb[5], cdb[6], cdb[7],
2353 cdb[8], cdb[9], cdb[10], cdb[11],
2354 cdb[12], cdb[13], cdb[14], cdb[15]);
Robert Hancock65211482009-07-14 20:43:39 -06002355 } else {
2356 const char *descr = ata_get_cmd_descript(cmd->command);
2357 if (descr)
2358 ata_dev_printk(qc->dev, KERN_ERR,
2359 "failed command: %s\n", descr);
2360 }
Tejun Heoabb6a882007-11-28 23:16:09 +09002361
Tejun Heo8a937582006-11-14 22:36:12 +09002362 ata_dev_printk(qc->dev, KERN_ERR,
2363 "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
Tejun Heoabb6a882007-11-28 23:16:09 +09002364 "tag %d%s\n %s"
Tejun Heo8a937582006-11-14 22:36:12 +09002365 "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
Tejun Heo5335b722007-07-16 14:29:40 +09002366 "Emask 0x%x (%s)%s\n",
Tejun Heo8a937582006-11-14 22:36:12 +09002367 cmd->command, cmd->feature, cmd->nsect,
2368 cmd->lbal, cmd->lbam, cmd->lbah,
2369 cmd->hob_feature, cmd->hob_nsect,
2370 cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
Tejun Heoabb6a882007-11-28 23:16:09 +09002371 cmd->device, qc->tag, data_buf, cdb_buf,
Tejun Heo8a937582006-11-14 22:36:12 +09002372 res->command, res->feature, res->nsect,
2373 res->lbal, res->lbam, res->lbah,
2374 res->hob_feature, res->hob_nsect,
2375 res->hob_lbal, res->hob_lbam, res->hob_lbah,
Tejun Heo5335b722007-07-16 14:29:40 +09002376 res->device, qc->err_mask, ata_err_string(qc->err_mask),
2377 qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
Robert Hancock1333e192007-10-02 11:22:02 -04002378
Robert Hancock65211482009-07-14 20:43:39 -06002379#ifdef CONFIG_ATA_VERBOSE_ERROR
Robert Hancock1333e192007-10-02 11:22:02 -04002380 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002381 ATA_ERR)) {
Robert Hancock1333e192007-10-02 11:22:02 -04002382 if (res->command & ATA_BUSY)
2383 ata_dev_printk(qc->dev, KERN_ERR,
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002384 "status: { Busy }\n");
Robert Hancock1333e192007-10-02 11:22:02 -04002385 else
2386 ata_dev_printk(qc->dev, KERN_ERR,
2387 "status: { %s%s%s%s}\n",
2388 res->command & ATA_DRDY ? "DRDY " : "",
2389 res->command & ATA_DF ? "DF " : "",
2390 res->command & ATA_DRQ ? "DRQ " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002391 res->command & ATA_ERR ? "ERR " : "");
Robert Hancock1333e192007-10-02 11:22:02 -04002392 }
2393
2394 if (cmd->command != ATA_CMD_PACKET &&
2395 (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
2396 ATA_ABORTED)))
2397 ata_dev_printk(qc->dev, KERN_ERR,
2398 "error: { %s%s%s%s}\n",
2399 res->feature & ATA_ICRC ? "ICRC " : "",
2400 res->feature & ATA_UNC ? "UNC " : "",
2401 res->feature & ATA_IDNF ? "IDNF " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002402 res->feature & ATA_ABORTED ? "ABRT " : "");
Robert Hancock65211482009-07-14 20:43:39 -06002403#endif
Tejun Heo022bdb02006-05-15 20:58:22 +09002404 }
2405}
2406
Tejun Heo9b1e2652007-08-06 18:36:24 +09002407/**
2408 * ata_eh_report - report error handling to user
2409 * @ap: ATA port to report EH about
2410 *
2411 * Report EH to user.
2412 *
2413 * LOCKING:
2414 * None.
2415 */
Tejun Heofb7fd612007-09-23 13:14:12 +09002416void ata_eh_report(struct ata_port *ap)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002417{
2418 struct ata_link *link;
2419
Tejun Heo1eca4362008-11-03 20:03:17 +09002420 ata_for_each_link(link, ap, HOST_FIRST)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002421 ata_eh_link_report(link);
2422}
2423
Tejun Heocc0680a2007-08-06 18:36:23 +09002424static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
Tejun Heob1c72912008-07-31 17:02:43 +09002425 unsigned int *classes, unsigned long deadline,
2426 bool clear_classes)
Tejun Heod87fa382006-05-31 18:28:24 +09002427{
Tejun Heof58229f2007-08-06 18:36:23 +09002428 struct ata_device *dev;
Tejun Heod87fa382006-05-31 18:28:24 +09002429
Tejun Heob1c72912008-07-31 17:02:43 +09002430 if (clear_classes)
Tejun Heo1eca4362008-11-03 20:03:17 +09002431 ata_for_each_dev(dev, link, ALL)
Tejun Heob1c72912008-07-31 17:02:43 +09002432 classes[dev->devno] = ATA_DEV_UNKNOWN;
Tejun Heod87fa382006-05-31 18:28:24 +09002433
Tejun Heof0465192008-05-19 01:15:08 +09002434 return reset(link, classes, deadline);
Tejun Heod87fa382006-05-31 18:28:24 +09002435}
2436
Tejun Heoae791c02007-09-23 13:14:12 +09002437static int ata_eh_followup_srst_needed(struct ata_link *link,
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002438 int rc, const unsigned int *classes)
Tejun Heo664faf02006-05-31 18:27:50 +09002439{
Tejun Heo45db2f62008-04-08 01:46:56 +09002440 if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link))
Tejun Heoae791c02007-09-23 13:14:12 +09002441 return 0;
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002442 if (rc == -EAGAIN)
2443 return 1;
Tejun Heo071f44b2008-04-07 22:47:22 +09002444 if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
Tejun Heo3495de72007-09-23 13:19:53 +09002445 return 1;
Tejun Heo664faf02006-05-31 18:27:50 +09002446 return 0;
2447}
2448
Tejun Heofb7fd612007-09-23 13:14:12 +09002449int ata_eh_reset(struct ata_link *link, int classify,
2450 ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
2451 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
Tejun Heo022bdb02006-05-15 20:58:22 +09002452{
Tejun Heoafaa5c32007-10-09 15:06:10 +09002453 struct ata_port *ap = link->ap;
Tejun Heob1c72912008-07-31 17:02:43 +09002454 struct ata_link *slave = ap->slave_link;
Tejun Heo936fd732007-08-06 18:36:23 +09002455 struct ata_eh_context *ehc = &link->eh_context;
Bartlomiej Zolnierkiewicz705d2012009-07-26 16:21:01 +02002456 struct ata_eh_context *sehc = slave ? &slave->eh_context : NULL;
Tejun Heo664faf02006-05-31 18:27:50 +09002457 unsigned int *classes = ehc->classes;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002458 unsigned int lflags = link->flags;
Tejun Heo1cdaf532006-07-03 16:07:26 +09002459 int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
Tejun Heod8af0eb2008-05-20 02:17:53 +09002460 int max_tries = 0, try = 0;
Tejun Heob1c72912008-07-31 17:02:43 +09002461 struct ata_link *failed_link;
Tejun Heof58229f2007-08-06 18:36:23 +09002462 struct ata_device *dev;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002463 unsigned long deadline, now;
Tejun Heo022bdb02006-05-15 20:58:22 +09002464 ata_reset_fn_t reset;
Tejun Heoafaa5c32007-10-09 15:06:10 +09002465 unsigned long flags;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002466 u32 sstatus;
Tejun Heob1c72912008-07-31 17:02:43 +09002467 int nr_unknown, rc;
Tejun Heo022bdb02006-05-15 20:58:22 +09002468
Tejun Heo932648b2008-05-19 01:15:06 +09002469 /*
2470 * Prepare to reset
2471 */
Tejun Heod8af0eb2008-05-20 02:17:53 +09002472 while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX)
2473 max_tries++;
Tejun Heo05944bd2008-08-13 20:19:09 +09002474 if (link->flags & ATA_LFLAG_NO_HRST)
2475 hardreset = NULL;
2476 if (link->flags & ATA_LFLAG_NO_SRST)
2477 softreset = NULL;
Tejun Heod8af0eb2008-05-20 02:17:53 +09002478
Tejun Heo19b72322008-11-04 17:08:40 +09002479 /* make sure each reset attemp is at least COOL_DOWN apart */
2480 if (ehc->i.flags & ATA_EHI_DID_RESET) {
2481 now = jiffies;
2482 WARN_ON(time_after(ehc->last_reset, now));
2483 deadline = ata_deadline(ehc->last_reset,
2484 ATA_EH_RESET_COOL_DOWN);
2485 if (time_before(now, deadline))
2486 schedule_timeout_uninterruptible(deadline - now);
2487 }
Tejun Heo0a2c0f52008-05-20 02:17:52 +09002488
Tejun Heoafaa5c32007-10-09 15:06:10 +09002489 spin_lock_irqsave(ap->lock, flags);
2490 ap->pflags |= ATA_PFLAG_RESETTING;
2491 spin_unlock_irqrestore(ap->lock, flags);
2492
Tejun Heocf480622008-01-24 00:05:14 +09002493 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
Tejun Heo13abf502006-07-10 23:18:46 +09002494
Tejun Heo1eca4362008-11-03 20:03:17 +09002495 ata_for_each_dev(dev, link, ALL) {
Tejun Heocdeab112007-10-29 16:41:09 +09002496 /* If we issue an SRST then an ATA drive (not ATAPI)
2497 * may change configuration and be in PIO0 timing. If
2498 * we do a hard reset (or are coming from power on)
2499 * this is true for ATA or ATAPI. Until we've set a
2500 * suitable controller mode we should not touch the
2501 * bus as we may be talking too fast.
2502 */
2503 dev->pio_mode = XFER_PIO_0;
2504
2505 /* If the controller has a pio mode setup function
2506 * then use it to set the chipset to rights. Don't
2507 * touch the DMA setup as that will be dealt with when
2508 * configuring devices.
2509 */
2510 if (ap->ops->set_piomode)
2511 ap->ops->set_piomode(ap, dev);
2512 }
2513
Tejun Heocf480622008-01-24 00:05:14 +09002514 /* prefer hardreset */
Tejun Heo932648b2008-05-19 01:15:06 +09002515 reset = NULL;
Tejun Heocf480622008-01-24 00:05:14 +09002516 ehc->i.action &= ~ATA_EH_RESET;
2517 if (hardreset) {
2518 reset = hardreset;
Tejun Heoa6740502008-07-31 16:07:04 +09002519 ehc->i.action |= ATA_EH_HARDRESET;
Tejun Heo4f7faa32008-01-30 18:18:26 +09002520 } else if (softreset) {
Tejun Heocf480622008-01-24 00:05:14 +09002521 reset = softreset;
Tejun Heoa6740502008-07-31 16:07:04 +09002522 ehc->i.action |= ATA_EH_SOFTRESET;
Tejun Heocf480622008-01-24 00:05:14 +09002523 }
Tejun Heof5914a42006-05-31 18:27:48 +09002524
2525 if (prereset) {
Tejun Heob1c72912008-07-31 17:02:43 +09002526 unsigned long deadline = ata_deadline(jiffies,
2527 ATA_EH_PRERESET_TIMEOUT);
2528
2529 if (slave) {
2530 sehc->i.action &= ~ATA_EH_RESET;
2531 sehc->i.action |= ehc->i.action;
2532 }
2533
2534 rc = prereset(link, deadline);
2535
2536 /* If present, do prereset on slave link too. Reset
2537 * is skipped iff both master and slave links report
2538 * -ENOENT or clear ATA_EH_RESET.
2539 */
2540 if (slave && (rc == 0 || rc == -ENOENT)) {
2541 int tmp;
2542
2543 tmp = prereset(slave, deadline);
2544 if (tmp != -ENOENT)
2545 rc = tmp;
2546
2547 ehc->i.action |= sehc->i.action;
2548 }
2549
Tejun Heof5914a42006-05-31 18:27:48 +09002550 if (rc) {
Alan Coxc9619222006-09-26 17:53:38 +01002551 if (rc == -ENOENT) {
Tejun Heocc0680a2007-08-06 18:36:23 +09002552 ata_link_printk(link, KERN_DEBUG,
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002553 "port disabled. ignoring.\n");
Tejun Heocf480622008-01-24 00:05:14 +09002554 ehc->i.action &= ~ATA_EH_RESET;
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002555
Tejun Heo1eca4362008-11-03 20:03:17 +09002556 ata_for_each_dev(dev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +09002557 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002558
2559 rc = 0;
Alan Coxc9619222006-09-26 17:53:38 +01002560 } else
Tejun Heocc0680a2007-08-06 18:36:23 +09002561 ata_link_printk(link, KERN_ERR,
Tejun Heof5914a42006-05-31 18:27:48 +09002562 "prereset failed (errno=%d)\n", rc);
Tejun Heofccb6ea2007-07-16 14:29:41 +09002563 goto out;
Tejun Heof5914a42006-05-31 18:27:48 +09002564 }
Tejun Heof5914a42006-05-31 18:27:48 +09002565
Tejun Heo932648b2008-05-19 01:15:06 +09002566 /* prereset() might have cleared ATA_EH_RESET. If so,
Tejun Heod6515e62009-03-04 15:59:30 +09002567 * bang classes, thaw and return.
Tejun Heo932648b2008-05-19 01:15:06 +09002568 */
2569 if (reset && !(ehc->i.action & ATA_EH_RESET)) {
Tejun Heo1eca4362008-11-03 20:03:17 +09002570 ata_for_each_dev(dev, link, ALL)
Tejun Heo932648b2008-05-19 01:15:06 +09002571 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heod6515e62009-03-04 15:59:30 +09002572 if ((ap->pflags & ATA_PFLAG_FROZEN) &&
2573 ata_is_host_link(link))
2574 ata_eh_thaw_port(ap);
Tejun Heo932648b2008-05-19 01:15:06 +09002575 rc = 0;
2576 goto out;
2577 }
Tejun Heof5914a42006-05-31 18:27:48 +09002578 }
2579
Tejun Heo022bdb02006-05-15 20:58:22 +09002580 retry:
Tejun Heo932648b2008-05-19 01:15:06 +09002581 /*
2582 * Perform reset
2583 */
Tejun Heodc98c322008-05-19 01:15:07 +09002584 if (ata_is_host_link(link))
2585 ata_eh_freeze_port(ap);
2586
Tejun Heo341c2c92008-05-20 02:17:51 +09002587 deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]);
Tejun Heo31daabd2007-02-02 16:50:52 +09002588
Tejun Heo932648b2008-05-19 01:15:06 +09002589 if (reset) {
2590 if (verbose)
2591 ata_link_printk(link, KERN_INFO, "%s resetting link\n",
2592 reset == softreset ? "soft" : "hard");
Tejun Heo022bdb02006-05-15 20:58:22 +09002593
Tejun Heo932648b2008-05-19 01:15:06 +09002594 /* mark that this EH session started with reset */
Tejun Heo19b72322008-11-04 17:08:40 +09002595 ehc->last_reset = jiffies;
Tejun Heo932648b2008-05-19 01:15:06 +09002596 if (reset == hardreset)
2597 ehc->i.flags |= ATA_EHI_DID_HARDRESET;
2598 else
2599 ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09002600
Tejun Heob1c72912008-07-31 17:02:43 +09002601 rc = ata_do_reset(link, reset, classes, deadline, true);
2602 if (rc && rc != -EAGAIN) {
2603 failed_link = link;
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002604 goto fail;
Tejun Heob1c72912008-07-31 17:02:43 +09002605 }
Tejun Heo022bdb02006-05-15 20:58:22 +09002606
Tejun Heob1c72912008-07-31 17:02:43 +09002607 /* hardreset slave link if existent */
2608 if (slave && reset == hardreset) {
2609 int tmp;
2610
2611 if (verbose)
2612 ata_link_printk(slave, KERN_INFO,
2613 "hard resetting link\n");
2614
2615 ata_eh_about_to_do(slave, NULL, ATA_EH_RESET);
2616 tmp = ata_do_reset(slave, reset, classes, deadline,
2617 false);
2618 switch (tmp) {
2619 case -EAGAIN:
2620 rc = -EAGAIN;
2621 case 0:
2622 break;
2623 default:
2624 failed_link = slave;
2625 rc = tmp;
2626 goto fail;
2627 }
2628 }
2629
2630 /* perform follow-up SRST if necessary */
Tejun Heo932648b2008-05-19 01:15:06 +09002631 if (reset == hardreset &&
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002632 ata_eh_followup_srst_needed(link, rc, classes)) {
Tejun Heo932648b2008-05-19 01:15:06 +09002633 reset = softreset;
Tejun Heo664faf02006-05-31 18:27:50 +09002634
Tejun Heo932648b2008-05-19 01:15:06 +09002635 if (!reset) {
2636 ata_link_printk(link, KERN_ERR,
2637 "follow-up softreset required "
2638 "but no softreset avaliable\n");
Tejun Heob1c72912008-07-31 17:02:43 +09002639 failed_link = link;
Tejun Heo932648b2008-05-19 01:15:06 +09002640 rc = -EINVAL;
2641 goto fail;
2642 }
2643
2644 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
Tejun Heob1c72912008-07-31 17:02:43 +09002645 rc = ata_do_reset(link, reset, classes, deadline, true);
Tejun Heofe2c4d02009-07-08 12:16:37 +09002646 if (rc) {
2647 failed_link = link;
2648 goto fail;
2649 }
Tejun Heo664faf02006-05-31 18:27:50 +09002650 }
Tejun Heo932648b2008-05-19 01:15:06 +09002651 } else {
2652 if (verbose)
2653 ata_link_printk(link, KERN_INFO, "no reset method "
2654 "available, skipping reset\n");
2655 if (!(lflags & ATA_LFLAG_ASSUME_CLASS))
2656 lflags |= ATA_LFLAG_ASSUME_ATA;
Tejun Heo664faf02006-05-31 18:27:50 +09002657 }
2658
Tejun Heo932648b2008-05-19 01:15:06 +09002659 /*
2660 * Post-reset processing
2661 */
Tejun Heo1eca4362008-11-03 20:03:17 +09002662 ata_for_each_dev(dev, link, ALL) {
Tejun Heo416dc9e2007-10-31 10:17:03 +09002663 /* After the reset, the device state is PIO 0 and the
2664 * controller state is undefined. Reset also wakes up
2665 * drives from sleeping mode.
2666 */
2667 dev->pio_mode = XFER_PIO_0;
2668 dev->flags &= ~ATA_DFLAG_SLEEPING;
Tejun Heo664faf02006-05-31 18:27:50 +09002669
Tejun Heo816ab892008-10-22 00:31:34 +09002670 if (!ata_phys_link_offline(ata_dev_phys_link(dev))) {
2671 /* apply class override */
2672 if (lflags & ATA_LFLAG_ASSUME_ATA)
2673 classes[dev->devno] = ATA_DEV_ATA;
2674 else if (lflags & ATA_LFLAG_ASSUME_SEMB)
2675 classes[dev->devno] = ATA_DEV_SEMB_UNSUP;
2676 } else
2677 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heo022bdb02006-05-15 20:58:22 +09002678 }
2679
Tejun Heo416dc9e2007-10-31 10:17:03 +09002680 /* record current link speed */
2681 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
2682 link->sata_spd = (sstatus >> 4) & 0xf;
Tejun Heob1c72912008-07-31 17:02:43 +09002683 if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0)
2684 slave->sata_spd = (sstatus >> 4) & 0xf;
Tejun Heo008a7892007-07-16 14:29:40 +09002685
Tejun Heodc98c322008-05-19 01:15:07 +09002686 /* thaw the port */
2687 if (ata_is_host_link(link))
2688 ata_eh_thaw_port(ap);
2689
Tejun Heof0465192008-05-19 01:15:08 +09002690 /* postreset() should clear hardware SError. Although SError
2691 * is cleared during link resume, clearing SError here is
2692 * necessary as some PHYs raise hotplug events after SRST.
2693 * This introduces race condition where hotplug occurs between
2694 * reset and here. This race is mediated by cross checking
2695 * link onlineness and classification result later.
2696 */
Tejun Heob1c72912008-07-31 17:02:43 +09002697 if (postreset) {
Tejun Heo416dc9e2007-10-31 10:17:03 +09002698 postreset(link, classes);
Tejun Heob1c72912008-07-31 17:02:43 +09002699 if (slave)
2700 postreset(slave, classes);
2701 }
Tejun Heo20952b62006-05-31 18:27:23 +09002702
Tejun Heo1e641062009-07-17 11:58:33 +09002703 /*
2704 * Some controllers can't be frozen very well and may set
2705 * spuruious error conditions during reset. Clear accumulated
2706 * error information. As reset is the final recovery action,
2707 * nothing is lost by doing this.
2708 */
Tejun Heof0465192008-05-19 01:15:08 +09002709 spin_lock_irqsave(link->ap->lock, flags);
Tejun Heo1e641062009-07-17 11:58:33 +09002710 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heob1c72912008-07-31 17:02:43 +09002711 if (slave)
Tejun Heo1e641062009-07-17 11:58:33 +09002712 memset(&slave->eh_info, 0, sizeof(link->eh_info));
2713 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heof0465192008-05-19 01:15:08 +09002714 spin_unlock_irqrestore(link->ap->lock, flags);
2715
2716 /* Make sure onlineness and classification result correspond.
2717 * Hotplug could have happened during reset and some
2718 * controllers fail to wait while a drive is spinning up after
2719 * being hotplugged causing misdetection. By cross checking
2720 * link onlineness and classification result, those conditions
2721 * can be reliably detected and retried.
2722 */
Tejun Heob1c72912008-07-31 17:02:43 +09002723 nr_unknown = 0;
Tejun Heo1eca4362008-11-03 20:03:17 +09002724 ata_for_each_dev(dev, link, ALL) {
Tejun Heof0465192008-05-19 01:15:08 +09002725 /* convert all ATA_DEV_UNKNOWN to ATA_DEV_NONE */
Tejun Heob1c72912008-07-31 17:02:43 +09002726 if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
Tejun Heof0465192008-05-19 01:15:08 +09002727 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heob1c72912008-07-31 17:02:43 +09002728 if (ata_phys_link_online(ata_dev_phys_link(dev)))
2729 nr_unknown++;
2730 }
Tejun Heof0465192008-05-19 01:15:08 +09002731 }
2732
Tejun Heob1c72912008-07-31 17:02:43 +09002733 if (classify && nr_unknown) {
Tejun Heof0465192008-05-19 01:15:08 +09002734 if (try < max_tries) {
2735 ata_link_printk(link, KERN_WARNING, "link online but "
2736 "device misclassified, retrying\n");
Tejun Heob1c72912008-07-31 17:02:43 +09002737 failed_link = link;
Tejun Heof0465192008-05-19 01:15:08 +09002738 rc = -EAGAIN;
2739 goto fail;
2740 }
2741 ata_link_printk(link, KERN_WARNING,
2742 "link online but device misclassified, "
2743 "device detection might fail\n");
2744 }
2745
Tejun Heo416dc9e2007-10-31 10:17:03 +09002746 /* reset successful, schedule revalidation */
Tejun Heocf480622008-01-24 00:05:14 +09002747 ata_eh_done(link, NULL, ATA_EH_RESET);
Tejun Heob1c72912008-07-31 17:02:43 +09002748 if (slave)
2749 ata_eh_done(slave, NULL, ATA_EH_RESET);
Tejun Heo19b72322008-11-04 17:08:40 +09002750 ehc->last_reset = jiffies; /* update to completion time */
Tejun Heo416dc9e2007-10-31 10:17:03 +09002751 ehc->i.action |= ATA_EH_REVALIDATE;
Tejun Heoae791c02007-09-23 13:14:12 +09002752
Tejun Heo416dc9e2007-10-31 10:17:03 +09002753 rc = 0;
Tejun Heofccb6ea2007-07-16 14:29:41 +09002754 out:
2755 /* clear hotplug flag */
2756 ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
Tejun Heob1c72912008-07-31 17:02:43 +09002757 if (slave)
2758 sehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
Tejun Heoafaa5c32007-10-09 15:06:10 +09002759
2760 spin_lock_irqsave(ap->lock, flags);
2761 ap->pflags &= ~ATA_PFLAG_RESETTING;
2762 spin_unlock_irqrestore(ap->lock, flags);
2763
Tejun Heo022bdb02006-05-15 20:58:22 +09002764 return rc;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002765
2766 fail:
Tejun Heo5958e302008-04-07 22:47:20 +09002767 /* if SCR isn't accessible on a fan-out port, PMP needs to be reset */
2768 if (!ata_is_host_link(link) &&
2769 sata_scr_read(link, SCR_STATUS, &sstatus))
2770 rc = -ERESTART;
2771
Tejun Heo416dc9e2007-10-31 10:17:03 +09002772 if (rc == -ERESTART || try >= max_tries)
2773 goto out;
2774
2775 now = jiffies;
2776 if (time_before(now, deadline)) {
2777 unsigned long delta = deadline - now;
2778
Tejun Heob1c72912008-07-31 17:02:43 +09002779 ata_link_printk(failed_link, KERN_WARNING,
Tejun Heo0a2c0f52008-05-20 02:17:52 +09002780 "reset failed (errno=%d), retrying in %u secs\n",
2781 rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));
Tejun Heo416dc9e2007-10-31 10:17:03 +09002782
2783 while (delta)
2784 delta = schedule_timeout_uninterruptible(delta);
2785 }
2786
Tejun Heob1c72912008-07-31 17:02:43 +09002787 if (try == max_tries - 1) {
Tejun Heoa07d4992009-01-29 20:31:33 +09002788 sata_down_spd_limit(link, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002789 if (slave)
Tejun Heoa07d4992009-01-29 20:31:33 +09002790 sata_down_spd_limit(slave, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002791 } else if (rc == -EPIPE)
Tejun Heoa07d4992009-01-29 20:31:33 +09002792 sata_down_spd_limit(failed_link, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002793
Tejun Heo416dc9e2007-10-31 10:17:03 +09002794 if (hardreset)
2795 reset = hardreset;
2796 goto retry;
Tejun Heo022bdb02006-05-15 20:58:22 +09002797}
2798
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02002799static inline void ata_eh_pull_park_action(struct ata_port *ap)
2800{
2801 struct ata_link *link;
2802 struct ata_device *dev;
2803 unsigned long flags;
2804
2805 /*
2806 * This function can be thought of as an extended version of
2807 * ata_eh_about_to_do() specially crafted to accommodate the
2808 * requirements of ATA_EH_PARK handling. Since the EH thread
2809 * does not leave the do {} while () loop in ata_eh_recover as
2810 * long as the timeout for a park request to *one* device on
2811 * the port has not expired, and since we still want to pick
2812 * up park requests to other devices on the same port or
2813 * timeout updates for the same device, we have to pull
2814 * ATA_EH_PARK actions from eh_info into eh_context.i
2815 * ourselves at the beginning of each pass over the loop.
2816 *
2817 * Additionally, all write accesses to &ap->park_req_pending
2818 * through INIT_COMPLETION() (see below) or complete_all()
2819 * (see ata_scsi_park_store()) are protected by the host lock.
2820 * As a result we have that park_req_pending.done is zero on
2821 * exit from this function, i.e. when ATA_EH_PARK actions for
2822 * *all* devices on port ap have been pulled into the
2823 * respective eh_context structs. If, and only if,
2824 * park_req_pending.done is non-zero by the time we reach
2825 * wait_for_completion_timeout(), another ATA_EH_PARK action
2826 * has been scheduled for at least one of the devices on port
2827 * ap and we have to cycle over the do {} while () loop in
2828 * ata_eh_recover() again.
2829 */
2830
2831 spin_lock_irqsave(ap->lock, flags);
2832 INIT_COMPLETION(ap->park_req_pending);
Tejun Heo1eca4362008-11-03 20:03:17 +09002833 ata_for_each_link(link, ap, EDGE) {
2834 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02002835 struct ata_eh_info *ehi = &link->eh_info;
2836
2837 link->eh_context.i.dev_action[dev->devno] |=
2838 ehi->dev_action[dev->devno] & ATA_EH_PARK;
2839 ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK);
2840 }
2841 }
2842 spin_unlock_irqrestore(ap->lock, flags);
2843}
2844
2845static void ata_eh_park_issue_cmd(struct ata_device *dev, int park)
2846{
2847 struct ata_eh_context *ehc = &dev->link->eh_context;
2848 struct ata_taskfile tf;
2849 unsigned int err_mask;
2850
2851 ata_tf_init(dev, &tf);
2852 if (park) {
2853 ehc->unloaded_mask |= 1 << dev->devno;
2854 tf.command = ATA_CMD_IDLEIMMEDIATE;
2855 tf.feature = 0x44;
2856 tf.lbal = 0x4c;
2857 tf.lbam = 0x4e;
2858 tf.lbah = 0x55;
2859 } else {
2860 ehc->unloaded_mask &= ~(1 << dev->devno);
2861 tf.command = ATA_CMD_CHK_POWER;
2862 }
2863
2864 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
2865 tf.protocol |= ATA_PROT_NODATA;
2866 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
2867 if (park && (err_mask || tf.lbal != 0xc4)) {
2868 ata_dev_printk(dev, KERN_ERR, "head unload failed!\n");
2869 ehc->unloaded_mask &= ~(1 << dev->devno);
2870 }
2871}
2872
Tejun Heo02607312007-08-06 18:36:23 +09002873static int ata_eh_revalidate_and_attach(struct ata_link *link,
Tejun Heo084fe632006-05-31 18:28:03 +09002874 struct ata_device **r_failed_dev)
Tejun Heo022bdb02006-05-15 20:58:22 +09002875{
Tejun Heo02607312007-08-06 18:36:23 +09002876 struct ata_port *ap = link->ap;
2877 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09002878 struct ata_device *dev;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002879 unsigned int new_mask = 0;
Tejun Heo084fe632006-05-31 18:28:03 +09002880 unsigned long flags;
Tejun Heof58229f2007-08-06 18:36:23 +09002881 int rc = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09002882
2883 DPRINTK("ENTER\n");
2884
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002885 /* For PATA drive side cable detection to work, IDENTIFY must
2886 * be done backwards such that PDIAG- is released by the slave
2887 * device before the master device is identified.
2888 */
Tejun Heo1eca4362008-11-03 20:03:17 +09002889 ata_for_each_dev(dev, link, ALL_REVERSE) {
Tejun Heof58229f2007-08-06 18:36:23 +09002890 unsigned int action = ata_eh_dev_action(dev);
2891 unsigned int readid_flags = 0;
Tejun Heo47005f22006-06-19 18:27:23 +09002892
Tejun Heobff04642006-11-10 18:08:10 +09002893 if (ehc->i.flags & ATA_EHI_DID_RESET)
2894 readid_flags |= ATA_READID_POSTRESET;
2895
Tejun Heo9666f402007-05-04 21:27:47 +02002896 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
Tejun Heo633273a2007-09-23 13:19:54 +09002897 WARN_ON(dev->class == ATA_DEV_PMP);
2898
Tejun Heob1c72912008-07-31 17:02:43 +09002899 if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
Tejun Heo022bdb02006-05-15 20:58:22 +09002900 rc = -EIO;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002901 goto err;
Tejun Heo022bdb02006-05-15 20:58:22 +09002902 }
2903
Tejun Heo02607312007-08-06 18:36:23 +09002904 ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
Tejun Heo422c9da2007-09-23 13:14:12 +09002905 rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
2906 readid_flags);
Tejun Heo022bdb02006-05-15 20:58:22 +09002907 if (rc)
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002908 goto err;
Tejun Heo022bdb02006-05-15 20:58:22 +09002909
Tejun Heo02607312007-08-06 18:36:23 +09002910 ata_eh_done(link, dev, ATA_EH_REVALIDATE);
Tejun Heo47005f22006-06-19 18:27:23 +09002911
Tejun Heobaa1e782006-11-01 18:39:27 +09002912 /* Configuration may have changed, reconfigure
2913 * transfer mode.
2914 */
2915 ehc->i.flags |= ATA_EHI_SETMODE;
2916
zhao, forrest3057ac32006-06-12 12:01:34 +08002917 /* schedule the scsi_rescan_device() here */
2918 queue_work(ata_aux_wq, &(ap->scsi_rescan_task));
Tejun Heo084fe632006-05-31 18:28:03 +09002919 } else if (dev->class == ATA_DEV_UNKNOWN &&
2920 ehc->tries[dev->devno] &&
2921 ata_class_enabled(ehc->classes[dev->devno])) {
Tejun Heo842faa62009-05-10 01:06:54 +09002922 /* Temporarily set dev->class, it will be
2923 * permanently set once all configurations are
2924 * complete. This is necessary because new
2925 * device configuration is done in two
2926 * separate loops.
2927 */
Tejun Heo084fe632006-05-31 18:28:03 +09002928 dev->class = ehc->classes[dev->devno];
2929
Tejun Heo633273a2007-09-23 13:19:54 +09002930 if (dev->class == ATA_DEV_PMP)
2931 rc = sata_pmp_attach(dev);
2932 else
2933 rc = ata_dev_read_id(dev, &dev->class,
2934 readid_flags, dev->id);
Tejun Heo842faa62009-05-10 01:06:54 +09002935
2936 /* read_id might have changed class, store and reset */
2937 ehc->classes[dev->devno] = dev->class;
2938 dev->class = ATA_DEV_UNKNOWN;
2939
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002940 switch (rc) {
2941 case 0:
Tejun Heo99cf6102009-01-29 20:31:32 +09002942 /* clear error info accumulated during probe */
2943 ata_ering_clear(&dev->ering);
Tejun Heof58229f2007-08-06 18:36:23 +09002944 new_mask |= 1 << dev->devno;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002945 break;
2946 case -ENOENT:
Tejun Heo55a8e2c2006-11-10 18:08:10 +09002947 /* IDENTIFY was issued to non-existent
2948 * device. No need to reset. Just
Tejun Heo842faa62009-05-10 01:06:54 +09002949 * thaw and ignore the device.
Tejun Heo55a8e2c2006-11-10 18:08:10 +09002950 */
2951 ata_eh_thaw_port(ap);
Tejun Heo084fe632006-05-31 18:28:03 +09002952 break;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002953 default:
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002954 goto err;
Tejun Heo55a8e2c2006-11-10 18:08:10 +09002955 }
Tejun Heo022bdb02006-05-15 20:58:22 +09002956 }
2957 }
2958
Tejun Heoc1c4e8d2007-04-23 02:05:53 +09002959 /* PDIAG- should have been released, ask cable type if post-reset */
Tejun Heo33267322008-02-13 09:15:09 +09002960 if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) {
2961 if (ap->ops->cable_detect)
2962 ap->cbl = ap->ops->cable_detect(ap);
2963 ata_force_cbl(ap);
2964 }
Tejun Heoc1c4e8d2007-04-23 02:05:53 +09002965
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002966 /* Configure new devices forward such that user doesn't see
2967 * device detection messages backwards.
2968 */
Tejun Heo1eca4362008-11-03 20:03:17 +09002969 ata_for_each_dev(dev, link, ALL) {
Tejun Heo633273a2007-09-23 13:19:54 +09002970 if (!(new_mask & (1 << dev->devno)) ||
2971 dev->class == ATA_DEV_PMP)
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002972 continue;
2973
Tejun Heo842faa62009-05-10 01:06:54 +09002974 dev->class = ehc->classes[dev->devno];
2975
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002976 ehc->i.flags |= ATA_EHI_PRINTINFO;
2977 rc = ata_dev_configure(dev);
2978 ehc->i.flags &= ~ATA_EHI_PRINTINFO;
Tejun Heo842faa62009-05-10 01:06:54 +09002979 if (rc) {
2980 dev->class = ATA_DEV_UNKNOWN;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002981 goto err;
Tejun Heo842faa62009-05-10 01:06:54 +09002982 }
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002983
2984 spin_lock_irqsave(ap->lock, flags);
2985 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
2986 spin_unlock_irqrestore(ap->lock, flags);
2987
2988 /* new device discovered, configure xfermode */
2989 ehc->i.flags |= ATA_EHI_SETMODE;
2990 }
2991
2992 return 0;
2993
2994 err:
2995 *r_failed_dev = dev;
2996 DPRINTK("EXIT rc=%d\n", rc);
Tejun Heo022bdb02006-05-15 20:58:22 +09002997 return rc;
2998}
2999
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003000/**
3001 * ata_set_mode - Program timings and issue SET FEATURES - XFER
3002 * @link: link on which timings will be programmed
Martin Olsson98a17082009-04-22 18:21:29 +02003003 * @r_failed_dev: out parameter for failed device
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003004 *
3005 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If
3006 * ata_set_mode() fails, pointer to the failing device is
3007 * returned in @r_failed_dev.
3008 *
3009 * LOCKING:
3010 * PCI/etc. bus probe sem.
3011 *
3012 * RETURNS:
3013 * 0 on success, negative errno otherwise
3014 */
3015int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3016{
3017 struct ata_port *ap = link->ap;
Tejun Heo00115e02007-11-27 19:28:58 +09003018 struct ata_device *dev;
3019 int rc;
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003020
Tejun Heo76326ac2007-11-27 19:28:59 +09003021 /* if data transfer is verified, clear DUBIOUS_XFER on ering top */
Tejun Heo1eca4362008-11-03 20:03:17 +09003022 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo76326ac2007-11-27 19:28:59 +09003023 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) {
3024 struct ata_ering_entry *ent;
3025
3026 ent = ata_ering_top(&dev->ering);
3027 if (ent)
3028 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER;
3029 }
3030 }
3031
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003032 /* has private set_mode? */
3033 if (ap->ops->set_mode)
Tejun Heo00115e02007-11-27 19:28:58 +09003034 rc = ap->ops->set_mode(link, r_failed_dev);
3035 else
3036 rc = ata_do_set_mode(link, r_failed_dev);
3037
3038 /* if transfer mode has changed, set DUBIOUS_XFER on device */
Tejun Heo1eca4362008-11-03 20:03:17 +09003039 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo00115e02007-11-27 19:28:58 +09003040 struct ata_eh_context *ehc = &link->eh_context;
3041 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno];
3042 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno));
3043
3044 if (dev->xfer_mode != saved_xfer_mode ||
3045 ata_ncq_enabled(dev) != saved_ncq)
3046 dev->flags |= ATA_DFLAG_DUBIOUS_XFER;
3047 }
3048
3049 return rc;
Tejun Heo6f1d1e32007-11-27 19:28:55 +09003050}
3051
Tejun Heo11fc33d2008-08-30 14:20:01 +02003052/**
3053 * atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset
3054 * @dev: ATAPI device to clear UA for
3055 *
3056 * Resets and other operations can make an ATAPI device raise
3057 * UNIT ATTENTION which causes the next operation to fail. This
3058 * function clears UA.
3059 *
3060 * LOCKING:
3061 * EH context (may sleep).
3062 *
3063 * RETURNS:
3064 * 0 on success, -errno on failure.
3065 */
3066static int atapi_eh_clear_ua(struct ata_device *dev)
3067{
3068 int i;
3069
3070 for (i = 0; i < ATA_EH_UA_TRIES; i++) {
Tejun Heob5357082009-03-02 18:55:16 +09003071 u8 *sense_buffer = dev->link->ap->sector_buf;
Tejun Heo11fc33d2008-08-30 14:20:01 +02003072 u8 sense_key = 0;
3073 unsigned int err_mask;
3074
3075 err_mask = atapi_eh_tur(dev, &sense_key);
3076 if (err_mask != 0 && err_mask != AC_ERR_DEV) {
3077 ata_dev_printk(dev, KERN_WARNING, "TEST_UNIT_READY "
3078 "failed (err_mask=0x%x)\n", err_mask);
3079 return -EIO;
3080 }
3081
3082 if (!err_mask || sense_key != UNIT_ATTENTION)
3083 return 0;
3084
3085 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key);
3086 if (err_mask) {
3087 ata_dev_printk(dev, KERN_WARNING, "failed to clear "
3088 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask);
3089 return -EIO;
3090 }
3091 }
3092
3093 ata_dev_printk(dev, KERN_WARNING,
3094 "UNIT ATTENTION persists after %d tries\n", ATA_EH_UA_TRIES);
3095
3096 return 0;
3097}
3098
Tejun Heo02607312007-08-06 18:36:23 +09003099static int ata_link_nr_enabled(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09003100{
Tejun Heof58229f2007-08-06 18:36:23 +09003101 struct ata_device *dev;
3102 int cnt = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003103
Tejun Heo1eca4362008-11-03 20:03:17 +09003104 ata_for_each_dev(dev, link, ENABLED)
3105 cnt++;
Tejun Heo022bdb02006-05-15 20:58:22 +09003106 return cnt;
3107}
3108
Tejun Heo02607312007-08-06 18:36:23 +09003109static int ata_link_nr_vacant(struct ata_link *link)
Tejun Heo084fe632006-05-31 18:28:03 +09003110{
Tejun Heof58229f2007-08-06 18:36:23 +09003111 struct ata_device *dev;
3112 int cnt = 0;
Tejun Heo084fe632006-05-31 18:28:03 +09003113
Tejun Heo1eca4362008-11-03 20:03:17 +09003114 ata_for_each_dev(dev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +09003115 if (dev->class == ATA_DEV_UNKNOWN)
Tejun Heo084fe632006-05-31 18:28:03 +09003116 cnt++;
3117 return cnt;
3118}
3119
Tejun Heo02607312007-08-06 18:36:23 +09003120static int ata_eh_skip_recovery(struct ata_link *link)
Tejun Heo084fe632006-05-31 18:28:03 +09003121{
Tejun Heo672b2d62008-01-24 00:05:14 +09003122 struct ata_port *ap = link->ap;
Tejun Heo02607312007-08-06 18:36:23 +09003123 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heof58229f2007-08-06 18:36:23 +09003124 struct ata_device *dev;
Tejun Heo084fe632006-05-31 18:28:03 +09003125
Tejun Heof9df58c2007-09-23 13:14:13 +09003126 /* skip disabled links */
3127 if (link->flags & ATA_LFLAG_DISABLED)
3128 return 1;
3129
Tejun Heo672b2d62008-01-24 00:05:14 +09003130 /* thaw frozen port and recover failed devices */
3131 if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link))
3132 return 0;
3133
3134 /* reset at least once if reset is requested */
3135 if ((ehc->i.action & ATA_EH_RESET) &&
3136 !(ehc->i.flags & ATA_EHI_DID_RESET))
Tejun Heo084fe632006-05-31 18:28:03 +09003137 return 0;
3138
3139 /* skip if class codes for all vacant slots are ATA_DEV_NONE */
Tejun Heo1eca4362008-11-03 20:03:17 +09003140 ata_for_each_dev(dev, link, ALL) {
Tejun Heo084fe632006-05-31 18:28:03 +09003141 if (dev->class == ATA_DEV_UNKNOWN &&
3142 ehc->classes[dev->devno] != ATA_DEV_NONE)
3143 return 0;
3144 }
3145
3146 return 1;
3147}
3148
Tejun Heoc2c7a892009-01-29 20:31:34 +09003149static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg)
3150{
3151 u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL);
3152 u64 now = get_jiffies_64();
3153 int *trials = void_arg;
3154
3155 if (ent->timestamp < now - min(now, interval))
3156 return -1;
3157
3158 (*trials)++;
3159 return 0;
3160}
3161
Tejun Heo02c05a22007-11-27 19:28:54 +09003162static int ata_eh_schedule_probe(struct ata_device *dev)
3163{
3164 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heoc2c7a892009-01-29 20:31:34 +09003165 struct ata_link *link = ata_dev_phys_link(dev);
3166 int trials = 0;
Tejun Heo02c05a22007-11-27 19:28:54 +09003167
3168 if (!(ehc->i.probe_mask & (1 << dev->devno)) ||
3169 (ehc->did_probe_mask & (1 << dev->devno)))
3170 return 0;
3171
3172 ata_eh_detach_dev(dev);
3173 ata_dev_init(dev);
3174 ehc->did_probe_mask |= (1 << dev->devno);
Tejun Heocf480622008-01-24 00:05:14 +09003175 ehc->i.action |= ATA_EH_RESET;
Tejun Heo00115e02007-11-27 19:28:58 +09003176 ehc->saved_xfer_mode[dev->devno] = 0;
3177 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
Tejun Heo02c05a22007-11-27 19:28:54 +09003178
Tejun Heoc2c7a892009-01-29 20:31:34 +09003179 /* Record and count probe trials on the ering. The specific
3180 * error mask used is irrelevant. Because a successful device
3181 * detection clears the ering, this count accumulates only if
3182 * there are consecutive failed probes.
3183 *
3184 * If the count is equal to or higher than ATA_EH_PROBE_TRIALS
3185 * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is
3186 * forced to 1.5Gbps.
3187 *
3188 * This is to work around cases where failed link speed
3189 * negotiation results in device misdetection leading to
3190 * infinite DEVXCHG or PHRDY CHG events.
3191 */
3192 ata_ering_record(&dev->ering, 0, AC_ERR_OTHER);
3193 ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials);
3194
3195 if (trials > ATA_EH_PROBE_TRIALS)
3196 sata_down_spd_limit(link, 1);
3197
Tejun Heo02c05a22007-11-27 19:28:54 +09003198 return 1;
3199}
3200
Tejun Heo9b1e2652007-08-06 18:36:24 +09003201static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
Tejun Heofee7ca72007-07-01 19:05:58 +09003202{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09003203 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heofee7ca72007-07-01 19:05:58 +09003204
Tejun Heocf9a5902009-01-29 20:31:35 +09003205 /* -EAGAIN from EH routine indicates retry without prejudice.
3206 * The requester is responsible for ensuring forward progress.
3207 */
3208 if (err != -EAGAIN)
3209 ehc->tries[dev->devno]--;
Tejun Heofee7ca72007-07-01 19:05:58 +09003210
3211 switch (err) {
3212 case -ENODEV:
3213 /* device missing or wrong IDENTIFY data, schedule probing */
3214 ehc->i.probe_mask |= (1 << dev->devno);
3215 case -EINVAL:
3216 /* give it just one more chance */
3217 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
3218 case -EIO:
Tejun Heod89293a2009-01-29 20:31:29 +09003219 if (ehc->tries[dev->devno] == 1) {
Tejun Heofee7ca72007-07-01 19:05:58 +09003220 /* This is the last chance, better to slow
3221 * down than lose it.
3222 */
Tejun Heoa07d4992009-01-29 20:31:33 +09003223 sata_down_spd_limit(ata_dev_phys_link(dev), 0);
Tejun Heod89293a2009-01-29 20:31:29 +09003224 if (dev->pio_mode > XFER_PIO_0)
3225 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
Tejun Heofee7ca72007-07-01 19:05:58 +09003226 }
3227 }
3228
3229 if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
3230 /* disable device if it has used up all its chances */
3231 ata_dev_disable(dev);
3232
3233 /* detach if offline */
Tejun Heob1c72912008-07-31 17:02:43 +09003234 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
Tejun Heofee7ca72007-07-01 19:05:58 +09003235 ata_eh_detach_dev(dev);
3236
Tejun Heo02c05a22007-11-27 19:28:54 +09003237 /* schedule probe if necessary */
Tejun Heo87fbc5a2008-05-20 02:17:54 +09003238 if (ata_eh_schedule_probe(dev)) {
Tejun Heofee7ca72007-07-01 19:05:58 +09003239 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
Tejun Heo87fbc5a2008-05-20 02:17:54 +09003240 memset(ehc->cmd_timeout_idx[dev->devno], 0,
3241 sizeof(ehc->cmd_timeout_idx[dev->devno]));
3242 }
Tejun Heo9b1e2652007-08-06 18:36:24 +09003243
3244 return 1;
Tejun Heofee7ca72007-07-01 19:05:58 +09003245 } else {
Tejun Heocf480622008-01-24 00:05:14 +09003246 ehc->i.action |= ATA_EH_RESET;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003247 return 0;
Tejun Heofee7ca72007-07-01 19:05:58 +09003248 }
3249}
3250
Tejun Heo022bdb02006-05-15 20:58:22 +09003251/**
3252 * ata_eh_recover - recover host port after error
3253 * @ap: host port to recover
Tejun Heof5914a42006-05-31 18:27:48 +09003254 * @prereset: prereset method (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09003255 * @softreset: softreset method (can be NULL)
3256 * @hardreset: hardreset method (can be NULL)
3257 * @postreset: postreset method (can be NULL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003258 * @r_failed_link: out parameter for failed link
Tejun Heo022bdb02006-05-15 20:58:22 +09003259 *
3260 * This is the alpha and omega, eum and yang, heart and soul of
3261 * libata exception handling. On entry, actions required to
Tejun Heo9b1e2652007-08-06 18:36:24 +09003262 * recover each link and hotplug requests are recorded in the
3263 * link's eh_context. This function executes all the operations
3264 * with appropriate retrials and fallbacks to resurrect failed
Tejun Heo084fe632006-05-31 18:28:03 +09003265 * devices, detach goners and greet newcomers.
Tejun Heo022bdb02006-05-15 20:58:22 +09003266 *
3267 * LOCKING:
3268 * Kernel thread context (may sleep).
3269 *
3270 * RETURNS:
3271 * 0 on success, -errno on failure.
3272 */
Tejun Heofb7fd612007-09-23 13:14:12 +09003273int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
3274 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3275 ata_postreset_fn_t postreset,
3276 struct ata_link **r_failed_link)
Tejun Heo022bdb02006-05-15 20:58:22 +09003277{
Tejun Heo9b1e2652007-08-06 18:36:24 +09003278 struct ata_link *link;
Tejun Heo022bdb02006-05-15 20:58:22 +09003279 struct ata_device *dev;
Tejun Heo0a2c0f52008-05-20 02:17:52 +09003280 int nr_failed_devs;
Tejun Heodc98c322008-05-19 01:15:07 +09003281 int rc;
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003282 unsigned long flags, deadline;
Tejun Heo022bdb02006-05-15 20:58:22 +09003283
3284 DPRINTK("ENTER\n");
3285
3286 /* prep for recovery */
Tejun Heo1eca4362008-11-03 20:03:17 +09003287 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003288 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo084fe632006-05-31 18:28:03 +09003289
Tejun Heof9df58c2007-09-23 13:14:13 +09003290 /* re-enable link? */
3291 if (ehc->i.action & ATA_EH_ENABLE_LINK) {
3292 ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
3293 spin_lock_irqsave(ap->lock, flags);
3294 link->flags &= ~ATA_LFLAG_DISABLED;
3295 spin_unlock_irqrestore(ap->lock, flags);
3296 ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
3297 }
3298
Tejun Heo1eca4362008-11-03 20:03:17 +09003299 ata_for_each_dev(dev, link, ALL) {
Tejun Heofd995f72007-09-23 13:14:12 +09003300 if (link->flags & ATA_LFLAG_NO_RETRY)
3301 ehc->tries[dev->devno] = 1;
3302 else
3303 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
Tejun Heo79a55b72007-01-18 17:22:18 +09003304
Tejun Heo9b1e2652007-08-06 18:36:24 +09003305 /* collect port action mask recorded in dev actions */
3306 ehc->i.action |= ehc->i.dev_action[dev->devno] &
3307 ~ATA_EH_PERDEV_MASK;
3308 ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
Tejun Heo084fe632006-05-31 18:28:03 +09003309
Tejun Heo9b1e2652007-08-06 18:36:24 +09003310 /* process hotplug request */
3311 if (dev->flags & ATA_DFLAG_DETACH)
3312 ata_eh_detach_dev(dev);
3313
Tejun Heo02c05a22007-11-27 19:28:54 +09003314 /* schedule probe if necessary */
3315 if (!ata_dev_enabled(dev))
3316 ata_eh_schedule_probe(dev);
Tejun Heo084fe632006-05-31 18:28:03 +09003317 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003318 }
3319
3320 retry:
Tejun Heo022bdb02006-05-15 20:58:22 +09003321 rc = 0;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003322 nr_failed_devs = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003323
Tejun Heoaeb2ecd2006-06-12 14:11:43 +09003324 /* if UNLOADING, finish immediately */
Tejun Heob51e9e52006-06-29 01:29:30 +09003325 if (ap->pflags & ATA_PFLAG_UNLOADING)
Tejun Heoaeb2ecd2006-06-12 14:11:43 +09003326 goto out;
3327
Tejun Heo9b1e2652007-08-06 18:36:24 +09003328 /* prep for EH */
Tejun Heo1eca4362008-11-03 20:03:17 +09003329 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003330 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003331
Tejun Heo9b1e2652007-08-06 18:36:24 +09003332 /* skip EH if possible. */
3333 if (ata_eh_skip_recovery(link))
3334 ehc->i.action = 0;
3335
Tejun Heo1eca4362008-11-03 20:03:17 +09003336 ata_for_each_dev(dev, link, ALL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003337 ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
3338 }
Tejun Heo084fe632006-05-31 18:28:03 +09003339
Tejun Heo022bdb02006-05-15 20:58:22 +09003340 /* reset */
Tejun Heo1eca4362008-11-03 20:03:17 +09003341 ata_for_each_link(link, ap, EDGE) {
Tejun Heodc98c322008-05-19 01:15:07 +09003342 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003343
Tejun Heodc98c322008-05-19 01:15:07 +09003344 if (!(ehc->i.action & ATA_EH_RESET))
3345 continue;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003346
Tejun Heodc98c322008-05-19 01:15:07 +09003347 rc = ata_eh_reset(link, ata_link_nr_vacant(link),
3348 prereset, softreset, hardreset, postreset);
3349 if (rc) {
3350 ata_link_printk(link, KERN_ERR,
3351 "reset failed, giving up\n");
3352 goto out;
Tejun Heo022bdb02006-05-15 20:58:22 +09003353 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003354 }
3355
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003356 do {
3357 unsigned long now;
3358
3359 /*
3360 * clears ATA_EH_PARK in eh_info and resets
3361 * ap->park_req_pending
3362 */
3363 ata_eh_pull_park_action(ap);
3364
3365 deadline = jiffies;
Tejun Heo1eca4362008-11-03 20:03:17 +09003366 ata_for_each_link(link, ap, EDGE) {
3367 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003368 struct ata_eh_context *ehc = &link->eh_context;
3369 unsigned long tmp;
3370
3371 if (dev->class != ATA_DEV_ATA)
3372 continue;
3373 if (!(ehc->i.dev_action[dev->devno] &
3374 ATA_EH_PARK))
3375 continue;
3376 tmp = dev->unpark_deadline;
3377 if (time_before(deadline, tmp))
3378 deadline = tmp;
3379 else if (time_before_eq(tmp, jiffies))
3380 continue;
3381 if (ehc->unloaded_mask & (1 << dev->devno))
3382 continue;
3383
3384 ata_eh_park_issue_cmd(dev, 1);
3385 }
3386 }
3387
3388 now = jiffies;
3389 if (time_before_eq(deadline, now))
3390 break;
3391
3392 deadline = wait_for_completion_timeout(&ap->park_req_pending,
3393 deadline - now);
3394 } while (deadline);
Tejun Heo1eca4362008-11-03 20:03:17 +09003395 ata_for_each_link(link, ap, EDGE) {
3396 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003397 if (!(link->eh_context.unloaded_mask &
3398 (1 << dev->devno)))
3399 continue;
3400
3401 ata_eh_park_issue_cmd(dev, 0);
3402 ata_eh_done(link, dev, ATA_EH_PARK);
3403 }
3404 }
3405
Tejun Heo9b1e2652007-08-06 18:36:24 +09003406 /* the rest */
Tejun Heo1eca4362008-11-03 20:03:17 +09003407 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003408 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003409
Tejun Heo9b1e2652007-08-06 18:36:24 +09003410 /* revalidate existing devices and attach new ones */
3411 rc = ata_eh_revalidate_and_attach(link, &dev);
Tejun Heo4ae72a12007-02-02 16:22:30 +09003412 if (rc)
Tejun Heo022bdb02006-05-15 20:58:22 +09003413 goto dev_fail;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003414
Tejun Heo633273a2007-09-23 13:19:54 +09003415 /* if PMP got attached, return, pmp EH will take care of it */
3416 if (link->device->class == ATA_DEV_PMP) {
3417 ehc->i.action = 0;
3418 return 0;
3419 }
3420
Tejun Heo9b1e2652007-08-06 18:36:24 +09003421 /* configure transfer mode if necessary */
3422 if (ehc->i.flags & ATA_EHI_SETMODE) {
3423 rc = ata_set_mode(link, &dev);
3424 if (rc)
3425 goto dev_fail;
3426 ehc->i.flags &= ~ATA_EHI_SETMODE;
3427 }
3428
Tejun Heo11fc33d2008-08-30 14:20:01 +02003429 /* If reset has been issued, clear UA to avoid
3430 * disrupting the current users of the device.
3431 */
3432 if (ehc->i.flags & ATA_EHI_DID_RESET) {
Tejun Heo1eca4362008-11-03 20:03:17 +09003433 ata_for_each_dev(dev, link, ALL) {
Tejun Heo11fc33d2008-08-30 14:20:01 +02003434 if (dev->class != ATA_DEV_ATAPI)
3435 continue;
3436 rc = atapi_eh_clear_ua(dev);
3437 if (rc)
3438 goto dev_fail;
3439 }
3440 }
3441
3442 /* configure link power saving */
Tejun Heo3ec25eb2008-03-27 18:37:14 +09003443 if (ehc->i.action & ATA_EH_LPM)
Tejun Heo1eca4362008-11-03 20:03:17 +09003444 ata_for_each_dev(dev, link, ALL)
Kristen Carlson Accardica773292007-10-25 00:58:59 -04003445 ata_dev_enable_pm(dev, ap->pm_policy);
3446
Tejun Heo9b1e2652007-08-06 18:36:24 +09003447 /* this link is okay now */
3448 ehc->i.flags = 0;
3449 continue;
3450
Jeff Garzik2dcb4072007-10-19 06:42:56 -04003451dev_fail:
Tejun Heo9b1e2652007-08-06 18:36:24 +09003452 nr_failed_devs++;
Tejun Heo0a2c0f52008-05-20 02:17:52 +09003453 ata_eh_handle_dev_fail(dev, rc);
Tejun Heo9b1e2652007-08-06 18:36:24 +09003454
Tejun Heob06ce3e2007-10-09 15:06:48 +09003455 if (ap->pflags & ATA_PFLAG_FROZEN) {
3456 /* PMP reset requires working host port.
3457 * Can't retry if it's frozen.
3458 */
Tejun Heo071f44b2008-04-07 22:47:22 +09003459 if (sata_pmp_attached(ap))
Tejun Heob06ce3e2007-10-09 15:06:48 +09003460 goto out;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003461 break;
Tejun Heob06ce3e2007-10-09 15:06:48 +09003462 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003463 }
3464
Tejun Heo0a2c0f52008-05-20 02:17:52 +09003465 if (nr_failed_devs)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003466 goto retry;
Tejun Heo022bdb02006-05-15 20:58:22 +09003467
Tejun Heo022bdb02006-05-15 20:58:22 +09003468 out:
Tejun Heo9b1e2652007-08-06 18:36:24 +09003469 if (rc && r_failed_link)
3470 *r_failed_link = link;
Tejun Heo022bdb02006-05-15 20:58:22 +09003471
3472 DPRINTK("EXIT, rc=%d\n", rc);
3473 return rc;
3474}
3475
3476/**
3477 * ata_eh_finish - finish up EH
3478 * @ap: host port to finish EH for
3479 *
3480 * Recovery is complete. Clean up EH states and retry or finish
3481 * failed qcs.
3482 *
3483 * LOCKING:
3484 * None.
3485 */
Tejun Heofb7fd612007-09-23 13:14:12 +09003486void ata_eh_finish(struct ata_port *ap)
Tejun Heo022bdb02006-05-15 20:58:22 +09003487{
3488 int tag;
3489
3490 /* retry or finish qcs */
3491 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
3492 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
3493
3494 if (!(qc->flags & ATA_QCFLAG_FAILED))
3495 continue;
3496
3497 if (qc->err_mask) {
3498 /* FIXME: Once EH migration is complete,
3499 * generate sense data in this function,
3500 * considering both err_mask and tf.
3501 */
Tejun Heo03faab72008-03-27 19:14:24 +09003502 if (qc->flags & ATA_QCFLAG_RETRY)
Tejun Heo022bdb02006-05-15 20:58:22 +09003503 ata_eh_qc_retry(qc);
Tejun Heo03faab72008-03-27 19:14:24 +09003504 else
3505 ata_eh_qc_complete(qc);
Tejun Heo022bdb02006-05-15 20:58:22 +09003506 } else {
3507 if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
3508 ata_eh_qc_complete(qc);
3509 } else {
3510 /* feed zero TF to sense generation */
3511 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
3512 ata_eh_qc_retry(qc);
3513 }
3514 }
3515 }
Tejun Heoda917d62007-09-23 13:14:12 +09003516
3517 /* make sure nr_active_links is zero after EH */
3518 WARN_ON(ap->nr_active_links);
3519 ap->nr_active_links = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003520}
3521
3522/**
3523 * ata_do_eh - do standard error handling
3524 * @ap: host port to handle error for
Tejun Heoa1efdab2008-03-25 12:22:50 +09003525 *
Tejun Heof5914a42006-05-31 18:27:48 +09003526 * @prereset: prereset method (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09003527 * @softreset: softreset method (can be NULL)
3528 * @hardreset: hardreset method (can be NULL)
3529 * @postreset: postreset method (can be NULL)
3530 *
3531 * Perform standard error handling sequence.
3532 *
3533 * LOCKING:
3534 * Kernel thread context (may sleep).
3535 */
Tejun Heof5914a42006-05-31 18:27:48 +09003536void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
3537 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3538 ata_postreset_fn_t postreset)
Tejun Heo022bdb02006-05-15 20:58:22 +09003539{
Tejun Heo9b1e2652007-08-06 18:36:24 +09003540 struct ata_device *dev;
3541 int rc;
3542
3543 ata_eh_autopsy(ap);
3544 ata_eh_report(ap);
3545
3546 rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
3547 NULL);
3548 if (rc) {
Tejun Heo1eca4362008-11-03 20:03:17 +09003549 ata_for_each_dev(dev, &ap->link, ALL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003550 ata_dev_disable(dev);
3551 }
3552
Tejun Heo022bdb02006-05-15 20:58:22 +09003553 ata_eh_finish(ap);
3554}
Tejun Heo500530f2006-07-03 16:07:27 +09003555
Tejun Heoa1efdab2008-03-25 12:22:50 +09003556/**
3557 * ata_std_error_handler - standard error handler
3558 * @ap: host port to handle error for
3559 *
3560 * Standard error handler
3561 *
3562 * LOCKING:
3563 * Kernel thread context (may sleep).
3564 */
3565void ata_std_error_handler(struct ata_port *ap)
3566{
3567 struct ata_port_operations *ops = ap->ops;
3568 ata_reset_fn_t hardreset = ops->hardreset;
3569
Tejun Heo57c9efd2008-04-07 22:47:19 +09003570 /* ignore built-in hardreset if SCR access is not available */
3571 if (ata_is_builtin_hardreset(hardreset) && !sata_scr_valid(&ap->link))
Tejun Heoa1efdab2008-03-25 12:22:50 +09003572 hardreset = NULL;
3573
3574 ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);
3575}
3576
Tejun Heo6ffa01d2007-03-02 17:32:47 +09003577#ifdef CONFIG_PM
Tejun Heo500530f2006-07-03 16:07:27 +09003578/**
3579 * ata_eh_handle_port_suspend - perform port suspend operation
3580 * @ap: port to suspend
3581 *
3582 * Suspend @ap.
3583 *
3584 * LOCKING:
3585 * Kernel thread context (may sleep).
3586 */
3587static void ata_eh_handle_port_suspend(struct ata_port *ap)
3588{
3589 unsigned long flags;
3590 int rc = 0;
3591
3592 /* are we suspending? */
3593 spin_lock_irqsave(ap->lock, flags);
3594 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
3595 ap->pm_mesg.event == PM_EVENT_ON) {
3596 spin_unlock_irqrestore(ap->lock, flags);
3597 return;
3598 }
3599 spin_unlock_irqrestore(ap->lock, flags);
3600
3601 WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
3602
Tejun Heo64578a32007-05-15 03:28:16 +09003603 /* tell ACPI we're suspending */
3604 rc = ata_acpi_on_suspend(ap);
3605 if (rc)
3606 goto out;
3607
Tejun Heo500530f2006-07-03 16:07:27 +09003608 /* suspend */
3609 ata_eh_freeze_port(ap);
3610
3611 if (ap->ops->port_suspend)
3612 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
3613
Shaohua Libd3adca2007-11-02 09:32:38 +08003614 ata_acpi_set_state(ap, PMSG_SUSPEND);
Tejun Heo64578a32007-05-15 03:28:16 +09003615 out:
Tejun Heo500530f2006-07-03 16:07:27 +09003616 /* report result */
3617 spin_lock_irqsave(ap->lock, flags);
3618
3619 ap->pflags &= ~ATA_PFLAG_PM_PENDING;
3620 if (rc == 0)
3621 ap->pflags |= ATA_PFLAG_SUSPENDED;
Tejun Heo64578a32007-05-15 03:28:16 +09003622 else if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heo500530f2006-07-03 16:07:27 +09003623 ata_port_schedule_eh(ap);
3624
3625 if (ap->pm_result) {
3626 *ap->pm_result = rc;
3627 ap->pm_result = NULL;
3628 }
3629
3630 spin_unlock_irqrestore(ap->lock, flags);
3631
3632 return;
3633}
3634
3635/**
3636 * ata_eh_handle_port_resume - perform port resume operation
3637 * @ap: port to resume
3638 *
3639 * Resume @ap.
3640 *
Tejun Heo500530f2006-07-03 16:07:27 +09003641 * LOCKING:
3642 * Kernel thread context (may sleep).
3643 */
3644static void ata_eh_handle_port_resume(struct ata_port *ap)
3645{
Tejun Heo6f9c1ea2009-04-23 09:55:28 +09003646 struct ata_link *link;
3647 struct ata_device *dev;
Tejun Heo500530f2006-07-03 16:07:27 +09003648 unsigned long flags;
Tejun Heo9666f402007-05-04 21:27:47 +02003649 int rc = 0;
Tejun Heo500530f2006-07-03 16:07:27 +09003650
3651 /* are we resuming? */
3652 spin_lock_irqsave(ap->lock, flags);
3653 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
3654 ap->pm_mesg.event != PM_EVENT_ON) {
3655 spin_unlock_irqrestore(ap->lock, flags);
3656 return;
3657 }
3658 spin_unlock_irqrestore(ap->lock, flags);
3659
Tejun Heo9666f402007-05-04 21:27:47 +02003660 WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
Tejun Heo500530f2006-07-03 16:07:27 +09003661
Tejun Heo6f9c1ea2009-04-23 09:55:28 +09003662 /*
3663 * Error timestamps are in jiffies which doesn't run while
3664 * suspended and PHY events during resume isn't too uncommon.
3665 * When the two are combined, it can lead to unnecessary speed
3666 * downs if the machine is suspended and resumed repeatedly.
3667 * Clear error history.
3668 */
3669 ata_for_each_link(link, ap, HOST_FIRST)
3670 ata_for_each_dev(dev, link, ALL)
3671 ata_ering_clear(&dev->ering);
3672
Shaohua Libd3adca2007-11-02 09:32:38 +08003673 ata_acpi_set_state(ap, PMSG_ON);
3674
Tejun Heo500530f2006-07-03 16:07:27 +09003675 if (ap->ops->port_resume)
3676 rc = ap->ops->port_resume(ap);
3677
Tejun Heo67465442007-05-15 03:28:16 +09003678 /* tell ACPI that we're resuming */
3679 ata_acpi_on_resume(ap);
3680
Tejun Heo9666f402007-05-04 21:27:47 +02003681 /* report result */
Tejun Heo500530f2006-07-03 16:07:27 +09003682 spin_lock_irqsave(ap->lock, flags);
3683 ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
3684 if (ap->pm_result) {
3685 *ap->pm_result = rc;
3686 ap->pm_result = NULL;
3687 }
3688 spin_unlock_irqrestore(ap->lock, flags);
3689}
Tejun Heo6ffa01d2007-03-02 17:32:47 +09003690#endif /* CONFIG_PM */