blob: fa22f94ca4150247b39a0e26fa7541d4cbee4ba4 [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>
Jeff Garzikc6fd2802006-08-10 07:31:37 -040043#include "../scsi/scsi_transport_api.h"
Tejun Heoece1d632006-04-02 18:51:53 +090044
45#include <linux/libata.h>
46
47#include "libata.h"
48
Tejun Heo7d47e8d2007-02-02 16:22:31 +090049enum {
Tejun Heo3884f7b2007-11-27 19:28:56 +090050 /* speed down verdicts */
Tejun Heo7d47e8d2007-02-02 16:22:31 +090051 ATA_EH_SPDN_NCQ_OFF = (1 << 0),
52 ATA_EH_SPDN_SPEED_DOWN = (1 << 1),
53 ATA_EH_SPDN_FALLBACK_TO_PIO = (1 << 2),
Tejun Heo76326ac2007-11-27 19:28:59 +090054 ATA_EH_SPDN_KEEP_ERRORS = (1 << 3),
Tejun Heo3884f7b2007-11-27 19:28:56 +090055
56 /* error flags */
57 ATA_EFLAG_IS_IO = (1 << 0),
Tejun Heo76326ac2007-11-27 19:28:59 +090058 ATA_EFLAG_DUBIOUS_XFER = (1 << 1),
Tejun Heo3884f7b2007-11-27 19:28:56 +090059
60 /* error categories */
61 ATA_ECAT_NONE = 0,
62 ATA_ECAT_ATA_BUS = 1,
63 ATA_ECAT_TOUT_HSM = 2,
64 ATA_ECAT_UNK_DEV = 3,
Tejun Heo75f9caf2008-01-03 01:21:14 +090065 ATA_ECAT_DUBIOUS_NONE = 4,
66 ATA_ECAT_DUBIOUS_ATA_BUS = 5,
67 ATA_ECAT_DUBIOUS_TOUT_HSM = 6,
68 ATA_ECAT_DUBIOUS_UNK_DEV = 7,
69 ATA_ECAT_NR = 8,
Tejun Heo7d47e8d2007-02-02 16:22:31 +090070
Tejun Heo87fbc5a2008-05-20 02:17:54 +090071 ATA_EH_CMD_DFL_TIMEOUT = 5000,
72
Tejun Heo0a2c0f52008-05-20 02:17:52 +090073 /* always put at least this amount of time between resets */
74 ATA_EH_RESET_COOL_DOWN = 5000,
75
Tejun Heo341c2c92008-05-20 02:17:51 +090076 /* Waiting in ->prereset can never be reliable. It's
77 * sometimes nice to wait there but it can't be depended upon;
78 * otherwise, we wouldn't be resetting. Just give it enough
79 * time for most drives to spin up.
80 */
81 ATA_EH_PRERESET_TIMEOUT = 10000,
82 ATA_EH_FASTDRAIN_INTERVAL = 3000,
Tejun Heo11fc33d2008-08-30 14:20:01 +020083
84 ATA_EH_UA_TRIES = 5,
Tejun Heoc2c7a892009-01-29 20:31:34 +090085
86 /* probe speed down parameters, see ata_eh_schedule_probe() */
87 ATA_EH_PROBE_TRIAL_INTERVAL = 60000, /* 1 min */
88 ATA_EH_PROBE_TRIALS = 2,
Tejun Heo31daabd2007-02-02 16:50:52 +090089};
90
91/* The following table determines how we sequence resets. Each entry
92 * represents timeout for that try. The first try can be soft or
93 * hardreset. All others are hardreset if available. In most cases
94 * the first reset w/ 10sec timeout should succeed. Following entries
95 * are mostly for error handling, hotplug and retarded devices.
96 */
97static const unsigned long ata_eh_reset_timeouts[] = {
Tejun Heo341c2c92008-05-20 02:17:51 +090098 10000, /* most drives spin up by 10sec */
99 10000, /* > 99% working drives spin up before 20sec */
100 35000, /* give > 30 secs of idleness for retarded devices */
101 5000, /* and sweet one last chance */
Tejun Heod8af0eb2008-05-20 02:17:53 +0900102 ULONG_MAX, /* > 1 min has elapsed, give up */
Tejun Heo31daabd2007-02-02 16:50:52 +0900103};
104
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900105static const unsigned long ata_eh_identify_timeouts[] = {
106 5000, /* covers > 99% of successes and not too boring on failures */
107 10000, /* combined time till here is enough even for media access */
108 30000, /* for true idiots */
109 ULONG_MAX,
110};
111
112static const unsigned long ata_eh_other_timeouts[] = {
113 5000, /* same rationale as identify timeout */
114 10000, /* ditto */
115 /* but no merciful 30sec for other commands, it just isn't worth it */
116 ULONG_MAX,
117};
118
119struct ata_eh_cmd_timeout_ent {
120 const u8 *commands;
121 const unsigned long *timeouts;
122};
123
124/* The following table determines timeouts to use for EH internal
125 * commands. Each table entry is a command class and matches the
126 * commands the entry applies to and the timeout table to use.
127 *
128 * On the retry after a command timed out, the next timeout value from
129 * the table is used. If the table doesn't contain further entries,
130 * the last value is used.
131 *
132 * ehc->cmd_timeout_idx keeps track of which timeout to use per
133 * command class, so if SET_FEATURES times out on the first try, the
134 * next try will use the second timeout value only for that class.
135 */
136#define CMDS(cmds...) (const u8 []){ cmds, 0 }
137static const struct ata_eh_cmd_timeout_ent
138ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = {
139 { .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI),
140 .timeouts = ata_eh_identify_timeouts, },
141 { .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT),
142 .timeouts = ata_eh_other_timeouts, },
143 { .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT),
144 .timeouts = ata_eh_other_timeouts, },
145 { .commands = CMDS(ATA_CMD_SET_FEATURES),
146 .timeouts = ata_eh_other_timeouts, },
147 { .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS),
148 .timeouts = ata_eh_other_timeouts, },
149};
150#undef CMDS
151
Tejun Heoad9e2762006-05-15 20:58:12 +0900152static void __ata_port_freeze(struct ata_port *ap);
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900153#ifdef CONFIG_PM
Tejun Heo500530f2006-07-03 16:07:27 +0900154static void ata_eh_handle_port_suspend(struct ata_port *ap);
155static void ata_eh_handle_port_resume(struct ata_port *ap);
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900156#else /* CONFIG_PM */
157static void ata_eh_handle_port_suspend(struct ata_port *ap)
158{ }
159
160static void ata_eh_handle_port_resume(struct ata_port *ap)
161{ }
Tejun Heo6ffa01d2007-03-02 17:32:47 +0900162#endif /* CONFIG_PM */
Tejun Heoad9e2762006-05-15 20:58:12 +0900163
Tejun Heob64bbc32007-07-16 14:29:39 +0900164static void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, const char *fmt,
165 va_list args)
166{
167 ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
168 ATA_EH_DESC_LEN - ehi->desc_len,
169 fmt, args);
170}
171
172/**
173 * __ata_ehi_push_desc - push error description without adding separator
174 * @ehi: target EHI
175 * @fmt: printf format string
176 *
177 * Format string according to @fmt and append it to @ehi->desc.
178 *
179 * LOCKING:
180 * spin_lock_irqsave(host lock)
181 */
182void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
183{
184 va_list args;
185
186 va_start(args, fmt);
187 __ata_ehi_pushv_desc(ehi, fmt, args);
188 va_end(args);
189}
190
191/**
192 * ata_ehi_push_desc - push error description with separator
193 * @ehi: target EHI
194 * @fmt: printf format string
195 *
196 * Format string according to @fmt and append it to @ehi->desc.
197 * If @ehi->desc is not empty, ", " is added in-between.
198 *
199 * LOCKING:
200 * spin_lock_irqsave(host lock)
201 */
202void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
203{
204 va_list args;
205
206 if (ehi->desc_len)
207 __ata_ehi_push_desc(ehi, ", ");
208
209 va_start(args, fmt);
210 __ata_ehi_pushv_desc(ehi, fmt, args);
211 va_end(args);
212}
213
214/**
215 * ata_ehi_clear_desc - clean error description
216 * @ehi: target EHI
217 *
218 * Clear @ehi->desc.
219 *
220 * LOCKING:
221 * spin_lock_irqsave(host lock)
222 */
223void ata_ehi_clear_desc(struct ata_eh_info *ehi)
224{
225 ehi->desc[0] = '\0';
226 ehi->desc_len = 0;
227}
228
Tejun Heocbcdd872007-08-18 13:14:55 +0900229/**
230 * ata_port_desc - append port description
231 * @ap: target ATA port
232 * @fmt: printf format string
233 *
234 * Format string according to @fmt and append it to port
235 * description. If port description is not empty, " " is added
236 * in-between. This function is to be used while initializing
237 * ata_host. The description is printed on host registration.
238 *
239 * LOCKING:
240 * None.
241 */
242void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
243{
244 va_list args;
245
246 WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
247
248 if (ap->link.eh_info.desc_len)
249 __ata_ehi_push_desc(&ap->link.eh_info, " ");
250
251 va_start(args, fmt);
252 __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
253 va_end(args);
254}
255
256#ifdef CONFIG_PCI
257
258/**
259 * ata_port_pbar_desc - append PCI BAR description
260 * @ap: target ATA port
261 * @bar: target PCI BAR
262 * @offset: offset into PCI BAR
263 * @name: name of the area
264 *
265 * If @offset is negative, this function formats a string which
266 * contains the name, address, size and type of the BAR and
267 * appends it to the port description. If @offset is zero or
268 * positive, only name and offsetted address is appended.
269 *
270 * LOCKING:
271 * None.
272 */
273void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
274 const char *name)
275{
276 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
277 char *type = "";
278 unsigned long long start, len;
279
280 if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
281 type = "m";
282 else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
283 type = "i";
284
285 start = (unsigned long long)pci_resource_start(pdev, bar);
286 len = (unsigned long long)pci_resource_len(pdev, bar);
287
288 if (offset < 0)
289 ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
290 else
Andrew Mortone6a73ab2007-12-13 16:01:37 -0800291 ata_port_desc(ap, "%s 0x%llx", name,
292 start + (unsigned long long)offset);
Tejun Heocbcdd872007-08-18 13:14:55 +0900293}
294
295#endif /* CONFIG_PCI */
296
Tejun Heo87fbc5a2008-05-20 02:17:54 +0900297static int ata_lookup_timeout_table(u8 cmd)
298{
299 int i;
300
301 for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) {
302 const u8 *cur;
303
304 for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++)
305 if (*cur == cmd)
306 return i;
307 }
308
309 return -1;
310}
311
312/**
313 * ata_internal_cmd_timeout - determine timeout for an internal command
314 * @dev: target device
315 * @cmd: internal command to be issued
316 *
317 * Determine timeout for internal command @cmd for @dev.
318 *
319 * LOCKING:
320 * EH context.
321 *
322 * RETURNS:
323 * Determined timeout.
324 */
325unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd)
326{
327 struct ata_eh_context *ehc = &dev->link->eh_context;
328 int ent = ata_lookup_timeout_table(cmd);
329 int idx;
330
331 if (ent < 0)
332 return ATA_EH_CMD_DFL_TIMEOUT;
333
334 idx = ehc->cmd_timeout_idx[dev->devno][ent];
335 return ata_eh_cmd_timeout_table[ent].timeouts[idx];
336}
337
338/**
339 * ata_internal_cmd_timed_out - notification for internal command timeout
340 * @dev: target device
341 * @cmd: internal command which timed out
342 *
343 * Notify EH that internal command @cmd for @dev timed out. This
344 * function should be called only for commands whose timeouts are
345 * determined using ata_internal_cmd_timeout().
346 *
347 * LOCKING:
348 * EH context.
349 */
350void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd)
351{
352 struct ata_eh_context *ehc = &dev->link->eh_context;
353 int ent = ata_lookup_timeout_table(cmd);
354 int idx;
355
356 if (ent < 0)
357 return;
358
359 idx = ehc->cmd_timeout_idx[dev->devno][ent];
360 if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX)
361 ehc->cmd_timeout_idx[dev->devno][ent]++;
362}
363
Tejun Heo3884f7b2007-11-27 19:28:56 +0900364static void ata_ering_record(struct ata_ering *ering, unsigned int eflags,
Tejun Heo0c247c52006-05-15 20:58:19 +0900365 unsigned int err_mask)
366{
367 struct ata_ering_entry *ent;
368
369 WARN_ON(!err_mask);
370
371 ering->cursor++;
372 ering->cursor %= ATA_ERING_SIZE;
373
374 ent = &ering->ring[ering->cursor];
Tejun Heo3884f7b2007-11-27 19:28:56 +0900375 ent->eflags = eflags;
Tejun Heo0c247c52006-05-15 20:58:19 +0900376 ent->err_mask = err_mask;
377 ent->timestamp = get_jiffies_64();
378}
379
Tejun Heo76326ac2007-11-27 19:28:59 +0900380static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
381{
382 struct ata_ering_entry *ent = &ering->ring[ering->cursor];
383
384 if (ent->err_mask)
385 return ent;
386 return NULL;
387}
388
Tejun Heo7d47e8d2007-02-02 16:22:31 +0900389static void ata_ering_clear(struct ata_ering *ering)
Tejun Heo0c247c52006-05-15 20:58:19 +0900390{
Tejun Heo7d47e8d2007-02-02 16:22:31 +0900391 memset(ering, 0, sizeof(*ering));
Tejun Heo0c247c52006-05-15 20:58:19 +0900392}
393
394static int ata_ering_map(struct ata_ering *ering,
395 int (*map_fn)(struct ata_ering_entry *, void *),
396 void *arg)
397{
398 int idx, rc = 0;
399 struct ata_ering_entry *ent;
400
401 idx = ering->cursor;
402 do {
403 ent = &ering->ring[idx];
404 if (!ent->err_mask)
405 break;
406 rc = map_fn(ent, arg);
407 if (rc)
408 break;
409 idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
410 } while (idx != ering->cursor);
411
412 return rc;
413}
414
Tejun Heo64f65ca2006-06-24 20:30:18 +0900415static unsigned int ata_eh_dev_action(struct ata_device *dev)
416{
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900417 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heo64f65ca2006-06-24 20:30:18 +0900418
419 return ehc->i.action | ehc->i.dev_action[dev->devno];
420}
421
Tejun Heof58229f2007-08-06 18:36:23 +0900422static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
Tejun Heoaf181c22006-06-24 20:30:18 +0900423 struct ata_eh_info *ehi, unsigned int action)
424{
Tejun Heof58229f2007-08-06 18:36:23 +0900425 struct ata_device *tdev;
Tejun Heoaf181c22006-06-24 20:30:18 +0900426
427 if (!dev) {
428 ehi->action &= ~action;
Tejun Heo1eca4362008-11-03 20:03:17 +0900429 ata_for_each_dev(tdev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +0900430 ehi->dev_action[tdev->devno] &= ~action;
Tejun Heoaf181c22006-06-24 20:30:18 +0900431 } else {
432 /* doesn't make sense for port-wide EH actions */
433 WARN_ON(!(action & ATA_EH_PERDEV_MASK));
434
435 /* break ehi->action into ehi->dev_action */
436 if (ehi->action & action) {
Tejun Heo1eca4362008-11-03 20:03:17 +0900437 ata_for_each_dev(tdev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +0900438 ehi->dev_action[tdev->devno] |=
439 ehi->action & action;
Tejun Heoaf181c22006-06-24 20:30:18 +0900440 ehi->action &= ~action;
441 }
442
443 /* turn off the specified per-dev action */
444 ehi->dev_action[dev->devno] &= ~action;
445 }
446}
447
Tejun Heoece1d632006-04-02 18:51:53 +0900448/**
449 * ata_scsi_timed_out - SCSI layer time out callback
450 * @cmd: timed out SCSI command
451 *
452 * Handles SCSI layer timeout. We race with normal completion of
453 * the qc for @cmd. If the qc is already gone, we lose and let
454 * the scsi command finish (EH_HANDLED). Otherwise, the qc has
455 * timed out and EH should be invoked. Prevent ata_qc_complete()
456 * from finishing it by setting EH_SCHEDULED and return
457 * EH_NOT_HANDLED.
458 *
Tejun Heoad9e2762006-05-15 20:58:12 +0900459 * TODO: kill this function once old EH is gone.
460 *
Tejun Heoece1d632006-04-02 18:51:53 +0900461 * LOCKING:
462 * Called from timer context
463 *
464 * RETURNS:
465 * EH_HANDLED or EH_NOT_HANDLED
466 */
Jens Axboe242f9dc2008-09-14 05:55:09 -0700467enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
Tejun Heoece1d632006-04-02 18:51:53 +0900468{
469 struct Scsi_Host *host = cmd->device->host;
Jeff Garzik35bb94b2006-04-11 13:12:34 -0400470 struct ata_port *ap = ata_shost_to_port(host);
Tejun Heoece1d632006-04-02 18:51:53 +0900471 unsigned long flags;
472 struct ata_queued_cmd *qc;
Jens Axboe242f9dc2008-09-14 05:55:09 -0700473 enum blk_eh_timer_return ret;
Tejun Heoece1d632006-04-02 18:51:53 +0900474
475 DPRINTK("ENTER\n");
476
Tejun Heoad9e2762006-05-15 20:58:12 +0900477 if (ap->ops->error_handler) {
Jens Axboe242f9dc2008-09-14 05:55:09 -0700478 ret = BLK_EH_NOT_HANDLED;
Tejun Heoad9e2762006-05-15 20:58:12 +0900479 goto out;
480 }
481
Jens Axboe242f9dc2008-09-14 05:55:09 -0700482 ret = BLK_EH_HANDLED;
Jeff Garzikba6a1302006-06-22 23:46:10 -0400483 spin_lock_irqsave(ap->lock, flags);
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900484 qc = ata_qc_from_tag(ap, ap->link.active_tag);
Tejun Heoece1d632006-04-02 18:51:53 +0900485 if (qc) {
486 WARN_ON(qc->scsicmd != cmd);
487 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
488 qc->err_mask |= AC_ERR_TIMEOUT;
Jens Axboe242f9dc2008-09-14 05:55:09 -0700489 ret = BLK_EH_NOT_HANDLED;
Tejun Heoece1d632006-04-02 18:51:53 +0900490 }
Jeff Garzikba6a1302006-06-22 23:46:10 -0400491 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +0900492
Tejun Heoad9e2762006-05-15 20:58:12 +0900493 out:
Tejun Heoece1d632006-04-02 18:51:53 +0900494 DPRINTK("EXIT, ret=%d\n", ret);
495 return ret;
496}
497
Tejun Heoece180d2008-11-03 20:04:37 +0900498static void ata_eh_unload(struct ata_port *ap)
499{
500 struct ata_link *link;
501 struct ata_device *dev;
502 unsigned long flags;
503
504 /* Restore SControl IPM and SPD for the next driver and
505 * disable attached devices.
506 */
507 ata_for_each_link(link, ap, PMP_FIRST) {
508 sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);
509 ata_for_each_dev(dev, link, ALL)
510 ata_dev_disable(dev);
511 }
512
513 /* freeze and set UNLOADED */
514 spin_lock_irqsave(ap->lock, flags);
515
516 ata_port_freeze(ap); /* won't be thawed */
517 ap->pflags &= ~ATA_PFLAG_EH_PENDING; /* clear pending from freeze */
518 ap->pflags |= ATA_PFLAG_UNLOADED;
519
520 spin_unlock_irqrestore(ap->lock, flags);
521}
522
Tejun Heoece1d632006-04-02 18:51:53 +0900523/**
524 * ata_scsi_error - SCSI layer error handler callback
525 * @host: SCSI host on which error occurred
526 *
527 * Handles SCSI-layer-thrown error events.
528 *
529 * LOCKING:
530 * Inherited from SCSI layer (none, can sleep)
531 *
532 * RETURNS:
533 * Zero.
534 */
Jeff Garzik381544b2006-04-11 13:04:39 -0400535void ata_scsi_error(struct Scsi_Host *host)
Tejun Heoece1d632006-04-02 18:51:53 +0900536{
Jeff Garzik35bb94b2006-04-11 13:12:34 -0400537 struct ata_port *ap = ata_shost_to_port(host);
Tejun Heoa1e10f72007-08-18 13:28:49 +0900538 int i;
Tejun Heoad9e2762006-05-15 20:58:12 +0900539 unsigned long flags;
Tejun Heoece1d632006-04-02 18:51:53 +0900540
541 DPRINTK("ENTER\n");
542
Tejun Heoad9e2762006-05-15 20:58:12 +0900543 /* synchronize with port task */
Tejun Heoece1d632006-04-02 18:51:53 +0900544 ata_port_flush_task(ap);
545
Jeff Garzikcca39742006-08-24 03:19:22 -0400546 /* synchronize with host lock and sort out timeouts */
Tejun Heoece1d632006-04-02 18:51:53 +0900547
Tejun Heoad9e2762006-05-15 20:58:12 +0900548 /* For new EH, all qcs are finished in one of three ways -
549 * normal completion, error completion, and SCSI timeout.
Alan Coxc96f1732009-03-24 10:23:46 +0000550 * Both completions can race against SCSI timeout. When normal
Tejun Heoad9e2762006-05-15 20:58:12 +0900551 * completion wins, the qc never reaches EH. When error
552 * completion wins, the qc has ATA_QCFLAG_FAILED set.
553 *
554 * When SCSI timeout wins, things are a bit more complex.
555 * Normal or error completion can occur after the timeout but
556 * before this point. In such cases, both types of
557 * completions are honored. A scmd is determined to have
558 * timed out iff its associated qc is active and not failed.
559 */
560 if (ap->ops->error_handler) {
561 struct scsi_cmnd *scmd, *tmp;
562 int nr_timedout = 0;
Tejun Heoece1d632006-04-02 18:51:53 +0900563
Tejun Heoe30349d2006-07-03 03:02:15 +0900564 spin_lock_irqsave(ap->lock, flags);
Alan Coxc96f1732009-03-24 10:23:46 +0000565
566 /* This must occur under the ap->lock as we don't want
567 a polled recovery to race the real interrupt handler
568
569 The lost_interrupt handler checks for any completed but
570 non-notified command and completes much like an IRQ handler.
571
572 We then fall into the error recovery code which will treat
573 this as if normal completion won the race */
Tejun Heoad9e2762006-05-15 20:58:12 +0900574
Alan Coxc96f1732009-03-24 10:23:46 +0000575 if (ap->ops->lost_interrupt)
576 ap->ops->lost_interrupt(ap);
577
Tejun Heoad9e2762006-05-15 20:58:12 +0900578 list_for_each_entry_safe(scmd, tmp, &host->eh_cmd_q, eh_entry) {
579 struct ata_queued_cmd *qc;
580
581 for (i = 0; i < ATA_MAX_QUEUE; i++) {
582 qc = __ata_qc_from_tag(ap, i);
583 if (qc->flags & ATA_QCFLAG_ACTIVE &&
584 qc->scsicmd == scmd)
585 break;
586 }
587
588 if (i < ATA_MAX_QUEUE) {
589 /* the scmd has an associated qc */
590 if (!(qc->flags & ATA_QCFLAG_FAILED)) {
591 /* which hasn't failed yet, timeout */
592 qc->err_mask |= AC_ERR_TIMEOUT;
593 qc->flags |= ATA_QCFLAG_FAILED;
594 nr_timedout++;
595 }
596 } else {
597 /* Normal completion occurred after
598 * SCSI timeout but before this point.
599 * Successfully complete it.
600 */
601 scmd->retries = scmd->allowed;
602 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
603 }
604 }
605
606 /* If we have timed out qcs. They belong to EH from
607 * this point but the state of the controller is
608 * unknown. Freeze the port to make sure the IRQ
609 * handler doesn't diddle with those qcs. This must
610 * be done atomically w.r.t. setting QCFLAG_FAILED.
611 */
612 if (nr_timedout)
613 __ata_port_freeze(ap);
614
Tejun Heoe30349d2006-07-03 03:02:15 +0900615 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoa1e10f72007-08-18 13:28:49 +0900616
617 /* initialize eh_tries */
618 ap->eh_tries = ATA_EH_MAX_TRIES;
Tejun Heoad9e2762006-05-15 20:58:12 +0900619 } else
Tejun Heoe30349d2006-07-03 03:02:15 +0900620 spin_unlock_wait(ap->lock);
Alan Coxc96f1732009-03-24 10:23:46 +0000621
622 /* If we timed raced normal completion and there is nothing to
623 recover nr_timedout == 0 why exactly are we doing error recovery ? */
Tejun Heoad9e2762006-05-15 20:58:12 +0900624
625 repeat:
626 /* invoke error handler */
627 if (ap->ops->error_handler) {
Tejun Heocf1b86c2007-08-06 18:36:23 +0900628 struct ata_link *link;
629
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900630 /* kill fast drain timer */
631 del_timer_sync(&ap->fastdrain_timer);
632
Tejun Heo500530f2006-07-03 16:07:27 +0900633 /* process port resume request */
634 ata_eh_handle_port_resume(ap);
635
Tejun Heof3e81b12006-05-15 20:58:21 +0900636 /* fetch & clear EH info */
Tejun Heoe30349d2006-07-03 03:02:15 +0900637 spin_lock_irqsave(ap->lock, flags);
Tejun Heof3e81b12006-05-15 20:58:21 +0900638
Tejun Heo1eca4362008-11-03 20:03:17 +0900639 ata_for_each_link(link, ap, HOST_FIRST) {
Tejun Heo00115e02007-11-27 19:28:58 +0900640 struct ata_eh_context *ehc = &link->eh_context;
641 struct ata_device *dev;
642
Tejun Heocf1b86c2007-08-06 18:36:23 +0900643 memset(&link->eh_context, 0, sizeof(link->eh_context));
644 link->eh_context.i = link->eh_info;
645 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heo00115e02007-11-27 19:28:58 +0900646
Tejun Heo1eca4362008-11-03 20:03:17 +0900647 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo00115e02007-11-27 19:28:58 +0900648 int devno = dev->devno;
649
650 ehc->saved_xfer_mode[devno] = dev->xfer_mode;
651 if (ata_ncq_enabled(dev))
652 ehc->saved_ncq_enabled |= 1 << devno;
653 }
Tejun Heocf1b86c2007-08-06 18:36:23 +0900654 }
Tejun Heof3e81b12006-05-15 20:58:21 +0900655
Tejun Heob51e9e52006-06-29 01:29:30 +0900656 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
657 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heoda917d62007-09-23 13:14:12 +0900658 ap->excl_link = NULL; /* don't maintain exclusion over EH */
Tejun Heof3e81b12006-05-15 20:58:21 +0900659
Tejun Heoe30349d2006-07-03 03:02:15 +0900660 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900661
Tejun Heo500530f2006-07-03 16:07:27 +0900662 /* invoke EH, skip if unloading or suspended */
663 if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
Tejun Heo720ba122006-05-31 18:28:13 +0900664 ap->ops->error_handler(ap);
Tejun Heoece180d2008-11-03 20:04:37 +0900665 else {
666 /* if unloading, commence suicide */
667 if ((ap->pflags & ATA_PFLAG_UNLOADING) &&
668 !(ap->pflags & ATA_PFLAG_UNLOADED))
669 ata_eh_unload(ap);
Tejun Heo720ba122006-05-31 18:28:13 +0900670 ata_eh_finish(ap);
Tejun Heoece180d2008-11-03 20:04:37 +0900671 }
Tejun Heoad9e2762006-05-15 20:58:12 +0900672
Tejun Heo500530f2006-07-03 16:07:27 +0900673 /* process port suspend request */
674 ata_eh_handle_port_suspend(ap);
675
Tejun Heoad9e2762006-05-15 20:58:12 +0900676 /* Exception might have happend after ->error_handler
677 * recovered the port but before this point. Repeat
678 * EH in such case.
679 */
Tejun Heoe30349d2006-07-03 03:02:15 +0900680 spin_lock_irqsave(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900681
Tejun Heob51e9e52006-06-29 01:29:30 +0900682 if (ap->pflags & ATA_PFLAG_EH_PENDING) {
Tejun Heoa1e10f72007-08-18 13:28:49 +0900683 if (--ap->eh_tries) {
Tejun Heoe30349d2006-07-03 03:02:15 +0900684 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900685 goto repeat;
686 }
687 ata_port_printk(ap, KERN_ERR, "EH pending after %d "
Tejun Heoa1e10f72007-08-18 13:28:49 +0900688 "tries, giving up\n", ATA_EH_MAX_TRIES);
Tejun Heo914616a2007-06-25 21:47:11 +0900689 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
Tejun Heoad9e2762006-05-15 20:58:12 +0900690 }
691
Tejun Heof3e81b12006-05-15 20:58:21 +0900692 /* this run is complete, make sure EH info is clear */
Tejun Heo1eca4362008-11-03 20:03:17 +0900693 ata_for_each_link(link, ap, HOST_FIRST)
Tejun Heocf1b86c2007-08-06 18:36:23 +0900694 memset(&link->eh_info, 0, sizeof(link->eh_info));
Tejun Heof3e81b12006-05-15 20:58:21 +0900695
Tejun Heoe30349d2006-07-03 03:02:15 +0900696 /* Clear host_eh_scheduled while holding ap->lock such
Tejun Heoad9e2762006-05-15 20:58:12 +0900697 * that if exception occurs after this point but
698 * before EH completion, SCSI midlayer will
699 * re-initiate EH.
700 */
701 host->host_eh_scheduled = 0;
702
Tejun Heoe30349d2006-07-03 03:02:15 +0900703 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900704 } else {
Tejun Heo9af5c9c2007-08-06 18:36:22 +0900705 WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
Tejun Heoad9e2762006-05-15 20:58:12 +0900706 ap->ops->eng_timeout(ap);
707 }
708
709 /* finish or retry handled scmd's and clean up */
Tejun Heoece1d632006-04-02 18:51:53 +0900710 WARN_ON(host->host_failed || !list_empty(&host->eh_cmd_q));
711
712 scsi_eh_flush_done_q(&ap->eh_done_q);
713
Tejun Heoad9e2762006-05-15 20:58:12 +0900714 /* clean up */
Tejun Heoe30349d2006-07-03 03:02:15 +0900715 spin_lock_irqsave(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900716
Tejun Heo1cdaf532006-07-03 16:07:26 +0900717 if (ap->pflags & ATA_PFLAG_LOADING)
Tejun Heob51e9e52006-06-29 01:29:30 +0900718 ap->pflags &= ~ATA_PFLAG_LOADING;
Tejun Heo1cdaf532006-07-03 16:07:26 +0900719 else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
David Howells52bad642006-11-22 14:54:01 +0000720 queue_delayed_work(ata_aux_wq, &ap->hotplug_task, 0);
Tejun Heo1cdaf532006-07-03 16:07:26 +0900721
722 if (ap->pflags & ATA_PFLAG_RECOVERED)
723 ata_port_printk(ap, KERN_INFO, "EH complete\n");
Tejun Heo580b21022006-05-31 18:28:05 +0900724
Tejun Heob51e9e52006-06-29 01:29:30 +0900725 ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
Tejun Heoad9e2762006-05-15 20:58:12 +0900726
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900727 /* tell wait_eh that we're done */
Tejun Heob51e9e52006-06-29 01:29:30 +0900728 ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900729 wake_up_all(&ap->eh_wait_q);
730
Tejun Heoe30349d2006-07-03 03:02:15 +0900731 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoad9e2762006-05-15 20:58:12 +0900732
Tejun Heoece1d632006-04-02 18:51:53 +0900733 DPRINTK("EXIT\n");
Tejun Heoece1d632006-04-02 18:51:53 +0900734}
735
736/**
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900737 * ata_port_wait_eh - Wait for the currently pending EH to complete
738 * @ap: Port to wait EH for
739 *
740 * Wait until the currently pending EH is complete.
741 *
742 * LOCKING:
743 * Kernel thread context (may sleep).
744 */
745void ata_port_wait_eh(struct ata_port *ap)
746{
747 unsigned long flags;
748 DEFINE_WAIT(wait);
749
750 retry:
Jeff Garzikba6a1302006-06-22 23:46:10 -0400751 spin_lock_irqsave(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900752
Tejun Heob51e9e52006-06-29 01:29:30 +0900753 while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900754 prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
Jeff Garzikba6a1302006-06-22 23:46:10 -0400755 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900756 schedule();
Jeff Garzikba6a1302006-06-22 23:46:10 -0400757 spin_lock_irqsave(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900758 }
Tejun Heo0a1b6222006-06-11 11:01:38 +0900759 finish_wait(&ap->eh_wait_q, &wait);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900760
Jeff Garzikba6a1302006-06-22 23:46:10 -0400761 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900762
763 /* make sure SCSI EH is complete */
Jeff Garzikcca39742006-08-24 03:19:22 -0400764 if (scsi_host_in_recovery(ap->scsi_host)) {
Tejun Heoc6cf9e92006-05-31 18:27:27 +0900765 msleep(10);
766 goto retry;
767 }
768}
769
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900770static int ata_eh_nr_in_flight(struct ata_port *ap)
771{
772 unsigned int tag;
773 int nr = 0;
774
775 /* count only non-internal commands */
776 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
777 if (ata_qc_from_tag(ap, tag))
778 nr++;
779
780 return nr;
781}
782
783void ata_eh_fastdrain_timerfn(unsigned long arg)
784{
785 struct ata_port *ap = (void *)arg;
786 unsigned long flags;
787 int cnt;
788
789 spin_lock_irqsave(ap->lock, flags);
790
791 cnt = ata_eh_nr_in_flight(ap);
792
793 /* are we done? */
794 if (!cnt)
795 goto out_unlock;
796
797 if (cnt == ap->fastdrain_cnt) {
798 unsigned int tag;
799
800 /* No progress during the last interval, tag all
801 * in-flight qcs as timed out and freeze the port.
802 */
803 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
804 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
805 if (qc)
806 qc->err_mask |= AC_ERR_TIMEOUT;
807 }
808
809 ata_port_freeze(ap);
810 } else {
811 /* some qcs have finished, give it another chance */
812 ap->fastdrain_cnt = cnt;
813 ap->fastdrain_timer.expires =
Tejun Heo341c2c92008-05-20 02:17:51 +0900814 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900815 add_timer(&ap->fastdrain_timer);
816 }
817
818 out_unlock:
819 spin_unlock_irqrestore(ap->lock, flags);
820}
821
822/**
823 * ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain
824 * @ap: target ATA port
825 * @fastdrain: activate fast drain
826 *
827 * Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain
828 * is non-zero and EH wasn't pending before. Fast drain ensures
829 * that EH kicks in in timely manner.
830 *
831 * LOCKING:
832 * spin_lock_irqsave(host lock)
833 */
834static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
835{
836 int cnt;
837
838 /* already scheduled? */
839 if (ap->pflags & ATA_PFLAG_EH_PENDING)
840 return;
841
842 ap->pflags |= ATA_PFLAG_EH_PENDING;
843
844 if (!fastdrain)
845 return;
846
847 /* do we have in-flight qcs? */
848 cnt = ata_eh_nr_in_flight(ap);
849 if (!cnt)
850 return;
851
852 /* activate fast drain */
853 ap->fastdrain_cnt = cnt;
Tejun Heo341c2c92008-05-20 02:17:51 +0900854 ap->fastdrain_timer.expires =
855 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900856 add_timer(&ap->fastdrain_timer);
857}
858
Tejun Heof686bcb2006-05-15 20:58:05 +0900859/**
860 * ata_qc_schedule_eh - schedule qc for error handling
861 * @qc: command to schedule error handling for
862 *
863 * Schedule error handling for @qc. EH will kick in as soon as
864 * other commands are drained.
865 *
866 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400867 * spin_lock_irqsave(host lock)
Tejun Heof686bcb2006-05-15 20:58:05 +0900868 */
869void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
870{
871 struct ata_port *ap = qc->ap;
872
873 WARN_ON(!ap->ops->error_handler);
874
875 qc->flags |= ATA_QCFLAG_FAILED;
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900876 ata_eh_set_pending(ap, 1);
Tejun Heof686bcb2006-05-15 20:58:05 +0900877
878 /* The following will fail if timeout has already expired.
879 * ata_scsi_error() takes care of such scmds on EH entry.
880 * Note that ATA_QCFLAG_FAILED is unconditionally set after
881 * this function completes.
882 */
Jens Axboe242f9dc2008-09-14 05:55:09 -0700883 blk_abort_request(qc->scsicmd->request);
Tejun Heof686bcb2006-05-15 20:58:05 +0900884}
885
Tejun Heo7b70fc02006-05-15 20:58:07 +0900886/**
887 * ata_port_schedule_eh - schedule error handling without a qc
888 * @ap: ATA port to schedule EH for
889 *
890 * Schedule error handling for @ap. EH will kick in as soon as
891 * all commands are drained.
892 *
893 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400894 * spin_lock_irqsave(host lock)
Tejun Heo7b70fc02006-05-15 20:58:07 +0900895 */
896void ata_port_schedule_eh(struct ata_port *ap)
897{
898 WARN_ON(!ap->ops->error_handler);
899
Tejun Heof4d6d002007-05-01 11:50:15 +0200900 if (ap->pflags & ATA_PFLAG_INITIALIZING)
901 return;
902
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900903 ata_eh_set_pending(ap, 1);
Jeff Garzikcca39742006-08-24 03:19:22 -0400904 scsi_schedule_eh(ap->scsi_host);
Tejun Heo7b70fc02006-05-15 20:58:07 +0900905
906 DPRINTK("port EH scheduled\n");
907}
908
Tejun Heodbd82612007-08-06 18:36:23 +0900909static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
Tejun Heo7b70fc02006-05-15 20:58:07 +0900910{
911 int tag, nr_aborted = 0;
912
913 WARN_ON(!ap->ops->error_handler);
914
Tejun Heo5ddf24c2007-07-16 14:29:41 +0900915 /* we're gonna abort all commands, no need for fast drain */
916 ata_eh_set_pending(ap, 0);
917
Tejun Heo7b70fc02006-05-15 20:58:07 +0900918 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
919 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
920
Tejun Heodbd82612007-08-06 18:36:23 +0900921 if (qc && (!link || qc->dev->link == link)) {
Tejun Heo7b70fc02006-05-15 20:58:07 +0900922 qc->flags |= ATA_QCFLAG_FAILED;
923 ata_qc_complete(qc);
924 nr_aborted++;
925 }
926 }
927
928 if (!nr_aborted)
929 ata_port_schedule_eh(ap);
930
931 return nr_aborted;
932}
933
Tejun Heoe3180492006-05-15 20:58:09 +0900934/**
Tejun Heodbd82612007-08-06 18:36:23 +0900935 * ata_link_abort - abort all qc's on the link
936 * @link: ATA link to abort qc's for
937 *
938 * Abort all active qc's active on @link and schedule EH.
939 *
940 * LOCKING:
941 * spin_lock_irqsave(host lock)
942 *
943 * RETURNS:
944 * Number of aborted qc's.
945 */
946int ata_link_abort(struct ata_link *link)
947{
948 return ata_do_link_abort(link->ap, link);
949}
950
951/**
952 * ata_port_abort - abort all qc's on the port
953 * @ap: ATA port to abort qc's for
954 *
955 * Abort all active qc's of @ap and schedule EH.
956 *
957 * LOCKING:
958 * spin_lock_irqsave(host_set lock)
959 *
960 * RETURNS:
961 * Number of aborted qc's.
962 */
963int ata_port_abort(struct ata_port *ap)
964{
965 return ata_do_link_abort(ap, NULL);
966}
967
968/**
Tejun Heoe3180492006-05-15 20:58:09 +0900969 * __ata_port_freeze - freeze port
970 * @ap: ATA port to freeze
971 *
972 * This function is called when HSM violation or some other
973 * condition disrupts normal operation of the port. Frozen port
974 * is not allowed to perform any operation until the port is
975 * thawed, which usually follows a successful reset.
976 *
977 * ap->ops->freeze() callback can be used for freezing the port
978 * hardware-wise (e.g. mask interrupt and stop DMA engine). If a
979 * port cannot be frozen hardware-wise, the interrupt handler
980 * must ack and clear interrupts unconditionally while the port
981 * is frozen.
982 *
983 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -0400984 * spin_lock_irqsave(host lock)
Tejun Heoe3180492006-05-15 20:58:09 +0900985 */
986static void __ata_port_freeze(struct ata_port *ap)
987{
988 WARN_ON(!ap->ops->error_handler);
989
990 if (ap->ops->freeze)
991 ap->ops->freeze(ap);
992
Tejun Heob51e9e52006-06-29 01:29:30 +0900993 ap->pflags |= ATA_PFLAG_FROZEN;
Tejun Heoe3180492006-05-15 20:58:09 +0900994
Tejun Heo44877b42007-02-21 01:06:51 +0900995 DPRINTK("ata%u port frozen\n", ap->print_id);
Tejun Heoe3180492006-05-15 20:58:09 +0900996}
997
998/**
999 * ata_port_freeze - abort & freeze port
1000 * @ap: ATA port to freeze
1001 *
1002 * Abort and freeze @ap.
1003 *
1004 * LOCKING:
Jeff Garzikcca39742006-08-24 03:19:22 -04001005 * spin_lock_irqsave(host lock)
Tejun Heoe3180492006-05-15 20:58:09 +09001006 *
1007 * RETURNS:
1008 * Number of aborted commands.
1009 */
1010int ata_port_freeze(struct ata_port *ap)
1011{
1012 int nr_aborted;
1013
1014 WARN_ON(!ap->ops->error_handler);
1015
1016 nr_aborted = ata_port_abort(ap);
1017 __ata_port_freeze(ap);
1018
1019 return nr_aborted;
1020}
1021
1022/**
Tejun Heo7d77b242007-09-23 13:14:13 +09001023 * sata_async_notification - SATA async notification handler
1024 * @ap: ATA port where async notification is received
1025 *
1026 * Handler to be called when async notification via SDB FIS is
1027 * received. This function schedules EH if necessary.
1028 *
1029 * LOCKING:
1030 * spin_lock_irqsave(host lock)
1031 *
1032 * RETURNS:
1033 * 1 if EH is scheduled, 0 otherwise.
1034 */
1035int sata_async_notification(struct ata_port *ap)
1036{
1037 u32 sntf;
1038 int rc;
1039
1040 if (!(ap->flags & ATA_FLAG_AN))
1041 return 0;
1042
1043 rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1044 if (rc == 0)
1045 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1046
Tejun Heo071f44b2008-04-07 22:47:22 +09001047 if (!sata_pmp_attached(ap) || rc) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001048 /* PMP is not attached or SNTF is not available */
Tejun Heo071f44b2008-04-07 22:47:22 +09001049 if (!sata_pmp_attached(ap)) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001050 /* PMP is not attached. Check whether ATAPI
1051 * AN is configured. If so, notify media
1052 * change.
1053 */
1054 struct ata_device *dev = ap->link.device;
1055
1056 if ((dev->class == ATA_DEV_ATAPI) &&
1057 (dev->flags & ATA_DFLAG_AN))
1058 ata_scsi_media_change_notify(dev);
1059 return 0;
1060 } else {
1061 /* PMP is attached but SNTF is not available.
1062 * ATAPI async media change notification is
1063 * not used. The PMP must be reporting PHY
1064 * status change, schedule EH.
1065 */
1066 ata_port_schedule_eh(ap);
1067 return 1;
1068 }
1069 } else {
1070 /* PMP is attached and SNTF is available */
1071 struct ata_link *link;
1072
1073 /* check and notify ATAPI AN */
Tejun Heo1eca4362008-11-03 20:03:17 +09001074 ata_for_each_link(link, ap, EDGE) {
Tejun Heo7d77b242007-09-23 13:14:13 +09001075 if (!(sntf & (1 << link->pmp)))
1076 continue;
1077
1078 if ((link->device->class == ATA_DEV_ATAPI) &&
1079 (link->device->flags & ATA_DFLAG_AN))
1080 ata_scsi_media_change_notify(link->device);
1081 }
1082
1083 /* If PMP is reporting that PHY status of some
1084 * downstream ports has changed, schedule EH.
1085 */
1086 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
1087 ata_port_schedule_eh(ap);
1088 return 1;
1089 }
1090
1091 return 0;
1092 }
1093}
1094
1095/**
Tejun Heoe3180492006-05-15 20:58:09 +09001096 * ata_eh_freeze_port - EH helper to freeze port
1097 * @ap: ATA port to freeze
1098 *
1099 * Freeze @ap.
1100 *
1101 * LOCKING:
1102 * None.
1103 */
1104void ata_eh_freeze_port(struct ata_port *ap)
1105{
1106 unsigned long flags;
1107
1108 if (!ap->ops->error_handler)
1109 return;
1110
Jeff Garzikba6a1302006-06-22 23:46:10 -04001111 spin_lock_irqsave(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001112 __ata_port_freeze(ap);
Jeff Garzikba6a1302006-06-22 23:46:10 -04001113 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001114}
1115
1116/**
1117 * ata_port_thaw_port - EH helper to thaw port
1118 * @ap: ATA port to thaw
1119 *
1120 * Thaw frozen port @ap.
1121 *
1122 * LOCKING:
1123 * None.
1124 */
1125void ata_eh_thaw_port(struct ata_port *ap)
1126{
1127 unsigned long flags;
1128
1129 if (!ap->ops->error_handler)
1130 return;
1131
Jeff Garzikba6a1302006-06-22 23:46:10 -04001132 spin_lock_irqsave(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001133
Tejun Heob51e9e52006-06-29 01:29:30 +09001134 ap->pflags &= ~ATA_PFLAG_FROZEN;
Tejun Heoe3180492006-05-15 20:58:09 +09001135
1136 if (ap->ops->thaw)
1137 ap->ops->thaw(ap);
1138
Jeff Garzikba6a1302006-06-22 23:46:10 -04001139 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoe3180492006-05-15 20:58:09 +09001140
Tejun Heo44877b42007-02-21 01:06:51 +09001141 DPRINTK("ata%u port thawed\n", ap->print_id);
Tejun Heoe3180492006-05-15 20:58:09 +09001142}
1143
Tejun Heoece1d632006-04-02 18:51:53 +09001144static void ata_eh_scsidone(struct scsi_cmnd *scmd)
1145{
1146 /* nada */
1147}
1148
1149static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
1150{
1151 struct ata_port *ap = qc->ap;
1152 struct scsi_cmnd *scmd = qc->scsicmd;
1153 unsigned long flags;
1154
Jeff Garzikba6a1302006-06-22 23:46:10 -04001155 spin_lock_irqsave(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +09001156 qc->scsidone = ata_eh_scsidone;
1157 __ata_qc_complete(qc);
1158 WARN_ON(ata_tag_valid(qc->tag));
Jeff Garzikba6a1302006-06-22 23:46:10 -04001159 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heoece1d632006-04-02 18:51:53 +09001160
1161 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
1162}
1163
1164/**
1165 * ata_eh_qc_complete - Complete an active ATA command from EH
1166 * @qc: Command to complete
1167 *
1168 * Indicate to the mid and upper layers that an ATA command has
1169 * completed. To be used from EH.
1170 */
1171void ata_eh_qc_complete(struct ata_queued_cmd *qc)
1172{
1173 struct scsi_cmnd *scmd = qc->scsicmd;
1174 scmd->retries = scmd->allowed;
1175 __ata_eh_qc_complete(qc);
1176}
1177
1178/**
1179 * ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
1180 * @qc: Command to retry
1181 *
1182 * Indicate to the mid and upper layers that an ATA command
1183 * should be retried. To be used from EH.
1184 *
1185 * SCSI midlayer limits the number of retries to scmd->allowed.
1186 * scmd->retries is decremented for commands which get retried
1187 * due to unrelated failures (qc->err_mask is zero).
1188 */
1189void ata_eh_qc_retry(struct ata_queued_cmd *qc)
1190{
1191 struct scsi_cmnd *scmd = qc->scsicmd;
1192 if (!qc->err_mask && scmd->retries)
1193 scmd->retries--;
1194 __ata_eh_qc_complete(qc);
1195}
Tejun Heo022bdb02006-05-15 20:58:22 +09001196
1197/**
Tejun Heo678afac2009-01-29 20:31:30 +09001198 * ata_dev_disable - disable ATA device
1199 * @dev: ATA device to disable
1200 *
1201 * Disable @dev.
1202 *
1203 * Locking:
1204 * EH context.
1205 */
1206void ata_dev_disable(struct ata_device *dev)
1207{
1208 if (!ata_dev_enabled(dev))
1209 return;
1210
1211 if (ata_msg_drv(dev->link->ap))
1212 ata_dev_printk(dev, KERN_WARNING, "disabled\n");
1213 ata_acpi_on_disable(dev);
1214 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET);
1215 dev->class++;
Tejun Heo99cf6102009-01-29 20:31:32 +09001216
1217 /* From now till the next successful probe, ering is used to
1218 * track probe failures. Clear accumulated device error info.
1219 */
1220 ata_ering_clear(&dev->ering);
Tejun Heo678afac2009-01-29 20:31:30 +09001221}
1222
1223/**
Tejun Heo0ea035a2006-05-31 18:28:01 +09001224 * ata_eh_detach_dev - detach ATA device
1225 * @dev: ATA device to detach
1226 *
1227 * Detach @dev.
1228 *
1229 * LOCKING:
1230 * None.
1231 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001232void ata_eh_detach_dev(struct ata_device *dev)
Tejun Heo0ea035a2006-05-31 18:28:01 +09001233{
Tejun Heof58229f2007-08-06 18:36:23 +09001234 struct ata_link *link = dev->link;
1235 struct ata_port *ap = link->ap;
Tejun Heo90484eb2008-10-26 15:43:03 +09001236 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo0ea035a2006-05-31 18:28:01 +09001237 unsigned long flags;
1238
1239 ata_dev_disable(dev);
1240
Jeff Garzikba6a1302006-06-22 23:46:10 -04001241 spin_lock_irqsave(ap->lock, flags);
Tejun Heo0ea035a2006-05-31 18:28:01 +09001242
1243 dev->flags &= ~ATA_DFLAG_DETACH;
1244
1245 if (ata_scsi_offline_dev(dev)) {
1246 dev->flags |= ATA_DFLAG_DETACHED;
Tejun Heob51e9e52006-06-29 01:29:30 +09001247 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
Tejun Heo0ea035a2006-05-31 18:28:01 +09001248 }
1249
Tejun Heo90484eb2008-10-26 15:43:03 +09001250 /* clear per-dev EH info */
Tejun Heof58229f2007-08-06 18:36:23 +09001251 ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
1252 ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
Tejun Heo90484eb2008-10-26 15:43:03 +09001253 ehc->saved_xfer_mode[dev->devno] = 0;
1254 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
Tejun Heobeb07c12006-06-24 20:30:19 +09001255
Jeff Garzikba6a1302006-06-22 23:46:10 -04001256 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo0ea035a2006-05-31 18:28:01 +09001257}
1258
1259/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001260 * ata_eh_about_to_do - about to perform eh_action
Tejun Heo955e57d2007-08-06 18:36:23 +09001261 * @link: target ATA link
Tejun Heo47005f22006-06-19 18:27:23 +09001262 * @dev: target ATA dev for per-dev action (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09001263 * @action: action about to be performed
1264 *
1265 * Called just before performing EH actions to clear related bits
Tejun Heo955e57d2007-08-06 18:36:23 +09001266 * in @link->eh_info such that eh actions are not unnecessarily
1267 * repeated.
Tejun Heo022bdb02006-05-15 20:58:22 +09001268 *
1269 * LOCKING:
1270 * None.
1271 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001272void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
1273 unsigned int action)
Tejun Heo022bdb02006-05-15 20:58:22 +09001274{
Tejun Heo955e57d2007-08-06 18:36:23 +09001275 struct ata_port *ap = link->ap;
1276 struct ata_eh_info *ehi = &link->eh_info;
1277 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09001278 unsigned long flags;
1279
Jeff Garzikba6a1302006-06-22 23:46:10 -04001280 spin_lock_irqsave(ap->lock, flags);
Tejun Heo1cdaf532006-07-03 16:07:26 +09001281
Tejun Heo955e57d2007-08-06 18:36:23 +09001282 ata_eh_clear_action(link, dev, ehi, action);
Tejun Heo13abf502006-07-10 23:18:46 +09001283
Tejun Heoa568d1d2008-10-21 20:37:21 +09001284 /* About to take EH action, set RECOVERED. Ignore actions on
1285 * slave links as master will do them again.
1286 */
1287 if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link)
Tejun Heo1cdaf532006-07-03 16:07:26 +09001288 ap->pflags |= ATA_PFLAG_RECOVERED;
1289
Jeff Garzikba6a1302006-06-22 23:46:10 -04001290 spin_unlock_irqrestore(ap->lock, flags);
Tejun Heo022bdb02006-05-15 20:58:22 +09001291}
1292
1293/**
Tejun Heo47005f22006-06-19 18:27:23 +09001294 * ata_eh_done - EH action complete
Tejun Heo955e57d2007-08-06 18:36:23 +09001295* @ap: target ATA port
Tejun Heo47005f22006-06-19 18:27:23 +09001296 * @dev: target ATA dev for per-dev action (can be NULL)
1297 * @action: action just completed
1298 *
1299 * Called right after performing EH actions to clear related bits
Tejun Heo955e57d2007-08-06 18:36:23 +09001300 * in @link->eh_context.
Tejun Heo47005f22006-06-19 18:27:23 +09001301 *
1302 * LOCKING:
1303 * None.
1304 */
Tejun Heofb7fd612007-09-23 13:14:12 +09001305void ata_eh_done(struct ata_link *link, struct ata_device *dev,
1306 unsigned int action)
Tejun Heo47005f22006-06-19 18:27:23 +09001307{
Tejun Heo955e57d2007-08-06 18:36:23 +09001308 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001309
Tejun Heo955e57d2007-08-06 18:36:23 +09001310 ata_eh_clear_action(link, dev, &ehc->i, action);
Tejun Heo47005f22006-06-19 18:27:23 +09001311}
1312
1313/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001314 * ata_err_string - convert err_mask to descriptive string
1315 * @err_mask: error mask to convert to string
1316 *
1317 * Convert @err_mask to descriptive string. Errors are
1318 * prioritized according to severity and only the most severe
1319 * error is reported.
1320 *
1321 * LOCKING:
1322 * None.
1323 *
1324 * RETURNS:
1325 * Descriptive string for @err_mask
1326 */
Jeff Garzik2dcb4072007-10-19 06:42:56 -04001327static const char *ata_err_string(unsigned int err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09001328{
1329 if (err_mask & AC_ERR_HOST_BUS)
1330 return "host bus error";
1331 if (err_mask & AC_ERR_ATA_BUS)
1332 return "ATA bus error";
1333 if (err_mask & AC_ERR_TIMEOUT)
1334 return "timeout";
1335 if (err_mask & AC_ERR_HSM)
1336 return "HSM violation";
1337 if (err_mask & AC_ERR_SYSTEM)
1338 return "internal error";
1339 if (err_mask & AC_ERR_MEDIA)
1340 return "media error";
1341 if (err_mask & AC_ERR_INVALID)
1342 return "invalid argument";
1343 if (err_mask & AC_ERR_DEV)
1344 return "device error";
1345 return "unknown error";
1346}
1347
1348/**
Tejun Heoe8ee8452006-05-15 21:03:46 +09001349 * ata_read_log_page - read a specific log page
1350 * @dev: target device
1351 * @page: page to read
1352 * @buf: buffer to store read page
1353 * @sectors: number of sectors to read
1354 *
1355 * Read log page using READ_LOG_EXT command.
1356 *
1357 * LOCKING:
1358 * Kernel thread context (may sleep).
1359 *
1360 * RETURNS:
1361 * 0 on success, AC_ERR_* mask otherwise.
1362 */
1363static unsigned int ata_read_log_page(struct ata_device *dev,
1364 u8 page, void *buf, unsigned int sectors)
1365{
1366 struct ata_taskfile tf;
1367 unsigned int err_mask;
1368
1369 DPRINTK("read log page - page %d\n", page);
1370
1371 ata_tf_init(dev, &tf);
1372 tf.command = ATA_CMD_READ_LOG_EXT;
1373 tf.lbal = page;
1374 tf.nsect = sectors;
1375 tf.hob_nsect = sectors >> 8;
1376 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
1377 tf.protocol = ATA_PROT_PIO;
1378
1379 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
Tejun Heo2b789102007-10-09 15:05:44 +09001380 buf, sectors * ATA_SECT_SIZE, 0);
Tejun Heoe8ee8452006-05-15 21:03:46 +09001381
1382 DPRINTK("EXIT, err_mask=%x\n", err_mask);
1383 return err_mask;
1384}
1385
1386/**
1387 * ata_eh_read_log_10h - Read log page 10h for NCQ error details
1388 * @dev: Device to read log page 10h from
1389 * @tag: Resulting tag of the failed command
1390 * @tf: Resulting taskfile registers of the failed command
1391 *
1392 * Read log page 10h to obtain NCQ error details and clear error
1393 * condition.
1394 *
1395 * LOCKING:
1396 * Kernel thread context (may sleep).
1397 *
1398 * RETURNS:
1399 * 0 on success, -errno otherwise.
1400 */
1401static int ata_eh_read_log_10h(struct ata_device *dev,
1402 int *tag, struct ata_taskfile *tf)
1403{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001404 u8 *buf = dev->link->ap->sector_buf;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001405 unsigned int err_mask;
1406 u8 csum;
1407 int i;
1408
1409 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1);
1410 if (err_mask)
1411 return -EIO;
1412
1413 csum = 0;
1414 for (i = 0; i < ATA_SECT_SIZE; i++)
1415 csum += buf[i];
1416 if (csum)
1417 ata_dev_printk(dev, KERN_WARNING,
1418 "invalid checksum 0x%x on log page 10h\n", csum);
1419
1420 if (buf[0] & 0x80)
1421 return -ENOENT;
1422
1423 *tag = buf[0] & 0x1f;
1424
1425 tf->command = buf[2];
1426 tf->feature = buf[3];
1427 tf->lbal = buf[4];
1428 tf->lbam = buf[5];
1429 tf->lbah = buf[6];
1430 tf->device = buf[7];
1431 tf->hob_lbal = buf[8];
1432 tf->hob_lbam = buf[9];
1433 tf->hob_lbah = buf[10];
1434 tf->nsect = buf[12];
1435 tf->hob_nsect = buf[13];
1436
1437 return 0;
1438}
1439
1440/**
Tejun Heo11fc33d2008-08-30 14:20:01 +02001441 * atapi_eh_tur - perform ATAPI TEST_UNIT_READY
1442 * @dev: target ATAPI device
1443 * @r_sense_key: out parameter for sense_key
1444 *
1445 * Perform ATAPI TEST_UNIT_READY.
1446 *
1447 * LOCKING:
1448 * EH context (may sleep).
1449 *
1450 * RETURNS:
1451 * 0 on success, AC_ERR_* mask on failure.
1452 */
1453static unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
1454{
1455 u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 };
1456 struct ata_taskfile tf;
1457 unsigned int err_mask;
1458
1459 ata_tf_init(dev, &tf);
1460
1461 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1462 tf.command = ATA_CMD_PACKET;
1463 tf.protocol = ATAPI_PROT_NODATA;
1464
1465 err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
1466 if (err_mask == AC_ERR_DEV)
1467 *r_sense_key = tf.feature >> 4;
1468 return err_mask;
1469}
1470
1471/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001472 * atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
1473 * @dev: device to perform REQUEST_SENSE to
1474 * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
Tejun Heo3eabddb2008-06-10 18:28:05 +09001475 * @dfl_sense_key: default sense key to use
Tejun Heo022bdb02006-05-15 20:58:22 +09001476 *
1477 * Perform ATAPI REQUEST_SENSE after the device reported CHECK
1478 * SENSE. This function is EH helper.
1479 *
1480 * LOCKING:
1481 * Kernel thread context (may sleep).
1482 *
1483 * RETURNS:
1484 * 0 on success, AC_ERR_* mask on failure
1485 */
Tejun Heo3eabddb2008-06-10 18:28:05 +09001486static unsigned int atapi_eh_request_sense(struct ata_device *dev,
1487 u8 *sense_buf, u8 dfl_sense_key)
Tejun Heo022bdb02006-05-15 20:58:22 +09001488{
Tejun Heo3eabddb2008-06-10 18:28:05 +09001489 u8 cdb[ATAPI_CDB_LEN] =
1490 { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 };
Tejun Heo9af5c9c2007-08-06 18:36:22 +09001491 struct ata_port *ap = dev->link->ap;
Tejun Heo022bdb02006-05-15 20:58:22 +09001492 struct ata_taskfile tf;
Tejun Heo022bdb02006-05-15 20:58:22 +09001493
1494 DPRINTK("ATAPI request sense\n");
1495
Tejun Heo022bdb02006-05-15 20:58:22 +09001496 /* FIXME: is this needed? */
1497 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
1498
Albert Lee56287762007-04-02 11:30:46 +08001499 /* initialize sense_buf with the error register,
1500 * for the case where they are -not- overwritten
1501 */
Tejun Heo022bdb02006-05-15 20:58:22 +09001502 sense_buf[0] = 0x70;
Tejun Heo3eabddb2008-06-10 18:28:05 +09001503 sense_buf[2] = dfl_sense_key;
Albert Lee56287762007-04-02 11:30:46 +08001504
Jeff Garzika617c092007-05-21 20:14:23 -04001505 /* some devices time out if garbage left in tf */
Albert Lee56287762007-04-02 11:30:46 +08001506 ata_tf_init(dev, &tf);
Tejun Heo022bdb02006-05-15 20:58:22 +09001507
Tejun Heo022bdb02006-05-15 20:58:22 +09001508 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1509 tf.command = ATA_CMD_PACKET;
1510
1511 /* is it pointless to prefer PIO for "safety reasons"? */
1512 if (ap->flags & ATA_FLAG_PIO_DMA) {
Tejun Heo0dc36882007-12-18 16:34:43 -05001513 tf.protocol = ATAPI_PROT_DMA;
Tejun Heo022bdb02006-05-15 20:58:22 +09001514 tf.feature |= ATAPI_PKT_DMA;
1515 } else {
Tejun Heo0dc36882007-12-18 16:34:43 -05001516 tf.protocol = ATAPI_PROT_PIO;
Tejun Heof2dfc1a2007-12-12 12:12:46 +09001517 tf.lbam = SCSI_SENSE_BUFFERSIZE;
1518 tf.lbah = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09001519 }
1520
1521 return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
Tejun Heo2b789102007-10-09 15:05:44 +09001522 sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
Tejun Heo022bdb02006-05-15 20:58:22 +09001523}
1524
1525/**
1526 * ata_eh_analyze_serror - analyze SError for a failed port
Tejun Heo02607312007-08-06 18:36:23 +09001527 * @link: ATA link to analyze SError for
Tejun Heo022bdb02006-05-15 20:58:22 +09001528 *
1529 * Analyze SError if available and further determine cause of
1530 * failure.
1531 *
1532 * LOCKING:
1533 * None.
1534 */
Tejun Heo02607312007-08-06 18:36:23 +09001535static void ata_eh_analyze_serror(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09001536{
Tejun Heo02607312007-08-06 18:36:23 +09001537 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09001538 u32 serror = ehc->i.serror;
1539 unsigned int err_mask = 0, action = 0;
Tejun Heof9df58c2007-09-23 13:14:13 +09001540 u32 hotplug_mask;
Tejun Heo022bdb02006-05-15 20:58:22 +09001541
Tejun Heoe0614db2008-05-19 01:15:09 +09001542 if (serror & (SERR_PERSISTENT | SERR_DATA)) {
Tejun Heo022bdb02006-05-15 20:58:22 +09001543 err_mask |= AC_ERR_ATA_BUS;
Tejun Heocf480622008-01-24 00:05:14 +09001544 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001545 }
1546 if (serror & SERR_PROTOCOL) {
1547 err_mask |= AC_ERR_HSM;
Tejun Heocf480622008-01-24 00:05:14 +09001548 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001549 }
1550 if (serror & SERR_INTERNAL) {
1551 err_mask |= AC_ERR_SYSTEM;
Tejun Heocf480622008-01-24 00:05:14 +09001552 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001553 }
Tejun Heof9df58c2007-09-23 13:14:13 +09001554
1555 /* Determine whether a hotplug event has occurred. Both
1556 * SError.N/X are considered hotplug events for enabled or
1557 * host links. For disabled PMP links, only N bit is
1558 * considered as X bit is left at 1 for link plugging.
1559 */
1560 hotplug_mask = 0;
1561
1562 if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
1563 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
1564 else
1565 hotplug_mask = SERR_PHYRDY_CHG;
1566
1567 if (serror & hotplug_mask)
Tejun Heo084fe632006-05-31 18:28:03 +09001568 ata_ehi_hotplugged(&ehc->i);
Tejun Heo022bdb02006-05-15 20:58:22 +09001569
1570 ehc->i.err_mask |= err_mask;
1571 ehc->i.action |= action;
1572}
1573
1574/**
Tejun Heoe8ee8452006-05-15 21:03:46 +09001575 * ata_eh_analyze_ncq_error - analyze NCQ error
Tejun Heo02607312007-08-06 18:36:23 +09001576 * @link: ATA link to analyze NCQ error for
Tejun Heoe8ee8452006-05-15 21:03:46 +09001577 *
1578 * Read log page 10h, determine the offending qc and acquire
1579 * error status TF. For NCQ device errors, all LLDDs have to do
1580 * is setting AC_ERR_DEV in ehi->err_mask. This function takes
1581 * care of the rest.
1582 *
1583 * LOCKING:
1584 * Kernel thread context (may sleep).
1585 */
Mark Lord10acf3b2008-05-02 02:14:53 -04001586void ata_eh_analyze_ncq_error(struct ata_link *link)
Tejun Heoe8ee8452006-05-15 21:03:46 +09001587{
Tejun Heo02607312007-08-06 18:36:23 +09001588 struct ata_port *ap = link->ap;
1589 struct ata_eh_context *ehc = &link->eh_context;
1590 struct ata_device *dev = link->device;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001591 struct ata_queued_cmd *qc;
1592 struct ata_taskfile tf;
1593 int tag, rc;
1594
1595 /* if frozen, we can't do much */
Tejun Heob51e9e52006-06-29 01:29:30 +09001596 if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heoe8ee8452006-05-15 21:03:46 +09001597 return;
1598
1599 /* is it NCQ device error? */
Tejun Heo02607312007-08-06 18:36:23 +09001600 if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
Tejun Heoe8ee8452006-05-15 21:03:46 +09001601 return;
1602
1603 /* has LLDD analyzed already? */
1604 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1605 qc = __ata_qc_from_tag(ap, tag);
1606
1607 if (!(qc->flags & ATA_QCFLAG_FAILED))
1608 continue;
1609
1610 if (qc->err_mask)
1611 return;
1612 }
1613
1614 /* okay, this error is ours */
1615 rc = ata_eh_read_log_10h(dev, &tag, &tf);
1616 if (rc) {
Tejun Heo02607312007-08-06 18:36:23 +09001617 ata_link_printk(link, KERN_ERR, "failed to read log page 10h "
Tejun Heoe8ee8452006-05-15 21:03:46 +09001618 "(errno=%d)\n", rc);
1619 return;
1620 }
1621
Tejun Heo02607312007-08-06 18:36:23 +09001622 if (!(link->sactive & (1 << tag))) {
1623 ata_link_printk(link, KERN_ERR, "log page 10h reported "
Tejun Heoe8ee8452006-05-15 21:03:46 +09001624 "inactive tag %d\n", tag);
1625 return;
1626 }
1627
1628 /* we've got the perpetrator, condemn it */
1629 qc = __ata_qc_from_tag(ap, tag);
1630 memcpy(&qc->result_tf, &tf, sizeof(tf));
Mark Lorda6116c92008-04-23 22:36:25 -04001631 qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
Tejun Heo5335b722007-07-16 14:29:40 +09001632 qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
Tejun Heoe8ee8452006-05-15 21:03:46 +09001633 ehc->i.err_mask &= ~AC_ERR_DEV;
1634}
1635
1636/**
Tejun Heo022bdb02006-05-15 20:58:22 +09001637 * ata_eh_analyze_tf - analyze taskfile of a failed qc
1638 * @qc: qc to analyze
1639 * @tf: Taskfile registers to analyze
1640 *
1641 * Analyze taskfile of @qc and further determine cause of
1642 * failure. This function also requests ATAPI sense data if
1643 * avaliable.
1644 *
1645 * LOCKING:
1646 * Kernel thread context (may sleep).
1647 *
1648 * RETURNS:
1649 * Determined recovery action
1650 */
1651static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
1652 const struct ata_taskfile *tf)
1653{
1654 unsigned int tmp, action = 0;
1655 u8 stat = tf->command, err = tf->feature;
1656
1657 if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
1658 qc->err_mask |= AC_ERR_HSM;
Tejun Heocf480622008-01-24 00:05:14 +09001659 return ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001660 }
1661
Tejun Heoa51d6442007-03-20 15:24:11 +09001662 if (stat & (ATA_ERR | ATA_DF))
1663 qc->err_mask |= AC_ERR_DEV;
1664 else
Tejun Heo022bdb02006-05-15 20:58:22 +09001665 return 0;
1666
1667 switch (qc->dev->class) {
1668 case ATA_DEV_ATA:
1669 if (err & ATA_ICRC)
1670 qc->err_mask |= AC_ERR_ATA_BUS;
1671 if (err & ATA_UNC)
1672 qc->err_mask |= AC_ERR_MEDIA;
1673 if (err & ATA_IDNF)
1674 qc->err_mask |= AC_ERR_INVALID;
1675 break;
1676
1677 case ATA_DEV_ATAPI:
Tejun Heoa569a302006-11-21 10:40:51 +09001678 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
Tejun Heo3eabddb2008-06-10 18:28:05 +09001679 tmp = atapi_eh_request_sense(qc->dev,
1680 qc->scsicmd->sense_buffer,
1681 qc->result_tf.feature >> 4);
Tejun Heoa569a302006-11-21 10:40:51 +09001682 if (!tmp) {
1683 /* ATA_QCFLAG_SENSE_VALID is used to
1684 * tell atapi_qc_complete() that sense
1685 * data is already valid.
1686 *
1687 * TODO: interpret sense data and set
1688 * appropriate err_mask.
1689 */
1690 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1691 } else
1692 qc->err_mask |= tmp;
1693 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001694 }
1695
1696 if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
Tejun Heocf480622008-01-24 00:05:14 +09001697 action |= ATA_EH_RESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09001698
1699 return action;
1700}
1701
Tejun Heo76326ac2007-11-27 19:28:59 +09001702static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
1703 int *xfer_ok)
Tejun Heo022bdb02006-05-15 20:58:22 +09001704{
Tejun Heo76326ac2007-11-27 19:28:59 +09001705 int base = 0;
1706
1707 if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
1708 *xfer_ok = 1;
1709
1710 if (!*xfer_ok)
Tejun Heo75f9caf2008-01-03 01:21:14 +09001711 base = ATA_ECAT_DUBIOUS_NONE;
Tejun Heo76326ac2007-11-27 19:28:59 +09001712
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001713 if (err_mask & AC_ERR_ATA_BUS)
Tejun Heo76326ac2007-11-27 19:28:59 +09001714 return base + ATA_ECAT_ATA_BUS;
Tejun Heo022bdb02006-05-15 20:58:22 +09001715
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001716 if (err_mask & AC_ERR_TIMEOUT)
Tejun Heo76326ac2007-11-27 19:28:59 +09001717 return base + ATA_ECAT_TOUT_HSM;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001718
Tejun Heo3884f7b2007-11-27 19:28:56 +09001719 if (eflags & ATA_EFLAG_IS_IO) {
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001720 if (err_mask & AC_ERR_HSM)
Tejun Heo76326ac2007-11-27 19:28:59 +09001721 return base + ATA_ECAT_TOUT_HSM;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001722 if ((err_mask &
1723 (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
Tejun Heo76326ac2007-11-27 19:28:59 +09001724 return base + ATA_ECAT_UNK_DEV;
Tejun Heo022bdb02006-05-15 20:58:22 +09001725 }
1726
1727 return 0;
1728}
1729
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001730struct speed_down_verdict_arg {
Tejun Heo022bdb02006-05-15 20:58:22 +09001731 u64 since;
Tejun Heo76326ac2007-11-27 19:28:59 +09001732 int xfer_ok;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001733 int nr_errors[ATA_ECAT_NR];
Tejun Heo022bdb02006-05-15 20:58:22 +09001734};
1735
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001736static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
Tejun Heo022bdb02006-05-15 20:58:22 +09001737{
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001738 struct speed_down_verdict_arg *arg = void_arg;
Tejun Heo76326ac2007-11-27 19:28:59 +09001739 int cat;
Tejun Heo022bdb02006-05-15 20:58:22 +09001740
1741 if (ent->timestamp < arg->since)
1742 return -1;
1743
Tejun Heo76326ac2007-11-27 19:28:59 +09001744 cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
1745 &arg->xfer_ok);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001746 arg->nr_errors[cat]++;
Tejun Heo76326ac2007-11-27 19:28:59 +09001747
Tejun Heo022bdb02006-05-15 20:58:22 +09001748 return 0;
1749}
1750
1751/**
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001752 * ata_eh_speed_down_verdict - Determine speed down verdict
Tejun Heo022bdb02006-05-15 20:58:22 +09001753 * @dev: Device of interest
1754 *
1755 * This function examines error ring of @dev and determines
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001756 * whether NCQ needs to be turned off, transfer speed should be
1757 * stepped down, or falling back to PIO is necessary.
Tejun Heo022bdb02006-05-15 20:58:22 +09001758 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001759 * ECAT_ATA_BUS : ATA_BUS error for any command
Tejun Heo022bdb02006-05-15 20:58:22 +09001760 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001761 * ECAT_TOUT_HSM : TIMEOUT for any command or HSM violation for
1762 * IO commands
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001763 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001764 * ECAT_UNK_DEV : Unknown DEV error for IO commands
Tejun Heo022bdb02006-05-15 20:58:22 +09001765 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001766 * ECAT_DUBIOUS_* : Identical to above three but occurred while
1767 * data transfer hasn't been verified.
1768 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001769 * Verdicts are
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001770 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001771 * NCQ_OFF : Turn off NCQ.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001772 *
Tejun Heo3884f7b2007-11-27 19:28:56 +09001773 * SPEED_DOWN : Speed down transfer speed but don't fall back
1774 * to PIO.
1775 *
1776 * FALLBACK_TO_PIO : Fall back to PIO.
1777 *
1778 * Even if multiple verdicts are returned, only one action is
Tejun Heo76326ac2007-11-27 19:28:59 +09001779 * taken per error. An action triggered by non-DUBIOUS errors
1780 * clears ering, while one triggered by DUBIOUS_* errors doesn't.
1781 * This is to expedite speed down decisions right after device is
1782 * initially configured.
Tejun Heo3884f7b2007-11-27 19:28:56 +09001783 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001784 * The followings are speed down rules. #1 and #2 deal with
1785 * DUBIOUS errors.
1786 *
1787 * 1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors
1788 * occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO.
1789 *
1790 * 2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors
1791 * occurred during last 5 mins, NCQ_OFF.
1792 *
1793 * 3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors
Tejun Heo3884f7b2007-11-27 19:28:56 +09001794 * ocurred during last 5 mins, FALLBACK_TO_PIO
1795 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001796 * 4. If more than 3 TOUT_HSM or UNK_DEV errors occurred
Tejun Heo3884f7b2007-11-27 19:28:56 +09001797 * during last 10 mins, NCQ_OFF.
1798 *
Tejun Heo76326ac2007-11-27 19:28:59 +09001799 * 5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6
Tejun Heo3884f7b2007-11-27 19:28:56 +09001800 * UNK_DEV errors occurred during last 10 mins, SPEED_DOWN.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001801 *
Tejun Heo022bdb02006-05-15 20:58:22 +09001802 * LOCKING:
1803 * Inherited from caller.
1804 *
1805 * RETURNS:
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001806 * OR of ATA_EH_SPDN_* flags.
Tejun Heo022bdb02006-05-15 20:58:22 +09001807 */
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001808static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
Tejun Heo022bdb02006-05-15 20:58:22 +09001809{
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001810 const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
1811 u64 j64 = get_jiffies_64();
1812 struct speed_down_verdict_arg arg;
1813 unsigned int verdict = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09001814
Tejun Heo3884f7b2007-11-27 19:28:56 +09001815 /* scan past 5 mins of error history */
1816 memset(&arg, 0, sizeof(arg));
1817 arg.since = j64 - min(j64, j5mins);
1818 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
1819
Tejun Heo76326ac2007-11-27 19:28:59 +09001820 if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
1821 arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
1822 verdict |= ATA_EH_SPDN_SPEED_DOWN |
1823 ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
1824
1825 if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
1826 arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
1827 verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
1828
Tejun Heo3884f7b2007-11-27 19:28:56 +09001829 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1830 arg.nr_errors[ATA_ECAT_TOUT_HSM] +
Tejun Heo663f99b2007-11-27 19:28:57 +09001831 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
Tejun Heo3884f7b2007-11-27 19:28:56 +09001832 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
1833
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001834 /* scan past 10 mins of error history */
Tejun Heo022bdb02006-05-15 20:58:22 +09001835 memset(&arg, 0, sizeof(arg));
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001836 arg.since = j64 - min(j64, j10mins);
1837 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
Tejun Heo022bdb02006-05-15 20:58:22 +09001838
Tejun Heo3884f7b2007-11-27 19:28:56 +09001839 if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
1840 arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001841 verdict |= ATA_EH_SPDN_NCQ_OFF;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001842
1843 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
1844 arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
Tejun Heo663f99b2007-11-27 19:28:57 +09001845 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001846 verdict |= ATA_EH_SPDN_SPEED_DOWN;
Tejun Heo022bdb02006-05-15 20:58:22 +09001847
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001848 return verdict;
Tejun Heo022bdb02006-05-15 20:58:22 +09001849}
1850
1851/**
1852 * ata_eh_speed_down - record error and speed down if necessary
1853 * @dev: Failed device
Tejun Heo3884f7b2007-11-27 19:28:56 +09001854 * @eflags: mask of ATA_EFLAG_* flags
Tejun Heo022bdb02006-05-15 20:58:22 +09001855 * @err_mask: err_mask of the error
1856 *
1857 * Record error and examine error history to determine whether
1858 * adjusting transmission speed is necessary. It also sets
1859 * transmission limits appropriately if such adjustment is
1860 * necessary.
1861 *
1862 * LOCKING:
1863 * Kernel thread context (may sleep).
1864 *
1865 * RETURNS:
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001866 * Determined recovery action.
Tejun Heo022bdb02006-05-15 20:58:22 +09001867 */
Tejun Heo3884f7b2007-11-27 19:28:56 +09001868static unsigned int ata_eh_speed_down(struct ata_device *dev,
1869 unsigned int eflags, unsigned int err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09001870{
Tejun Heob1c72912008-07-31 17:02:43 +09001871 struct ata_link *link = ata_dev_phys_link(dev);
Tejun Heo76326ac2007-11-27 19:28:59 +09001872 int xfer_ok = 0;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001873 unsigned int verdict;
1874 unsigned int action = 0;
1875
1876 /* don't bother if Cat-0 error */
Tejun Heo76326ac2007-11-27 19:28:59 +09001877 if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
Tejun Heo022bdb02006-05-15 20:58:22 +09001878 return 0;
1879
1880 /* record error and determine whether speed down is necessary */
Tejun Heo3884f7b2007-11-27 19:28:56 +09001881 ata_ering_record(&dev->ering, eflags, err_mask);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001882 verdict = ata_eh_speed_down_verdict(dev);
Tejun Heo022bdb02006-05-15 20:58:22 +09001883
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001884 /* turn off NCQ? */
1885 if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
1886 (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
1887 ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
1888 dev->flags |= ATA_DFLAG_NCQ_OFF;
1889 ata_dev_printk(dev, KERN_WARNING,
1890 "NCQ disabled due to excessive errors\n");
1891 goto done;
1892 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001893
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001894 /* speed down? */
1895 if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
1896 /* speed down SATA link speed if possible */
Tejun Heoa07d4992009-01-29 20:31:33 +09001897 if (sata_down_spd_limit(link, 0) == 0) {
Tejun Heocf480622008-01-24 00:05:14 +09001898 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001899 goto done;
1900 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001901
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001902 /* lower transfer mode */
1903 if (dev->spdn_cnt < 2) {
1904 static const int dma_dnxfer_sel[] =
1905 { ATA_DNXFER_DMA, ATA_DNXFER_40C };
1906 static const int pio_dnxfer_sel[] =
1907 { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
1908 int sel;
Tejun Heo022bdb02006-05-15 20:58:22 +09001909
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001910 if (dev->xfer_shift != ATA_SHIFT_PIO)
1911 sel = dma_dnxfer_sel[dev->spdn_cnt];
1912 else
1913 sel = pio_dnxfer_sel[dev->spdn_cnt];
1914
1915 dev->spdn_cnt++;
1916
1917 if (ata_down_xfermask_limit(dev, sel) == 0) {
Tejun Heocf480622008-01-24 00:05:14 +09001918 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001919 goto done;
1920 }
1921 }
1922 }
1923
1924 /* Fall back to PIO? Slowing down to PIO is meaningless for
Tejun Heo663f99b2007-11-27 19:28:57 +09001925 * SATA ATA devices. Consider it only for PATA and SATAPI.
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001926 */
1927 if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
Tejun Heo663f99b2007-11-27 19:28:57 +09001928 (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) &&
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001929 (dev->xfer_shift != ATA_SHIFT_PIO)) {
1930 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
1931 dev->spdn_cnt = 0;
Tejun Heocf480622008-01-24 00:05:14 +09001932 action |= ATA_EH_RESET;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001933 goto done;
1934 }
1935 }
1936
Tejun Heo022bdb02006-05-15 20:58:22 +09001937 return 0;
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001938 done:
1939 /* device has been slowed down, blow error history */
Tejun Heo76326ac2007-11-27 19:28:59 +09001940 if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS))
1941 ata_ering_clear(&dev->ering);
Tejun Heo7d47e8d2007-02-02 16:22:31 +09001942 return action;
Tejun Heo022bdb02006-05-15 20:58:22 +09001943}
1944
1945/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09001946 * ata_eh_link_autopsy - analyze error and determine recovery action
1947 * @link: host link to perform autopsy on
Tejun Heo022bdb02006-05-15 20:58:22 +09001948 *
Tejun Heo02607312007-08-06 18:36:23 +09001949 * Analyze why @link failed and determine which recovery actions
1950 * are needed. This function also sets more detailed AC_ERR_*
1951 * values and fills sense data for ATAPI CHECK SENSE.
Tejun Heo022bdb02006-05-15 20:58:22 +09001952 *
1953 * LOCKING:
1954 * Kernel thread context (may sleep).
1955 */
Tejun Heo9b1e2652007-08-06 18:36:24 +09001956static void ata_eh_link_autopsy(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09001957{
Tejun Heo02607312007-08-06 18:36:23 +09001958 struct ata_port *ap = link->ap;
Tejun Heo936fd732007-08-06 18:36:23 +09001959 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heodfcc1732007-10-31 10:17:05 +09001960 struct ata_device *dev;
Tejun Heo3884f7b2007-11-27 19:28:56 +09001961 unsigned int all_err_mask = 0, eflags = 0;
1962 int tag;
Tejun Heo022bdb02006-05-15 20:58:22 +09001963 u32 serror;
1964 int rc;
1965
1966 DPRINTK("ENTER\n");
1967
Tejun Heo1cdaf532006-07-03 16:07:26 +09001968 if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
1969 return;
1970
Tejun Heo022bdb02006-05-15 20:58:22 +09001971 /* obtain and analyze SError */
Tejun Heo936fd732007-08-06 18:36:23 +09001972 rc = sata_scr_read(link, SCR_ERROR, &serror);
Tejun Heo022bdb02006-05-15 20:58:22 +09001973 if (rc == 0) {
1974 ehc->i.serror |= serror;
Tejun Heo02607312007-08-06 18:36:23 +09001975 ata_eh_analyze_serror(link);
Tejun Heo4e57c512007-07-16 14:29:41 +09001976 } else if (rc != -EOPNOTSUPP) {
Tejun Heocf480622008-01-24 00:05:14 +09001977 /* SError read failed, force reset and probing */
Tejun Heob558edd2008-01-24 00:05:14 +09001978 ehc->i.probe_mask |= ATA_ALL_DEVICES;
Tejun Heocf480622008-01-24 00:05:14 +09001979 ehc->i.action |= ATA_EH_RESET;
Tejun Heo4e57c512007-07-16 14:29:41 +09001980 ehc->i.err_mask |= AC_ERR_OTHER;
1981 }
Tejun Heo022bdb02006-05-15 20:58:22 +09001982
Tejun Heoe8ee8452006-05-15 21:03:46 +09001983 /* analyze NCQ failure */
Tejun Heo02607312007-08-06 18:36:23 +09001984 ata_eh_analyze_ncq_error(link);
Tejun Heoe8ee8452006-05-15 21:03:46 +09001985
Tejun Heo022bdb02006-05-15 20:58:22 +09001986 /* any real error trumps AC_ERR_OTHER */
1987 if (ehc->i.err_mask & ~AC_ERR_OTHER)
1988 ehc->i.err_mask &= ~AC_ERR_OTHER;
1989
1990 all_err_mask |= ehc->i.err_mask;
1991
1992 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1993 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1994
Tejun Heob1c72912008-07-31 17:02:43 +09001995 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
1996 ata_dev_phys_link(qc->dev) != link)
Tejun Heo022bdb02006-05-15 20:58:22 +09001997 continue;
1998
1999 /* inherit upper level err_mask */
2000 qc->err_mask |= ehc->i.err_mask;
2001
Tejun Heo022bdb02006-05-15 20:58:22 +09002002 /* analyze TF */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002003 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002004
2005 /* DEV errors are probably spurious in case of ATA_BUS error */
2006 if (qc->err_mask & AC_ERR_ATA_BUS)
2007 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
2008 AC_ERR_INVALID);
2009
2010 /* any real error trumps unknown error */
2011 if (qc->err_mask & ~AC_ERR_OTHER)
2012 qc->err_mask &= ~AC_ERR_OTHER;
2013
2014 /* SENSE_VALID trumps dev/unknown error and revalidation */
Tejun Heof90f0822007-10-26 16:12:41 +09002015 if (qc->flags & ATA_QCFLAG_SENSE_VALID)
Tejun Heo022bdb02006-05-15 20:58:22 +09002016 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
Tejun Heo022bdb02006-05-15 20:58:22 +09002017
Tejun Heo03faab72008-03-27 19:14:24 +09002018 /* determine whether the command is worth retrying */
2019 if (!(qc->err_mask & AC_ERR_INVALID) &&
2020 ((qc->flags & ATA_QCFLAG_IO) || qc->err_mask != AC_ERR_DEV))
2021 qc->flags |= ATA_QCFLAG_RETRY;
2022
Tejun Heo022bdb02006-05-15 20:58:22 +09002023 /* accumulate error info */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002024 ehc->i.dev = qc->dev;
Tejun Heo022bdb02006-05-15 20:58:22 +09002025 all_err_mask |= qc->err_mask;
2026 if (qc->flags & ATA_QCFLAG_IO)
Tejun Heo3884f7b2007-11-27 19:28:56 +09002027 eflags |= ATA_EFLAG_IS_IO;
Tejun Heo022bdb02006-05-15 20:58:22 +09002028 }
2029
Tejun Heoa20f33f2006-05-16 12:58:24 +09002030 /* enforce default EH actions */
Tejun Heob51e9e52006-06-29 01:29:30 +09002031 if (ap->pflags & ATA_PFLAG_FROZEN ||
Tejun Heoa20f33f2006-05-16 12:58:24 +09002032 all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
Tejun Heocf480622008-01-24 00:05:14 +09002033 ehc->i.action |= ATA_EH_RESET;
Tejun Heo3884f7b2007-11-27 19:28:56 +09002034 else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) ||
2035 (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV)))
Tejun Heo4528e4d2006-07-08 20:17:26 +09002036 ehc->i.action |= ATA_EH_REVALIDATE;
Tejun Heo022bdb02006-05-15 20:58:22 +09002037
Tejun Heodfcc1732007-10-31 10:17:05 +09002038 /* If we have offending qcs and the associated failed device,
2039 * perform per-dev EH action only on the offending device.
2040 */
Tejun Heo4528e4d2006-07-08 20:17:26 +09002041 if (ehc->i.dev) {
Tejun Heo4528e4d2006-07-08 20:17:26 +09002042 ehc->i.dev_action[ehc->i.dev->devno] |=
2043 ehc->i.action & ATA_EH_PERDEV_MASK;
2044 ehc->i.action &= ~ATA_EH_PERDEV_MASK;
Tejun Heo47005f22006-06-19 18:27:23 +09002045 }
2046
Tejun Heo2695e362008-01-10 13:41:23 +09002047 /* propagate timeout to host link */
2048 if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link))
2049 ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT;
2050
2051 /* record error and consider speeding down */
Tejun Heodfcc1732007-10-31 10:17:05 +09002052 dev = ehc->i.dev;
Tejun Heo2695e362008-01-10 13:41:23 +09002053 if (!dev && ((ata_link_max_devices(link) == 1 &&
2054 ata_dev_enabled(link->device))))
2055 dev = link->device;
Tejun Heodfcc1732007-10-31 10:17:05 +09002056
Tejun Heo76326ac2007-11-27 19:28:59 +09002057 if (dev) {
2058 if (dev->flags & ATA_DFLAG_DUBIOUS_XFER)
2059 eflags |= ATA_EFLAG_DUBIOUS_XFER;
Tejun Heo3884f7b2007-11-27 19:28:56 +09002060 ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask);
Tejun Heo76326ac2007-11-27 19:28:59 +09002061 }
Tejun Heodfcc1732007-10-31 10:17:05 +09002062
Tejun Heo022bdb02006-05-15 20:58:22 +09002063 DPRINTK("EXIT\n");
2064}
2065
2066/**
Tejun Heo9b1e2652007-08-06 18:36:24 +09002067 * ata_eh_autopsy - analyze error and determine recovery action
2068 * @ap: host port to perform autopsy on
2069 *
2070 * Analyze all links of @ap and determine why they failed and
2071 * which recovery actions are needed.
2072 *
2073 * LOCKING:
2074 * Kernel thread context (may sleep).
2075 */
Tejun Heofb7fd612007-09-23 13:14:12 +09002076void ata_eh_autopsy(struct ata_port *ap)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002077{
2078 struct ata_link *link;
2079
Tejun Heo1eca4362008-11-03 20:03:17 +09002080 ata_for_each_link(link, ap, EDGE)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002081 ata_eh_link_autopsy(link);
Tejun Heo2695e362008-01-10 13:41:23 +09002082
Tejun Heob1c72912008-07-31 17:02:43 +09002083 /* Handle the frigging slave link. Autopsy is done similarly
2084 * but actions and flags are transferred over to the master
2085 * link and handled from there.
2086 */
2087 if (ap->slave_link) {
2088 struct ata_eh_context *mehc = &ap->link.eh_context;
2089 struct ata_eh_context *sehc = &ap->slave_link->eh_context;
2090
Tejun Heo848e4c62008-10-21 14:26:39 +09002091 /* transfer control flags from master to slave */
2092 sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK;
2093
2094 /* perform autopsy on the slave link */
Tejun Heob1c72912008-07-31 17:02:43 +09002095 ata_eh_link_autopsy(ap->slave_link);
2096
Tejun Heo848e4c62008-10-21 14:26:39 +09002097 /* transfer actions from slave to master and clear slave */
Tejun Heob1c72912008-07-31 17:02:43 +09002098 ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2099 mehc->i.action |= sehc->i.action;
2100 mehc->i.dev_action[1] |= sehc->i.dev_action[1];
2101 mehc->i.flags |= sehc->i.flags;
2102 ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2103 }
2104
Tejun Heo2695e362008-01-10 13:41:23 +09002105 /* Autopsy of fanout ports can affect host link autopsy.
2106 * Perform host link autopsy last.
2107 */
Tejun Heo071f44b2008-04-07 22:47:22 +09002108 if (sata_pmp_attached(ap))
Tejun Heo2695e362008-01-10 13:41:23 +09002109 ata_eh_link_autopsy(&ap->link);
Tejun Heo9b1e2652007-08-06 18:36:24 +09002110}
2111
2112/**
2113 * ata_eh_link_report - report error handling to user
Tejun Heo02607312007-08-06 18:36:23 +09002114 * @link: ATA link EH is going on
Tejun Heo022bdb02006-05-15 20:58:22 +09002115 *
2116 * Report EH to user.
2117 *
2118 * LOCKING:
2119 * None.
2120 */
Tejun Heo9b1e2652007-08-06 18:36:24 +09002121static void ata_eh_link_report(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09002122{
Tejun Heo02607312007-08-06 18:36:23 +09002123 struct ata_port *ap = link->ap;
2124 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09002125 const char *frozen, *desc;
Tejun Heoa1e10f72007-08-18 13:28:49 +09002126 char tries_buf[6];
Tejun Heo022bdb02006-05-15 20:58:22 +09002127 int tag, nr_failed = 0;
2128
Tejun Heo94ff3d52007-10-09 14:57:56 +09002129 if (ehc->i.flags & ATA_EHI_QUIET)
2130 return;
2131
Tejun Heo022bdb02006-05-15 20:58:22 +09002132 desc = NULL;
2133 if (ehc->i.desc[0] != '\0')
2134 desc = ehc->i.desc;
2135
2136 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2137 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2138
Tejun Heob1c72912008-07-31 17:02:43 +09002139 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2140 ata_dev_phys_link(qc->dev) != link ||
Tejun Heoe027bd32007-10-26 16:19:26 +09002141 ((qc->flags & ATA_QCFLAG_QUIET) &&
2142 qc->err_mask == AC_ERR_DEV))
Tejun Heo022bdb02006-05-15 20:58:22 +09002143 continue;
2144 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
2145 continue;
2146
2147 nr_failed++;
2148 }
2149
2150 if (!nr_failed && !ehc->i.err_mask)
2151 return;
2152
2153 frozen = "";
Tejun Heob51e9e52006-06-29 01:29:30 +09002154 if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heo022bdb02006-05-15 20:58:22 +09002155 frozen = " frozen";
2156
Tejun Heoa1e10f72007-08-18 13:28:49 +09002157 memset(tries_buf, 0, sizeof(tries_buf));
2158 if (ap->eh_tries < ATA_EH_MAX_TRIES)
2159 snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d",
2160 ap->eh_tries);
2161
Tejun Heo022bdb02006-05-15 20:58:22 +09002162 if (ehc->i.dev) {
Tejun Heoe8ee8452006-05-15 21:03:46 +09002163 ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x "
Tejun Heoa1e10f72007-08-18 13:28:49 +09002164 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2165 ehc->i.err_mask, link->sactive, ehc->i.serror,
2166 ehc->i.action, frozen, tries_buf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002167 if (desc)
Tejun Heob64bbc32007-07-16 14:29:39 +09002168 ata_dev_printk(ehc->i.dev, KERN_ERR, "%s\n", desc);
Tejun Heo022bdb02006-05-15 20:58:22 +09002169 } else {
Tejun Heo02607312007-08-06 18:36:23 +09002170 ata_link_printk(link, KERN_ERR, "exception Emask 0x%x "
Tejun Heoa1e10f72007-08-18 13:28:49 +09002171 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2172 ehc->i.err_mask, link->sactive, ehc->i.serror,
2173 ehc->i.action, frozen, tries_buf);
Tejun Heo022bdb02006-05-15 20:58:22 +09002174 if (desc)
Tejun Heo02607312007-08-06 18:36:23 +09002175 ata_link_printk(link, KERN_ERR, "%s\n", desc);
Tejun Heo022bdb02006-05-15 20:58:22 +09002176 }
2177
Robert Hancock1333e192007-10-02 11:22:02 -04002178 if (ehc->i.serror)
Tejun Heoda0e21d2008-07-31 16:08:38 +09002179 ata_link_printk(link, KERN_ERR,
Robert Hancock1333e192007-10-02 11:22:02 -04002180 "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
2181 ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
2182 ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
2183 ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
2184 ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
2185 ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
2186 ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
2187 ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
2188 ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
2189 ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
2190 ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
2191 ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
2192 ehc->i.serror & SERR_CRC ? "BadCRC " : "",
2193 ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
2194 ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
2195 ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
2196 ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002197 ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
Robert Hancock1333e192007-10-02 11:22:02 -04002198
Tejun Heo022bdb02006-05-15 20:58:22 +09002199 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2200 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
Tejun Heo8a937582006-11-14 22:36:12 +09002201 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
Tejun Heoabb6a882007-11-28 23:16:09 +09002202 const u8 *cdb = qc->cdb;
2203 char data_buf[20] = "";
2204 char cdb_buf[70] = "";
Tejun Heo022bdb02006-05-15 20:58:22 +09002205
Tejun Heo02607312007-08-06 18:36:23 +09002206 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
Tejun Heob1c72912008-07-31 17:02:43 +09002207 ata_dev_phys_link(qc->dev) != link || !qc->err_mask)
Tejun Heo022bdb02006-05-15 20:58:22 +09002208 continue;
2209
Tejun Heoabb6a882007-11-28 23:16:09 +09002210 if (qc->dma_dir != DMA_NONE) {
2211 static const char *dma_str[] = {
2212 [DMA_BIDIRECTIONAL] = "bidi",
2213 [DMA_TO_DEVICE] = "out",
2214 [DMA_FROM_DEVICE] = "in",
2215 };
2216 static const char *prot_str[] = {
2217 [ATA_PROT_PIO] = "pio",
2218 [ATA_PROT_DMA] = "dma",
2219 [ATA_PROT_NCQ] = "ncq",
Tejun Heo0dc36882007-12-18 16:34:43 -05002220 [ATAPI_PROT_PIO] = "pio",
2221 [ATAPI_PROT_DMA] = "dma",
Tejun Heoabb6a882007-11-28 23:16:09 +09002222 };
2223
2224 snprintf(data_buf, sizeof(data_buf), " %s %u %s",
2225 prot_str[qc->tf.protocol], qc->nbytes,
2226 dma_str[qc->dma_dir]);
2227 }
2228
Jeff Garzike39eec12007-12-01 18:05:39 -05002229 if (ata_is_atapi(qc->tf.protocol))
Tejun Heoabb6a882007-11-28 23:16:09 +09002230 snprintf(cdb_buf, sizeof(cdb_buf),
2231 "cdb %02x %02x %02x %02x %02x %02x %02x %02x "
2232 "%02x %02x %02x %02x %02x %02x %02x %02x\n ",
2233 cdb[0], cdb[1], cdb[2], cdb[3],
2234 cdb[4], cdb[5], cdb[6], cdb[7],
2235 cdb[8], cdb[9], cdb[10], cdb[11],
2236 cdb[12], cdb[13], cdb[14], cdb[15]);
2237
Tejun Heo8a937582006-11-14 22:36:12 +09002238 ata_dev_printk(qc->dev, KERN_ERR,
2239 "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
Tejun Heoabb6a882007-11-28 23:16:09 +09002240 "tag %d%s\n %s"
Tejun Heo8a937582006-11-14 22:36:12 +09002241 "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
Tejun Heo5335b722007-07-16 14:29:40 +09002242 "Emask 0x%x (%s)%s\n",
Tejun Heo8a937582006-11-14 22:36:12 +09002243 cmd->command, cmd->feature, cmd->nsect,
2244 cmd->lbal, cmd->lbam, cmd->lbah,
2245 cmd->hob_feature, cmd->hob_nsect,
2246 cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
Tejun Heoabb6a882007-11-28 23:16:09 +09002247 cmd->device, qc->tag, data_buf, cdb_buf,
Tejun Heo8a937582006-11-14 22:36:12 +09002248 res->command, res->feature, res->nsect,
2249 res->lbal, res->lbam, res->lbah,
2250 res->hob_feature, res->hob_nsect,
2251 res->hob_lbal, res->hob_lbam, res->hob_lbah,
Tejun Heo5335b722007-07-16 14:29:40 +09002252 res->device, qc->err_mask, ata_err_string(qc->err_mask),
2253 qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
Robert Hancock1333e192007-10-02 11:22:02 -04002254
2255 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002256 ATA_ERR)) {
Robert Hancock1333e192007-10-02 11:22:02 -04002257 if (res->command & ATA_BUSY)
2258 ata_dev_printk(qc->dev, KERN_ERR,
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002259 "status: { Busy }\n");
Robert Hancock1333e192007-10-02 11:22:02 -04002260 else
2261 ata_dev_printk(qc->dev, KERN_ERR,
2262 "status: { %s%s%s%s}\n",
2263 res->command & ATA_DRDY ? "DRDY " : "",
2264 res->command & ATA_DF ? "DF " : "",
2265 res->command & ATA_DRQ ? "DRQ " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002266 res->command & ATA_ERR ? "ERR " : "");
Robert Hancock1333e192007-10-02 11:22:02 -04002267 }
2268
2269 if (cmd->command != ATA_CMD_PACKET &&
2270 (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF |
2271 ATA_ABORTED)))
2272 ata_dev_printk(qc->dev, KERN_ERR,
2273 "error: { %s%s%s%s}\n",
2274 res->feature & ATA_ICRC ? "ICRC " : "",
2275 res->feature & ATA_UNC ? "UNC " : "",
2276 res->feature & ATA_IDNF ? "IDNF " : "",
Jeff Garzik2dcb4072007-10-19 06:42:56 -04002277 res->feature & ATA_ABORTED ? "ABRT " : "");
Tejun Heo022bdb02006-05-15 20:58:22 +09002278 }
2279}
2280
Tejun Heo9b1e2652007-08-06 18:36:24 +09002281/**
2282 * ata_eh_report - report error handling to user
2283 * @ap: ATA port to report EH about
2284 *
2285 * Report EH to user.
2286 *
2287 * LOCKING:
2288 * None.
2289 */
Tejun Heofb7fd612007-09-23 13:14:12 +09002290void ata_eh_report(struct ata_port *ap)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002291{
2292 struct ata_link *link;
2293
Tejun Heo1eca4362008-11-03 20:03:17 +09002294 ata_for_each_link(link, ap, HOST_FIRST)
Tejun Heo9b1e2652007-08-06 18:36:24 +09002295 ata_eh_link_report(link);
2296}
2297
Tejun Heocc0680a2007-08-06 18:36:23 +09002298static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
Tejun Heob1c72912008-07-31 17:02:43 +09002299 unsigned int *classes, unsigned long deadline,
2300 bool clear_classes)
Tejun Heod87fa382006-05-31 18:28:24 +09002301{
Tejun Heof58229f2007-08-06 18:36:23 +09002302 struct ata_device *dev;
Tejun Heod87fa382006-05-31 18:28:24 +09002303
Tejun Heob1c72912008-07-31 17:02:43 +09002304 if (clear_classes)
Tejun Heo1eca4362008-11-03 20:03:17 +09002305 ata_for_each_dev(dev, link, ALL)
Tejun Heob1c72912008-07-31 17:02:43 +09002306 classes[dev->devno] = ATA_DEV_UNKNOWN;
Tejun Heod87fa382006-05-31 18:28:24 +09002307
Tejun Heof0465192008-05-19 01:15:08 +09002308 return reset(link, classes, deadline);
Tejun Heod87fa382006-05-31 18:28:24 +09002309}
2310
Tejun Heoae791c02007-09-23 13:14:12 +09002311static int ata_eh_followup_srst_needed(struct ata_link *link,
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002312 int rc, const unsigned int *classes)
Tejun Heo664faf02006-05-31 18:27:50 +09002313{
Tejun Heo45db2f62008-04-08 01:46:56 +09002314 if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link))
Tejun Heoae791c02007-09-23 13:14:12 +09002315 return 0;
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002316 if (rc == -EAGAIN)
2317 return 1;
Tejun Heo071f44b2008-04-07 22:47:22 +09002318 if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
Tejun Heo3495de72007-09-23 13:19:53 +09002319 return 1;
Tejun Heo664faf02006-05-31 18:27:50 +09002320 return 0;
2321}
2322
Tejun Heofb7fd612007-09-23 13:14:12 +09002323int ata_eh_reset(struct ata_link *link, int classify,
2324 ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
2325 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
Tejun Heo022bdb02006-05-15 20:58:22 +09002326{
Tejun Heoafaa5c32007-10-09 15:06:10 +09002327 struct ata_port *ap = link->ap;
Tejun Heob1c72912008-07-31 17:02:43 +09002328 struct ata_link *slave = ap->slave_link;
Tejun Heo936fd732007-08-06 18:36:23 +09002329 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heob1c72912008-07-31 17:02:43 +09002330 struct ata_eh_context *sehc = &slave->eh_context;
Tejun Heo664faf02006-05-31 18:27:50 +09002331 unsigned int *classes = ehc->classes;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002332 unsigned int lflags = link->flags;
Tejun Heo1cdaf532006-07-03 16:07:26 +09002333 int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
Tejun Heod8af0eb2008-05-20 02:17:53 +09002334 int max_tries = 0, try = 0;
Tejun Heob1c72912008-07-31 17:02:43 +09002335 struct ata_link *failed_link;
Tejun Heof58229f2007-08-06 18:36:23 +09002336 struct ata_device *dev;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002337 unsigned long deadline, now;
Tejun Heo022bdb02006-05-15 20:58:22 +09002338 ata_reset_fn_t reset;
Tejun Heoafaa5c32007-10-09 15:06:10 +09002339 unsigned long flags;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002340 u32 sstatus;
Tejun Heob1c72912008-07-31 17:02:43 +09002341 int nr_unknown, rc;
Tejun Heo022bdb02006-05-15 20:58:22 +09002342
Tejun Heo932648b2008-05-19 01:15:06 +09002343 /*
2344 * Prepare to reset
2345 */
Tejun Heod8af0eb2008-05-20 02:17:53 +09002346 while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX)
2347 max_tries++;
Tejun Heo05944bd2008-08-13 20:19:09 +09002348 if (link->flags & ATA_LFLAG_NO_HRST)
2349 hardreset = NULL;
2350 if (link->flags & ATA_LFLAG_NO_SRST)
2351 softreset = NULL;
Tejun Heod8af0eb2008-05-20 02:17:53 +09002352
Tejun Heo19b72322008-11-04 17:08:40 +09002353 /* make sure each reset attemp is at least COOL_DOWN apart */
2354 if (ehc->i.flags & ATA_EHI_DID_RESET) {
2355 now = jiffies;
2356 WARN_ON(time_after(ehc->last_reset, now));
2357 deadline = ata_deadline(ehc->last_reset,
2358 ATA_EH_RESET_COOL_DOWN);
2359 if (time_before(now, deadline))
2360 schedule_timeout_uninterruptible(deadline - now);
2361 }
Tejun Heo0a2c0f52008-05-20 02:17:52 +09002362
Tejun Heoafaa5c32007-10-09 15:06:10 +09002363 spin_lock_irqsave(ap->lock, flags);
2364 ap->pflags |= ATA_PFLAG_RESETTING;
2365 spin_unlock_irqrestore(ap->lock, flags);
2366
Tejun Heocf480622008-01-24 00:05:14 +09002367 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
Tejun Heo13abf502006-07-10 23:18:46 +09002368
Tejun Heo1eca4362008-11-03 20:03:17 +09002369 ata_for_each_dev(dev, link, ALL) {
Tejun Heocdeab112007-10-29 16:41:09 +09002370 /* If we issue an SRST then an ATA drive (not ATAPI)
2371 * may change configuration and be in PIO0 timing. If
2372 * we do a hard reset (or are coming from power on)
2373 * this is true for ATA or ATAPI. Until we've set a
2374 * suitable controller mode we should not touch the
2375 * bus as we may be talking too fast.
2376 */
2377 dev->pio_mode = XFER_PIO_0;
2378
2379 /* If the controller has a pio mode setup function
2380 * then use it to set the chipset to rights. Don't
2381 * touch the DMA setup as that will be dealt with when
2382 * configuring devices.
2383 */
2384 if (ap->ops->set_piomode)
2385 ap->ops->set_piomode(ap, dev);
2386 }
2387
Tejun Heocf480622008-01-24 00:05:14 +09002388 /* prefer hardreset */
Tejun Heo932648b2008-05-19 01:15:06 +09002389 reset = NULL;
Tejun Heocf480622008-01-24 00:05:14 +09002390 ehc->i.action &= ~ATA_EH_RESET;
2391 if (hardreset) {
2392 reset = hardreset;
Tejun Heoa6740502008-07-31 16:07:04 +09002393 ehc->i.action |= ATA_EH_HARDRESET;
Tejun Heo4f7faa32008-01-30 18:18:26 +09002394 } else if (softreset) {
Tejun Heocf480622008-01-24 00:05:14 +09002395 reset = softreset;
Tejun Heoa6740502008-07-31 16:07:04 +09002396 ehc->i.action |= ATA_EH_SOFTRESET;
Tejun Heocf480622008-01-24 00:05:14 +09002397 }
Tejun Heof5914a42006-05-31 18:27:48 +09002398
2399 if (prereset) {
Tejun Heob1c72912008-07-31 17:02:43 +09002400 unsigned long deadline = ata_deadline(jiffies,
2401 ATA_EH_PRERESET_TIMEOUT);
2402
2403 if (slave) {
2404 sehc->i.action &= ~ATA_EH_RESET;
2405 sehc->i.action |= ehc->i.action;
2406 }
2407
2408 rc = prereset(link, deadline);
2409
2410 /* If present, do prereset on slave link too. Reset
2411 * is skipped iff both master and slave links report
2412 * -ENOENT or clear ATA_EH_RESET.
2413 */
2414 if (slave && (rc == 0 || rc == -ENOENT)) {
2415 int tmp;
2416
2417 tmp = prereset(slave, deadline);
2418 if (tmp != -ENOENT)
2419 rc = tmp;
2420
2421 ehc->i.action |= sehc->i.action;
2422 }
2423
Tejun Heof5914a42006-05-31 18:27:48 +09002424 if (rc) {
Alan Coxc9619222006-09-26 17:53:38 +01002425 if (rc == -ENOENT) {
Tejun Heocc0680a2007-08-06 18:36:23 +09002426 ata_link_printk(link, KERN_DEBUG,
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002427 "port disabled. ignoring.\n");
Tejun Heocf480622008-01-24 00:05:14 +09002428 ehc->i.action &= ~ATA_EH_RESET;
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002429
Tejun Heo1eca4362008-11-03 20:03:17 +09002430 ata_for_each_dev(dev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +09002431 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heo4aa9ab62007-03-12 17:24:08 +09002432
2433 rc = 0;
Alan Coxc9619222006-09-26 17:53:38 +01002434 } else
Tejun Heocc0680a2007-08-06 18:36:23 +09002435 ata_link_printk(link, KERN_ERR,
Tejun Heof5914a42006-05-31 18:27:48 +09002436 "prereset failed (errno=%d)\n", rc);
Tejun Heofccb6ea2007-07-16 14:29:41 +09002437 goto out;
Tejun Heof5914a42006-05-31 18:27:48 +09002438 }
Tejun Heof5914a42006-05-31 18:27:48 +09002439
Tejun Heo932648b2008-05-19 01:15:06 +09002440 /* prereset() might have cleared ATA_EH_RESET. If so,
Tejun Heod6515e62009-03-04 15:59:30 +09002441 * bang classes, thaw and return.
Tejun Heo932648b2008-05-19 01:15:06 +09002442 */
2443 if (reset && !(ehc->i.action & ATA_EH_RESET)) {
Tejun Heo1eca4362008-11-03 20:03:17 +09002444 ata_for_each_dev(dev, link, ALL)
Tejun Heo932648b2008-05-19 01:15:06 +09002445 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heod6515e62009-03-04 15:59:30 +09002446 if ((ap->pflags & ATA_PFLAG_FROZEN) &&
2447 ata_is_host_link(link))
2448 ata_eh_thaw_port(ap);
Tejun Heo932648b2008-05-19 01:15:06 +09002449 rc = 0;
2450 goto out;
2451 }
Tejun Heof5914a42006-05-31 18:27:48 +09002452 }
2453
Tejun Heo022bdb02006-05-15 20:58:22 +09002454 retry:
Tejun Heo932648b2008-05-19 01:15:06 +09002455 /*
2456 * Perform reset
2457 */
Tejun Heodc98c322008-05-19 01:15:07 +09002458 if (ata_is_host_link(link))
2459 ata_eh_freeze_port(ap);
2460
Tejun Heo341c2c92008-05-20 02:17:51 +09002461 deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]);
Tejun Heo31daabd2007-02-02 16:50:52 +09002462
Tejun Heo932648b2008-05-19 01:15:06 +09002463 if (reset) {
2464 if (verbose)
2465 ata_link_printk(link, KERN_INFO, "%s resetting link\n",
2466 reset == softreset ? "soft" : "hard");
Tejun Heo022bdb02006-05-15 20:58:22 +09002467
Tejun Heo932648b2008-05-19 01:15:06 +09002468 /* mark that this EH session started with reset */
Tejun Heo19b72322008-11-04 17:08:40 +09002469 ehc->last_reset = jiffies;
Tejun Heo932648b2008-05-19 01:15:06 +09002470 if (reset == hardreset)
2471 ehc->i.flags |= ATA_EHI_DID_HARDRESET;
2472 else
2473 ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
Tejun Heo022bdb02006-05-15 20:58:22 +09002474
Tejun Heob1c72912008-07-31 17:02:43 +09002475 rc = ata_do_reset(link, reset, classes, deadline, true);
2476 if (rc && rc != -EAGAIN) {
2477 failed_link = link;
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002478 goto fail;
Tejun Heob1c72912008-07-31 17:02:43 +09002479 }
Tejun Heo022bdb02006-05-15 20:58:22 +09002480
Tejun Heob1c72912008-07-31 17:02:43 +09002481 /* hardreset slave link if existent */
2482 if (slave && reset == hardreset) {
2483 int tmp;
2484
2485 if (verbose)
2486 ata_link_printk(slave, KERN_INFO,
2487 "hard resetting link\n");
2488
2489 ata_eh_about_to_do(slave, NULL, ATA_EH_RESET);
2490 tmp = ata_do_reset(slave, reset, classes, deadline,
2491 false);
2492 switch (tmp) {
2493 case -EAGAIN:
2494 rc = -EAGAIN;
2495 case 0:
2496 break;
2497 default:
2498 failed_link = slave;
2499 rc = tmp;
2500 goto fail;
2501 }
2502 }
2503
2504 /* perform follow-up SRST if necessary */
Tejun Heo932648b2008-05-19 01:15:06 +09002505 if (reset == hardreset &&
Tejun Heo5dbfc9c2008-07-31 16:08:02 +09002506 ata_eh_followup_srst_needed(link, rc, classes)) {
Tejun Heo932648b2008-05-19 01:15:06 +09002507 reset = softreset;
Tejun Heo664faf02006-05-31 18:27:50 +09002508
Tejun Heo932648b2008-05-19 01:15:06 +09002509 if (!reset) {
2510 ata_link_printk(link, KERN_ERR,
2511 "follow-up softreset required "
2512 "but no softreset avaliable\n");
Tejun Heob1c72912008-07-31 17:02:43 +09002513 failed_link = link;
Tejun Heo932648b2008-05-19 01:15:06 +09002514 rc = -EINVAL;
2515 goto fail;
2516 }
2517
2518 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
Tejun Heob1c72912008-07-31 17:02:43 +09002519 rc = ata_do_reset(link, reset, classes, deadline, true);
Tejun Heo664faf02006-05-31 18:27:50 +09002520 }
Tejun Heo932648b2008-05-19 01:15:06 +09002521 } else {
2522 if (verbose)
2523 ata_link_printk(link, KERN_INFO, "no reset method "
2524 "available, skipping reset\n");
2525 if (!(lflags & ATA_LFLAG_ASSUME_CLASS))
2526 lflags |= ATA_LFLAG_ASSUME_ATA;
Tejun Heo664faf02006-05-31 18:27:50 +09002527 }
2528
Tejun Heo932648b2008-05-19 01:15:06 +09002529 /*
2530 * Post-reset processing
2531 */
Tejun Heo1eca4362008-11-03 20:03:17 +09002532 ata_for_each_dev(dev, link, ALL) {
Tejun Heo416dc9e2007-10-31 10:17:03 +09002533 /* After the reset, the device state is PIO 0 and the
2534 * controller state is undefined. Reset also wakes up
2535 * drives from sleeping mode.
2536 */
2537 dev->pio_mode = XFER_PIO_0;
2538 dev->flags &= ~ATA_DFLAG_SLEEPING;
Tejun Heo664faf02006-05-31 18:27:50 +09002539
Tejun Heo816ab892008-10-22 00:31:34 +09002540 if (!ata_phys_link_offline(ata_dev_phys_link(dev))) {
2541 /* apply class override */
2542 if (lflags & ATA_LFLAG_ASSUME_ATA)
2543 classes[dev->devno] = ATA_DEV_ATA;
2544 else if (lflags & ATA_LFLAG_ASSUME_SEMB)
2545 classes[dev->devno] = ATA_DEV_SEMB_UNSUP;
2546 } else
2547 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heo022bdb02006-05-15 20:58:22 +09002548 }
2549
Tejun Heo416dc9e2007-10-31 10:17:03 +09002550 /* record current link speed */
2551 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
2552 link->sata_spd = (sstatus >> 4) & 0xf;
Tejun Heob1c72912008-07-31 17:02:43 +09002553 if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0)
2554 slave->sata_spd = (sstatus >> 4) & 0xf;
Tejun Heo008a7892007-07-16 14:29:40 +09002555
Tejun Heodc98c322008-05-19 01:15:07 +09002556 /* thaw the port */
2557 if (ata_is_host_link(link))
2558 ata_eh_thaw_port(ap);
2559
Tejun Heof0465192008-05-19 01:15:08 +09002560 /* postreset() should clear hardware SError. Although SError
2561 * is cleared during link resume, clearing SError here is
2562 * necessary as some PHYs raise hotplug events after SRST.
2563 * This introduces race condition where hotplug occurs between
2564 * reset and here. This race is mediated by cross checking
2565 * link onlineness and classification result later.
2566 */
Tejun Heob1c72912008-07-31 17:02:43 +09002567 if (postreset) {
Tejun Heo416dc9e2007-10-31 10:17:03 +09002568 postreset(link, classes);
Tejun Heob1c72912008-07-31 17:02:43 +09002569 if (slave)
2570 postreset(slave, classes);
2571 }
Tejun Heo20952b62006-05-31 18:27:23 +09002572
Tejun Heof0465192008-05-19 01:15:08 +09002573 /* clear cached SError */
2574 spin_lock_irqsave(link->ap->lock, flags);
2575 link->eh_info.serror = 0;
Tejun Heob1c72912008-07-31 17:02:43 +09002576 if (slave)
2577 slave->eh_info.serror = 0;
Tejun Heof0465192008-05-19 01:15:08 +09002578 spin_unlock_irqrestore(link->ap->lock, flags);
2579
2580 /* Make sure onlineness and classification result correspond.
2581 * Hotplug could have happened during reset and some
2582 * controllers fail to wait while a drive is spinning up after
2583 * being hotplugged causing misdetection. By cross checking
2584 * link onlineness and classification result, those conditions
2585 * can be reliably detected and retried.
2586 */
Tejun Heob1c72912008-07-31 17:02:43 +09002587 nr_unknown = 0;
Tejun Heo1eca4362008-11-03 20:03:17 +09002588 ata_for_each_dev(dev, link, ALL) {
Tejun Heof0465192008-05-19 01:15:08 +09002589 /* convert all ATA_DEV_UNKNOWN to ATA_DEV_NONE */
Tejun Heob1c72912008-07-31 17:02:43 +09002590 if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
Tejun Heof0465192008-05-19 01:15:08 +09002591 classes[dev->devno] = ATA_DEV_NONE;
Tejun Heob1c72912008-07-31 17:02:43 +09002592 if (ata_phys_link_online(ata_dev_phys_link(dev)))
2593 nr_unknown++;
2594 }
Tejun Heof0465192008-05-19 01:15:08 +09002595 }
2596
Tejun Heob1c72912008-07-31 17:02:43 +09002597 if (classify && nr_unknown) {
Tejun Heof0465192008-05-19 01:15:08 +09002598 if (try < max_tries) {
2599 ata_link_printk(link, KERN_WARNING, "link online but "
2600 "device misclassified, retrying\n");
Tejun Heob1c72912008-07-31 17:02:43 +09002601 failed_link = link;
Tejun Heof0465192008-05-19 01:15:08 +09002602 rc = -EAGAIN;
2603 goto fail;
2604 }
2605 ata_link_printk(link, KERN_WARNING,
2606 "link online but device misclassified, "
2607 "device detection might fail\n");
2608 }
2609
Tejun Heo416dc9e2007-10-31 10:17:03 +09002610 /* reset successful, schedule revalidation */
Tejun Heocf480622008-01-24 00:05:14 +09002611 ata_eh_done(link, NULL, ATA_EH_RESET);
Tejun Heob1c72912008-07-31 17:02:43 +09002612 if (slave)
2613 ata_eh_done(slave, NULL, ATA_EH_RESET);
Tejun Heo19b72322008-11-04 17:08:40 +09002614 ehc->last_reset = jiffies; /* update to completion time */
Tejun Heo416dc9e2007-10-31 10:17:03 +09002615 ehc->i.action |= ATA_EH_REVALIDATE;
Tejun Heoae791c02007-09-23 13:14:12 +09002616
Tejun Heo416dc9e2007-10-31 10:17:03 +09002617 rc = 0;
Tejun Heofccb6ea2007-07-16 14:29:41 +09002618 out:
2619 /* clear hotplug flag */
2620 ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
Tejun Heob1c72912008-07-31 17:02:43 +09002621 if (slave)
2622 sehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
Tejun Heoafaa5c32007-10-09 15:06:10 +09002623
2624 spin_lock_irqsave(ap->lock, flags);
2625 ap->pflags &= ~ATA_PFLAG_RESETTING;
2626 spin_unlock_irqrestore(ap->lock, flags);
2627
Tejun Heo022bdb02006-05-15 20:58:22 +09002628 return rc;
Tejun Heo416dc9e2007-10-31 10:17:03 +09002629
2630 fail:
Tejun Heo5958e302008-04-07 22:47:20 +09002631 /* if SCR isn't accessible on a fan-out port, PMP needs to be reset */
2632 if (!ata_is_host_link(link) &&
2633 sata_scr_read(link, SCR_STATUS, &sstatus))
2634 rc = -ERESTART;
2635
Tejun Heo416dc9e2007-10-31 10:17:03 +09002636 if (rc == -ERESTART || try >= max_tries)
2637 goto out;
2638
2639 now = jiffies;
2640 if (time_before(now, deadline)) {
2641 unsigned long delta = deadline - now;
2642
Tejun Heob1c72912008-07-31 17:02:43 +09002643 ata_link_printk(failed_link, KERN_WARNING,
Tejun Heo0a2c0f52008-05-20 02:17:52 +09002644 "reset failed (errno=%d), retrying in %u secs\n",
2645 rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));
Tejun Heo416dc9e2007-10-31 10:17:03 +09002646
2647 while (delta)
2648 delta = schedule_timeout_uninterruptible(delta);
2649 }
2650
Tejun Heob1c72912008-07-31 17:02:43 +09002651 if (try == max_tries - 1) {
Tejun Heoa07d4992009-01-29 20:31:33 +09002652 sata_down_spd_limit(link, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002653 if (slave)
Tejun Heoa07d4992009-01-29 20:31:33 +09002654 sata_down_spd_limit(slave, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002655 } else if (rc == -EPIPE)
Tejun Heoa07d4992009-01-29 20:31:33 +09002656 sata_down_spd_limit(failed_link, 0);
Tejun Heob1c72912008-07-31 17:02:43 +09002657
Tejun Heo416dc9e2007-10-31 10:17:03 +09002658 if (hardreset)
2659 reset = hardreset;
2660 goto retry;
Tejun Heo022bdb02006-05-15 20:58:22 +09002661}
2662
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02002663static inline void ata_eh_pull_park_action(struct ata_port *ap)
2664{
2665 struct ata_link *link;
2666 struct ata_device *dev;
2667 unsigned long flags;
2668
2669 /*
2670 * This function can be thought of as an extended version of
2671 * ata_eh_about_to_do() specially crafted to accommodate the
2672 * requirements of ATA_EH_PARK handling. Since the EH thread
2673 * does not leave the do {} while () loop in ata_eh_recover as
2674 * long as the timeout for a park request to *one* device on
2675 * the port has not expired, and since we still want to pick
2676 * up park requests to other devices on the same port or
2677 * timeout updates for the same device, we have to pull
2678 * ATA_EH_PARK actions from eh_info into eh_context.i
2679 * ourselves at the beginning of each pass over the loop.
2680 *
2681 * Additionally, all write accesses to &ap->park_req_pending
2682 * through INIT_COMPLETION() (see below) or complete_all()
2683 * (see ata_scsi_park_store()) are protected by the host lock.
2684 * As a result we have that park_req_pending.done is zero on
2685 * exit from this function, i.e. when ATA_EH_PARK actions for
2686 * *all* devices on port ap have been pulled into the
2687 * respective eh_context structs. If, and only if,
2688 * park_req_pending.done is non-zero by the time we reach
2689 * wait_for_completion_timeout(), another ATA_EH_PARK action
2690 * has been scheduled for at least one of the devices on port
2691 * ap and we have to cycle over the do {} while () loop in
2692 * ata_eh_recover() again.
2693 */
2694
2695 spin_lock_irqsave(ap->lock, flags);
2696 INIT_COMPLETION(ap->park_req_pending);
Tejun Heo1eca4362008-11-03 20:03:17 +09002697 ata_for_each_link(link, ap, EDGE) {
2698 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02002699 struct ata_eh_info *ehi = &link->eh_info;
2700
2701 link->eh_context.i.dev_action[dev->devno] |=
2702 ehi->dev_action[dev->devno] & ATA_EH_PARK;
2703 ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK);
2704 }
2705 }
2706 spin_unlock_irqrestore(ap->lock, flags);
2707}
2708
2709static void ata_eh_park_issue_cmd(struct ata_device *dev, int park)
2710{
2711 struct ata_eh_context *ehc = &dev->link->eh_context;
2712 struct ata_taskfile tf;
2713 unsigned int err_mask;
2714
2715 ata_tf_init(dev, &tf);
2716 if (park) {
2717 ehc->unloaded_mask |= 1 << dev->devno;
2718 tf.command = ATA_CMD_IDLEIMMEDIATE;
2719 tf.feature = 0x44;
2720 tf.lbal = 0x4c;
2721 tf.lbam = 0x4e;
2722 tf.lbah = 0x55;
2723 } else {
2724 ehc->unloaded_mask &= ~(1 << dev->devno);
2725 tf.command = ATA_CMD_CHK_POWER;
2726 }
2727
2728 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
2729 tf.protocol |= ATA_PROT_NODATA;
2730 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
2731 if (park && (err_mask || tf.lbal != 0xc4)) {
2732 ata_dev_printk(dev, KERN_ERR, "head unload failed!\n");
2733 ehc->unloaded_mask &= ~(1 << dev->devno);
2734 }
2735}
2736
Tejun Heo02607312007-08-06 18:36:23 +09002737static int ata_eh_revalidate_and_attach(struct ata_link *link,
Tejun Heo084fe632006-05-31 18:28:03 +09002738 struct ata_device **r_failed_dev)
Tejun Heo022bdb02006-05-15 20:58:22 +09002739{
Tejun Heo02607312007-08-06 18:36:23 +09002740 struct ata_port *ap = link->ap;
2741 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09002742 struct ata_device *dev;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002743 unsigned int new_mask = 0;
Tejun Heo084fe632006-05-31 18:28:03 +09002744 unsigned long flags;
Tejun Heof58229f2007-08-06 18:36:23 +09002745 int rc = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09002746
2747 DPRINTK("ENTER\n");
2748
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002749 /* For PATA drive side cable detection to work, IDENTIFY must
2750 * be done backwards such that PDIAG- is released by the slave
2751 * device before the master device is identified.
2752 */
Tejun Heo1eca4362008-11-03 20:03:17 +09002753 ata_for_each_dev(dev, link, ALL_REVERSE) {
Tejun Heof58229f2007-08-06 18:36:23 +09002754 unsigned int action = ata_eh_dev_action(dev);
2755 unsigned int readid_flags = 0;
Tejun Heo47005f22006-06-19 18:27:23 +09002756
Tejun Heobff04642006-11-10 18:08:10 +09002757 if (ehc->i.flags & ATA_EHI_DID_RESET)
2758 readid_flags |= ATA_READID_POSTRESET;
2759
Tejun Heo9666f402007-05-04 21:27:47 +02002760 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
Tejun Heo633273a32007-09-23 13:19:54 +09002761 WARN_ON(dev->class == ATA_DEV_PMP);
2762
Tejun Heob1c72912008-07-31 17:02:43 +09002763 if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
Tejun Heo022bdb02006-05-15 20:58:22 +09002764 rc = -EIO;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002765 goto err;
Tejun Heo022bdb02006-05-15 20:58:22 +09002766 }
2767
Tejun Heo02607312007-08-06 18:36:23 +09002768 ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
Tejun Heo422c9da2007-09-23 13:14:12 +09002769 rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
2770 readid_flags);
Tejun Heo022bdb02006-05-15 20:58:22 +09002771 if (rc)
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002772 goto err;
Tejun Heo022bdb02006-05-15 20:58:22 +09002773
Tejun Heo02607312007-08-06 18:36:23 +09002774 ata_eh_done(link, dev, ATA_EH_REVALIDATE);
Tejun Heo47005f22006-06-19 18:27:23 +09002775
Tejun Heobaa1e782006-11-01 18:39:27 +09002776 /* Configuration may have changed, reconfigure
2777 * transfer mode.
2778 */
2779 ehc->i.flags |= ATA_EHI_SETMODE;
2780
zhao, forrest3057ac32006-06-12 12:01:34 +08002781 /* schedule the scsi_rescan_device() here */
2782 queue_work(ata_aux_wq, &(ap->scsi_rescan_task));
Tejun Heo084fe632006-05-31 18:28:03 +09002783 } else if (dev->class == ATA_DEV_UNKNOWN &&
2784 ehc->tries[dev->devno] &&
2785 ata_class_enabled(ehc->classes[dev->devno])) {
Tejun Heo842faa62009-05-10 01:06:54 +09002786 /* Temporarily set dev->class, it will be
2787 * permanently set once all configurations are
2788 * complete. This is necessary because new
2789 * device configuration is done in two
2790 * separate loops.
2791 */
Tejun Heo084fe632006-05-31 18:28:03 +09002792 dev->class = ehc->classes[dev->devno];
2793
Tejun Heo633273a32007-09-23 13:19:54 +09002794 if (dev->class == ATA_DEV_PMP)
2795 rc = sata_pmp_attach(dev);
2796 else
2797 rc = ata_dev_read_id(dev, &dev->class,
2798 readid_flags, dev->id);
Tejun Heo842faa62009-05-10 01:06:54 +09002799
2800 /* read_id might have changed class, store and reset */
2801 ehc->classes[dev->devno] = dev->class;
2802 dev->class = ATA_DEV_UNKNOWN;
2803
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002804 switch (rc) {
2805 case 0:
Tejun Heo99cf6102009-01-29 20:31:32 +09002806 /* clear error info accumulated during probe */
2807 ata_ering_clear(&dev->ering);
Tejun Heof58229f2007-08-06 18:36:23 +09002808 new_mask |= 1 << dev->devno;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002809 break;
2810 case -ENOENT:
Tejun Heo55a8e2c2006-11-10 18:08:10 +09002811 /* IDENTIFY was issued to non-existent
2812 * device. No need to reset. Just
Tejun Heo842faa62009-05-10 01:06:54 +09002813 * thaw and ignore the device.
Tejun Heo55a8e2c2006-11-10 18:08:10 +09002814 */
2815 ata_eh_thaw_port(ap);
Tejun Heo084fe632006-05-31 18:28:03 +09002816 break;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002817 default:
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002818 goto err;
Tejun Heo55a8e2c2006-11-10 18:08:10 +09002819 }
Tejun Heo022bdb02006-05-15 20:58:22 +09002820 }
2821 }
2822
Tejun Heoc1c4e8d2007-04-23 02:05:53 +09002823 /* PDIAG- should have been released, ask cable type if post-reset */
Tejun Heo33267322008-02-13 09:15:09 +09002824 if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) {
2825 if (ap->ops->cable_detect)
2826 ap->cbl = ap->ops->cable_detect(ap);
2827 ata_force_cbl(ap);
2828 }
Tejun Heoc1c4e8d2007-04-23 02:05:53 +09002829
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002830 /* Configure new devices forward such that user doesn't see
2831 * device detection messages backwards.
2832 */
Tejun Heo1eca4362008-11-03 20:03:17 +09002833 ata_for_each_dev(dev, link, ALL) {
Tejun Heo633273a32007-09-23 13:19:54 +09002834 if (!(new_mask & (1 << dev->devno)) ||
2835 dev->class == ATA_DEV_PMP)
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002836 continue;
2837
Tejun Heo842faa62009-05-10 01:06:54 +09002838 dev->class = ehc->classes[dev->devno];
2839
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002840 ehc->i.flags |= ATA_EHI_PRINTINFO;
2841 rc = ata_dev_configure(dev);
2842 ehc->i.flags &= ~ATA_EHI_PRINTINFO;
Tejun Heo842faa62009-05-10 01:06:54 +09002843 if (rc) {
2844 dev->class = ATA_DEV_UNKNOWN;
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002845 goto err;
Tejun Heo842faa62009-05-10 01:06:54 +09002846 }
Tejun Heo8c3c52a2007-03-22 22:24:19 +09002847
2848 spin_lock_irqsave(ap->lock, flags);
2849 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
2850 spin_unlock_irqrestore(ap->lock, flags);
2851
2852 /* new device discovered, configure xfermode */
2853 ehc->i.flags |= ATA_EHI_SETMODE;
2854 }
2855
2856 return 0;
2857
2858 err:
2859 *r_failed_dev = dev;
2860 DPRINTK("EXIT rc=%d\n", rc);
Tejun Heo022bdb02006-05-15 20:58:22 +09002861 return rc;
2862}
2863
Tejun Heo6f1d1e32007-11-27 19:28:55 +09002864/**
2865 * ata_set_mode - Program timings and issue SET FEATURES - XFER
2866 * @link: link on which timings will be programmed
Martin Olsson98a17082009-04-22 18:21:29 +02002867 * @r_failed_dev: out parameter for failed device
Tejun Heo6f1d1e32007-11-27 19:28:55 +09002868 *
2869 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If
2870 * ata_set_mode() fails, pointer to the failing device is
2871 * returned in @r_failed_dev.
2872 *
2873 * LOCKING:
2874 * PCI/etc. bus probe sem.
2875 *
2876 * RETURNS:
2877 * 0 on success, negative errno otherwise
2878 */
2879int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
2880{
2881 struct ata_port *ap = link->ap;
Tejun Heo00115e02007-11-27 19:28:58 +09002882 struct ata_device *dev;
2883 int rc;
Tejun Heo6f1d1e32007-11-27 19:28:55 +09002884
Tejun Heo76326ac2007-11-27 19:28:59 +09002885 /* if data transfer is verified, clear DUBIOUS_XFER on ering top */
Tejun Heo1eca4362008-11-03 20:03:17 +09002886 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo76326ac2007-11-27 19:28:59 +09002887 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) {
2888 struct ata_ering_entry *ent;
2889
2890 ent = ata_ering_top(&dev->ering);
2891 if (ent)
2892 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER;
2893 }
2894 }
2895
Tejun Heo6f1d1e32007-11-27 19:28:55 +09002896 /* has private set_mode? */
2897 if (ap->ops->set_mode)
Tejun Heo00115e02007-11-27 19:28:58 +09002898 rc = ap->ops->set_mode(link, r_failed_dev);
2899 else
2900 rc = ata_do_set_mode(link, r_failed_dev);
2901
2902 /* if transfer mode has changed, set DUBIOUS_XFER on device */
Tejun Heo1eca4362008-11-03 20:03:17 +09002903 ata_for_each_dev(dev, link, ENABLED) {
Tejun Heo00115e02007-11-27 19:28:58 +09002904 struct ata_eh_context *ehc = &link->eh_context;
2905 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno];
2906 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno));
2907
2908 if (dev->xfer_mode != saved_xfer_mode ||
2909 ata_ncq_enabled(dev) != saved_ncq)
2910 dev->flags |= ATA_DFLAG_DUBIOUS_XFER;
2911 }
2912
2913 return rc;
Tejun Heo6f1d1e32007-11-27 19:28:55 +09002914}
2915
Tejun Heo11fc33d2008-08-30 14:20:01 +02002916/**
2917 * atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset
2918 * @dev: ATAPI device to clear UA for
2919 *
2920 * Resets and other operations can make an ATAPI device raise
2921 * UNIT ATTENTION which causes the next operation to fail. This
2922 * function clears UA.
2923 *
2924 * LOCKING:
2925 * EH context (may sleep).
2926 *
2927 * RETURNS:
2928 * 0 on success, -errno on failure.
2929 */
2930static int atapi_eh_clear_ua(struct ata_device *dev)
2931{
2932 int i;
2933
2934 for (i = 0; i < ATA_EH_UA_TRIES; i++) {
Tejun Heob5357082009-03-02 18:55:16 +09002935 u8 *sense_buffer = dev->link->ap->sector_buf;
Tejun Heo11fc33d2008-08-30 14:20:01 +02002936 u8 sense_key = 0;
2937 unsigned int err_mask;
2938
2939 err_mask = atapi_eh_tur(dev, &sense_key);
2940 if (err_mask != 0 && err_mask != AC_ERR_DEV) {
2941 ata_dev_printk(dev, KERN_WARNING, "TEST_UNIT_READY "
2942 "failed (err_mask=0x%x)\n", err_mask);
2943 return -EIO;
2944 }
2945
2946 if (!err_mask || sense_key != UNIT_ATTENTION)
2947 return 0;
2948
2949 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key);
2950 if (err_mask) {
2951 ata_dev_printk(dev, KERN_WARNING, "failed to clear "
2952 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask);
2953 return -EIO;
2954 }
2955 }
2956
2957 ata_dev_printk(dev, KERN_WARNING,
2958 "UNIT ATTENTION persists after %d tries\n", ATA_EH_UA_TRIES);
2959
2960 return 0;
2961}
2962
Tejun Heo02607312007-08-06 18:36:23 +09002963static int ata_link_nr_enabled(struct ata_link *link)
Tejun Heo022bdb02006-05-15 20:58:22 +09002964{
Tejun Heof58229f2007-08-06 18:36:23 +09002965 struct ata_device *dev;
2966 int cnt = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09002967
Tejun Heo1eca4362008-11-03 20:03:17 +09002968 ata_for_each_dev(dev, link, ENABLED)
2969 cnt++;
Tejun Heo022bdb02006-05-15 20:58:22 +09002970 return cnt;
2971}
2972
Tejun Heo02607312007-08-06 18:36:23 +09002973static int ata_link_nr_vacant(struct ata_link *link)
Tejun Heo084fe632006-05-31 18:28:03 +09002974{
Tejun Heof58229f2007-08-06 18:36:23 +09002975 struct ata_device *dev;
2976 int cnt = 0;
Tejun Heo084fe632006-05-31 18:28:03 +09002977
Tejun Heo1eca4362008-11-03 20:03:17 +09002978 ata_for_each_dev(dev, link, ALL)
Tejun Heof58229f2007-08-06 18:36:23 +09002979 if (dev->class == ATA_DEV_UNKNOWN)
Tejun Heo084fe632006-05-31 18:28:03 +09002980 cnt++;
2981 return cnt;
2982}
2983
Tejun Heo02607312007-08-06 18:36:23 +09002984static int ata_eh_skip_recovery(struct ata_link *link)
Tejun Heo084fe632006-05-31 18:28:03 +09002985{
Tejun Heo672b2d62008-01-24 00:05:14 +09002986 struct ata_port *ap = link->ap;
Tejun Heo02607312007-08-06 18:36:23 +09002987 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heof58229f2007-08-06 18:36:23 +09002988 struct ata_device *dev;
Tejun Heo084fe632006-05-31 18:28:03 +09002989
Tejun Heof9df58c2007-09-23 13:14:13 +09002990 /* skip disabled links */
2991 if (link->flags & ATA_LFLAG_DISABLED)
2992 return 1;
2993
Tejun Heo672b2d62008-01-24 00:05:14 +09002994 /* thaw frozen port and recover failed devices */
2995 if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link))
2996 return 0;
2997
2998 /* reset at least once if reset is requested */
2999 if ((ehc->i.action & ATA_EH_RESET) &&
3000 !(ehc->i.flags & ATA_EHI_DID_RESET))
Tejun Heo084fe632006-05-31 18:28:03 +09003001 return 0;
3002
3003 /* skip if class codes for all vacant slots are ATA_DEV_NONE */
Tejun Heo1eca4362008-11-03 20:03:17 +09003004 ata_for_each_dev(dev, link, ALL) {
Tejun Heo084fe632006-05-31 18:28:03 +09003005 if (dev->class == ATA_DEV_UNKNOWN &&
3006 ehc->classes[dev->devno] != ATA_DEV_NONE)
3007 return 0;
3008 }
3009
3010 return 1;
3011}
3012
Tejun Heoc2c7a892009-01-29 20:31:34 +09003013static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg)
3014{
3015 u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL);
3016 u64 now = get_jiffies_64();
3017 int *trials = void_arg;
3018
3019 if (ent->timestamp < now - min(now, interval))
3020 return -1;
3021
3022 (*trials)++;
3023 return 0;
3024}
3025
Tejun Heo02c05a22007-11-27 19:28:54 +09003026static int ata_eh_schedule_probe(struct ata_device *dev)
3027{
3028 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heoc2c7a892009-01-29 20:31:34 +09003029 struct ata_link *link = ata_dev_phys_link(dev);
3030 int trials = 0;
Tejun Heo02c05a22007-11-27 19:28:54 +09003031
3032 if (!(ehc->i.probe_mask & (1 << dev->devno)) ||
3033 (ehc->did_probe_mask & (1 << dev->devno)))
3034 return 0;
3035
3036 ata_eh_detach_dev(dev);
3037 ata_dev_init(dev);
3038 ehc->did_probe_mask |= (1 << dev->devno);
Tejun Heocf480622008-01-24 00:05:14 +09003039 ehc->i.action |= ATA_EH_RESET;
Tejun Heo00115e02007-11-27 19:28:58 +09003040 ehc->saved_xfer_mode[dev->devno] = 0;
3041 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
Tejun Heo02c05a22007-11-27 19:28:54 +09003042
Tejun Heoc2c7a892009-01-29 20:31:34 +09003043 /* Record and count probe trials on the ering. The specific
3044 * error mask used is irrelevant. Because a successful device
3045 * detection clears the ering, this count accumulates only if
3046 * there are consecutive failed probes.
3047 *
3048 * If the count is equal to or higher than ATA_EH_PROBE_TRIALS
3049 * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is
3050 * forced to 1.5Gbps.
3051 *
3052 * This is to work around cases where failed link speed
3053 * negotiation results in device misdetection leading to
3054 * infinite DEVXCHG or PHRDY CHG events.
3055 */
3056 ata_ering_record(&dev->ering, 0, AC_ERR_OTHER);
3057 ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials);
3058
3059 if (trials > ATA_EH_PROBE_TRIALS)
3060 sata_down_spd_limit(link, 1);
3061
Tejun Heo02c05a22007-11-27 19:28:54 +09003062 return 1;
3063}
3064
Tejun Heo9b1e2652007-08-06 18:36:24 +09003065static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
Tejun Heofee7ca72007-07-01 19:05:58 +09003066{
Tejun Heo9af5c9c2007-08-06 18:36:22 +09003067 struct ata_eh_context *ehc = &dev->link->eh_context;
Tejun Heofee7ca72007-07-01 19:05:58 +09003068
Tejun Heocf9a5902009-01-29 20:31:35 +09003069 /* -EAGAIN from EH routine indicates retry without prejudice.
3070 * The requester is responsible for ensuring forward progress.
3071 */
3072 if (err != -EAGAIN)
3073 ehc->tries[dev->devno]--;
Tejun Heofee7ca72007-07-01 19:05:58 +09003074
3075 switch (err) {
3076 case -ENODEV:
3077 /* device missing or wrong IDENTIFY data, schedule probing */
3078 ehc->i.probe_mask |= (1 << dev->devno);
3079 case -EINVAL:
3080 /* give it just one more chance */
3081 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
3082 case -EIO:
Tejun Heod89293a2009-01-29 20:31:29 +09003083 if (ehc->tries[dev->devno] == 1) {
Tejun Heofee7ca72007-07-01 19:05:58 +09003084 /* This is the last chance, better to slow
3085 * down than lose it.
3086 */
Tejun Heoa07d4992009-01-29 20:31:33 +09003087 sata_down_spd_limit(ata_dev_phys_link(dev), 0);
Tejun Heod89293a2009-01-29 20:31:29 +09003088 if (dev->pio_mode > XFER_PIO_0)
3089 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
Tejun Heofee7ca72007-07-01 19:05:58 +09003090 }
3091 }
3092
3093 if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
3094 /* disable device if it has used up all its chances */
3095 ata_dev_disable(dev);
3096
3097 /* detach if offline */
Tejun Heob1c72912008-07-31 17:02:43 +09003098 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
Tejun Heofee7ca72007-07-01 19:05:58 +09003099 ata_eh_detach_dev(dev);
3100
Tejun Heo02c05a22007-11-27 19:28:54 +09003101 /* schedule probe if necessary */
Tejun Heo87fbc5a2008-05-20 02:17:54 +09003102 if (ata_eh_schedule_probe(dev)) {
Tejun Heofee7ca72007-07-01 19:05:58 +09003103 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
Tejun Heo87fbc5a2008-05-20 02:17:54 +09003104 memset(ehc->cmd_timeout_idx[dev->devno], 0,
3105 sizeof(ehc->cmd_timeout_idx[dev->devno]));
3106 }
Tejun Heo9b1e2652007-08-06 18:36:24 +09003107
3108 return 1;
Tejun Heofee7ca72007-07-01 19:05:58 +09003109 } else {
Tejun Heocf480622008-01-24 00:05:14 +09003110 ehc->i.action |= ATA_EH_RESET;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003111 return 0;
Tejun Heofee7ca72007-07-01 19:05:58 +09003112 }
3113}
3114
Tejun Heo022bdb02006-05-15 20:58:22 +09003115/**
3116 * ata_eh_recover - recover host port after error
3117 * @ap: host port to recover
Tejun Heof5914a42006-05-31 18:27:48 +09003118 * @prereset: prereset method (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09003119 * @softreset: softreset method (can be NULL)
3120 * @hardreset: hardreset method (can be NULL)
3121 * @postreset: postreset method (can be NULL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003122 * @r_failed_link: out parameter for failed link
Tejun Heo022bdb02006-05-15 20:58:22 +09003123 *
3124 * This is the alpha and omega, eum and yang, heart and soul of
3125 * libata exception handling. On entry, actions required to
Tejun Heo9b1e2652007-08-06 18:36:24 +09003126 * recover each link and hotplug requests are recorded in the
3127 * link's eh_context. This function executes all the operations
3128 * with appropriate retrials and fallbacks to resurrect failed
Tejun Heo084fe632006-05-31 18:28:03 +09003129 * devices, detach goners and greet newcomers.
Tejun Heo022bdb02006-05-15 20:58:22 +09003130 *
3131 * LOCKING:
3132 * Kernel thread context (may sleep).
3133 *
3134 * RETURNS:
3135 * 0 on success, -errno on failure.
3136 */
Tejun Heofb7fd612007-09-23 13:14:12 +09003137int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
3138 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3139 ata_postreset_fn_t postreset,
3140 struct ata_link **r_failed_link)
Tejun Heo022bdb02006-05-15 20:58:22 +09003141{
Tejun Heo9b1e2652007-08-06 18:36:24 +09003142 struct ata_link *link;
Tejun Heo022bdb02006-05-15 20:58:22 +09003143 struct ata_device *dev;
Tejun Heo0a2c0f52008-05-20 02:17:52 +09003144 int nr_failed_devs;
Tejun Heodc98c322008-05-19 01:15:07 +09003145 int rc;
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003146 unsigned long flags, deadline;
Tejun Heo022bdb02006-05-15 20:58:22 +09003147
3148 DPRINTK("ENTER\n");
3149
3150 /* prep for recovery */
Tejun Heo1eca4362008-11-03 20:03:17 +09003151 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003152 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo084fe632006-05-31 18:28:03 +09003153
Tejun Heof9df58c2007-09-23 13:14:13 +09003154 /* re-enable link? */
3155 if (ehc->i.action & ATA_EH_ENABLE_LINK) {
3156 ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
3157 spin_lock_irqsave(ap->lock, flags);
3158 link->flags &= ~ATA_LFLAG_DISABLED;
3159 spin_unlock_irqrestore(ap->lock, flags);
3160 ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
3161 }
3162
Tejun Heo1eca4362008-11-03 20:03:17 +09003163 ata_for_each_dev(dev, link, ALL) {
Tejun Heofd995f72007-09-23 13:14:12 +09003164 if (link->flags & ATA_LFLAG_NO_RETRY)
3165 ehc->tries[dev->devno] = 1;
3166 else
3167 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
Tejun Heo79a55b72007-01-18 17:22:18 +09003168
Tejun Heo9b1e2652007-08-06 18:36:24 +09003169 /* collect port action mask recorded in dev actions */
3170 ehc->i.action |= ehc->i.dev_action[dev->devno] &
3171 ~ATA_EH_PERDEV_MASK;
3172 ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
Tejun Heo084fe632006-05-31 18:28:03 +09003173
Tejun Heo9b1e2652007-08-06 18:36:24 +09003174 /* process hotplug request */
3175 if (dev->flags & ATA_DFLAG_DETACH)
3176 ata_eh_detach_dev(dev);
3177
Tejun Heo02c05a22007-11-27 19:28:54 +09003178 /* schedule probe if necessary */
3179 if (!ata_dev_enabled(dev))
3180 ata_eh_schedule_probe(dev);
Tejun Heo084fe632006-05-31 18:28:03 +09003181 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003182 }
3183
3184 retry:
Tejun Heo022bdb02006-05-15 20:58:22 +09003185 rc = 0;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003186 nr_failed_devs = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003187
Tejun Heoaeb2ecd2006-06-12 14:11:43 +09003188 /* if UNLOADING, finish immediately */
Tejun Heob51e9e52006-06-29 01:29:30 +09003189 if (ap->pflags & ATA_PFLAG_UNLOADING)
Tejun Heoaeb2ecd2006-06-12 14:11:43 +09003190 goto out;
3191
Tejun Heo9b1e2652007-08-06 18:36:24 +09003192 /* prep for EH */
Tejun Heo1eca4362008-11-03 20:03:17 +09003193 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003194 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003195
Tejun Heo9b1e2652007-08-06 18:36:24 +09003196 /* skip EH if possible. */
3197 if (ata_eh_skip_recovery(link))
3198 ehc->i.action = 0;
3199
Tejun Heo1eca4362008-11-03 20:03:17 +09003200 ata_for_each_dev(dev, link, ALL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003201 ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
3202 }
Tejun Heo084fe632006-05-31 18:28:03 +09003203
Tejun Heo022bdb02006-05-15 20:58:22 +09003204 /* reset */
Tejun Heo1eca4362008-11-03 20:03:17 +09003205 ata_for_each_link(link, ap, EDGE) {
Tejun Heodc98c322008-05-19 01:15:07 +09003206 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003207
Tejun Heodc98c322008-05-19 01:15:07 +09003208 if (!(ehc->i.action & ATA_EH_RESET))
3209 continue;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003210
Tejun Heodc98c322008-05-19 01:15:07 +09003211 rc = ata_eh_reset(link, ata_link_nr_vacant(link),
3212 prereset, softreset, hardreset, postreset);
3213 if (rc) {
3214 ata_link_printk(link, KERN_ERR,
3215 "reset failed, giving up\n");
3216 goto out;
Tejun Heo022bdb02006-05-15 20:58:22 +09003217 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003218 }
3219
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003220 do {
3221 unsigned long now;
3222
3223 /*
3224 * clears ATA_EH_PARK in eh_info and resets
3225 * ap->park_req_pending
3226 */
3227 ata_eh_pull_park_action(ap);
3228
3229 deadline = jiffies;
Tejun Heo1eca4362008-11-03 20:03:17 +09003230 ata_for_each_link(link, ap, EDGE) {
3231 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003232 struct ata_eh_context *ehc = &link->eh_context;
3233 unsigned long tmp;
3234
3235 if (dev->class != ATA_DEV_ATA)
3236 continue;
3237 if (!(ehc->i.dev_action[dev->devno] &
3238 ATA_EH_PARK))
3239 continue;
3240 tmp = dev->unpark_deadline;
3241 if (time_before(deadline, tmp))
3242 deadline = tmp;
3243 else if (time_before_eq(tmp, jiffies))
3244 continue;
3245 if (ehc->unloaded_mask & (1 << dev->devno))
3246 continue;
3247
3248 ata_eh_park_issue_cmd(dev, 1);
3249 }
3250 }
3251
3252 now = jiffies;
3253 if (time_before_eq(deadline, now))
3254 break;
3255
3256 deadline = wait_for_completion_timeout(&ap->park_req_pending,
3257 deadline - now);
3258 } while (deadline);
Tejun Heo1eca4362008-11-03 20:03:17 +09003259 ata_for_each_link(link, ap, EDGE) {
3260 ata_for_each_dev(dev, link, ALL) {
Elias Oltmanns45fabbb2008-09-21 11:54:08 +02003261 if (!(link->eh_context.unloaded_mask &
3262 (1 << dev->devno)))
3263 continue;
3264
3265 ata_eh_park_issue_cmd(dev, 0);
3266 ata_eh_done(link, dev, ATA_EH_PARK);
3267 }
3268 }
3269
Tejun Heo9b1e2652007-08-06 18:36:24 +09003270 /* the rest */
Tejun Heo1eca4362008-11-03 20:03:17 +09003271 ata_for_each_link(link, ap, EDGE) {
Tejun Heo9b1e2652007-08-06 18:36:24 +09003272 struct ata_eh_context *ehc = &link->eh_context;
Tejun Heo022bdb02006-05-15 20:58:22 +09003273
Tejun Heo9b1e2652007-08-06 18:36:24 +09003274 /* revalidate existing devices and attach new ones */
3275 rc = ata_eh_revalidate_and_attach(link, &dev);
Tejun Heo4ae72a12007-02-02 16:22:30 +09003276 if (rc)
Tejun Heo022bdb02006-05-15 20:58:22 +09003277 goto dev_fail;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003278
Tejun Heo633273a32007-09-23 13:19:54 +09003279 /* if PMP got attached, return, pmp EH will take care of it */
3280 if (link->device->class == ATA_DEV_PMP) {
3281 ehc->i.action = 0;
3282 return 0;
3283 }
3284
Tejun Heo9b1e2652007-08-06 18:36:24 +09003285 /* configure transfer mode if necessary */
3286 if (ehc->i.flags & ATA_EHI_SETMODE) {
3287 rc = ata_set_mode(link, &dev);
3288 if (rc)
3289 goto dev_fail;
3290 ehc->i.flags &= ~ATA_EHI_SETMODE;
3291 }
3292
Tejun Heo11fc33d2008-08-30 14:20:01 +02003293 /* If reset has been issued, clear UA to avoid
3294 * disrupting the current users of the device.
3295 */
3296 if (ehc->i.flags & ATA_EHI_DID_RESET) {
Tejun Heo1eca4362008-11-03 20:03:17 +09003297 ata_for_each_dev(dev, link, ALL) {
Tejun Heo11fc33d2008-08-30 14:20:01 +02003298 if (dev->class != ATA_DEV_ATAPI)
3299 continue;
3300 rc = atapi_eh_clear_ua(dev);
3301 if (rc)
3302 goto dev_fail;
3303 }
3304 }
3305
3306 /* configure link power saving */
Tejun Heo3ec25eb2008-03-27 18:37:14 +09003307 if (ehc->i.action & ATA_EH_LPM)
Tejun Heo1eca4362008-11-03 20:03:17 +09003308 ata_for_each_dev(dev, link, ALL)
Kristen Carlson Accardica773292007-10-25 00:58:59 -04003309 ata_dev_enable_pm(dev, ap->pm_policy);
3310
Tejun Heo9b1e2652007-08-06 18:36:24 +09003311 /* this link is okay now */
3312 ehc->i.flags = 0;
3313 continue;
3314
Jeff Garzik2dcb4072007-10-19 06:42:56 -04003315dev_fail:
Tejun Heo9b1e2652007-08-06 18:36:24 +09003316 nr_failed_devs++;
Tejun Heo0a2c0f52008-05-20 02:17:52 +09003317 ata_eh_handle_dev_fail(dev, rc);
Tejun Heo9b1e2652007-08-06 18:36:24 +09003318
Tejun Heob06ce3e2007-10-09 15:06:48 +09003319 if (ap->pflags & ATA_PFLAG_FROZEN) {
3320 /* PMP reset requires working host port.
3321 * Can't retry if it's frozen.
3322 */
Tejun Heo071f44b2008-04-07 22:47:22 +09003323 if (sata_pmp_attached(ap))
Tejun Heob06ce3e2007-10-09 15:06:48 +09003324 goto out;
Tejun Heo9b1e2652007-08-06 18:36:24 +09003325 break;
Tejun Heob06ce3e2007-10-09 15:06:48 +09003326 }
Tejun Heo022bdb02006-05-15 20:58:22 +09003327 }
3328
Tejun Heo0a2c0f52008-05-20 02:17:52 +09003329 if (nr_failed_devs)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003330 goto retry;
Tejun Heo022bdb02006-05-15 20:58:22 +09003331
Tejun Heo022bdb02006-05-15 20:58:22 +09003332 out:
Tejun Heo9b1e2652007-08-06 18:36:24 +09003333 if (rc && r_failed_link)
3334 *r_failed_link = link;
Tejun Heo022bdb02006-05-15 20:58:22 +09003335
3336 DPRINTK("EXIT, rc=%d\n", rc);
3337 return rc;
3338}
3339
3340/**
3341 * ata_eh_finish - finish up EH
3342 * @ap: host port to finish EH for
3343 *
3344 * Recovery is complete. Clean up EH states and retry or finish
3345 * failed qcs.
3346 *
3347 * LOCKING:
3348 * None.
3349 */
Tejun Heofb7fd612007-09-23 13:14:12 +09003350void ata_eh_finish(struct ata_port *ap)
Tejun Heo022bdb02006-05-15 20:58:22 +09003351{
3352 int tag;
3353
3354 /* retry or finish qcs */
3355 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
3356 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
3357
3358 if (!(qc->flags & ATA_QCFLAG_FAILED))
3359 continue;
3360
3361 if (qc->err_mask) {
3362 /* FIXME: Once EH migration is complete,
3363 * generate sense data in this function,
3364 * considering both err_mask and tf.
3365 */
Tejun Heo03faab72008-03-27 19:14:24 +09003366 if (qc->flags & ATA_QCFLAG_RETRY)
Tejun Heo022bdb02006-05-15 20:58:22 +09003367 ata_eh_qc_retry(qc);
Tejun Heo03faab72008-03-27 19:14:24 +09003368 else
3369 ata_eh_qc_complete(qc);
Tejun Heo022bdb02006-05-15 20:58:22 +09003370 } else {
3371 if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
3372 ata_eh_qc_complete(qc);
3373 } else {
3374 /* feed zero TF to sense generation */
3375 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
3376 ata_eh_qc_retry(qc);
3377 }
3378 }
3379 }
Tejun Heoda917d62007-09-23 13:14:12 +09003380
3381 /* make sure nr_active_links is zero after EH */
3382 WARN_ON(ap->nr_active_links);
3383 ap->nr_active_links = 0;
Tejun Heo022bdb02006-05-15 20:58:22 +09003384}
3385
3386/**
3387 * ata_do_eh - do standard error handling
3388 * @ap: host port to handle error for
Tejun Heoa1efdab2008-03-25 12:22:50 +09003389 *
Tejun Heof5914a42006-05-31 18:27:48 +09003390 * @prereset: prereset method (can be NULL)
Tejun Heo022bdb02006-05-15 20:58:22 +09003391 * @softreset: softreset method (can be NULL)
3392 * @hardreset: hardreset method (can be NULL)
3393 * @postreset: postreset method (can be NULL)
3394 *
3395 * Perform standard error handling sequence.
3396 *
3397 * LOCKING:
3398 * Kernel thread context (may sleep).
3399 */
Tejun Heof5914a42006-05-31 18:27:48 +09003400void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
3401 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3402 ata_postreset_fn_t postreset)
Tejun Heo022bdb02006-05-15 20:58:22 +09003403{
Tejun Heo9b1e2652007-08-06 18:36:24 +09003404 struct ata_device *dev;
3405 int rc;
3406
3407 ata_eh_autopsy(ap);
3408 ata_eh_report(ap);
3409
3410 rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
3411 NULL);
3412 if (rc) {
Tejun Heo1eca4362008-11-03 20:03:17 +09003413 ata_for_each_dev(dev, &ap->link, ALL)
Tejun Heo9b1e2652007-08-06 18:36:24 +09003414 ata_dev_disable(dev);
3415 }
3416
Tejun Heo022bdb02006-05-15 20:58:22 +09003417 ata_eh_finish(ap);
3418}
Tejun Heo500530f2006-07-03 16:07:27 +09003419
Tejun Heoa1efdab2008-03-25 12:22:50 +09003420/**
3421 * ata_std_error_handler - standard error handler
3422 * @ap: host port to handle error for
3423 *
3424 * Standard error handler
3425 *
3426 * LOCKING:
3427 * Kernel thread context (may sleep).
3428 */
3429void ata_std_error_handler(struct ata_port *ap)
3430{
3431 struct ata_port_operations *ops = ap->ops;
3432 ata_reset_fn_t hardreset = ops->hardreset;
3433
Tejun Heo57c9efd2008-04-07 22:47:19 +09003434 /* ignore built-in hardreset if SCR access is not available */
3435 if (ata_is_builtin_hardreset(hardreset) && !sata_scr_valid(&ap->link))
Tejun Heoa1efdab2008-03-25 12:22:50 +09003436 hardreset = NULL;
3437
3438 ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);
3439}
3440
Tejun Heo6ffa01d2007-03-02 17:32:47 +09003441#ifdef CONFIG_PM
Tejun Heo500530f2006-07-03 16:07:27 +09003442/**
3443 * ata_eh_handle_port_suspend - perform port suspend operation
3444 * @ap: port to suspend
3445 *
3446 * Suspend @ap.
3447 *
3448 * LOCKING:
3449 * Kernel thread context (may sleep).
3450 */
3451static void ata_eh_handle_port_suspend(struct ata_port *ap)
3452{
3453 unsigned long flags;
3454 int rc = 0;
3455
3456 /* are we suspending? */
3457 spin_lock_irqsave(ap->lock, flags);
3458 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
3459 ap->pm_mesg.event == PM_EVENT_ON) {
3460 spin_unlock_irqrestore(ap->lock, flags);
3461 return;
3462 }
3463 spin_unlock_irqrestore(ap->lock, flags);
3464
3465 WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
3466
Tejun Heo64578a32007-05-15 03:28:16 +09003467 /* tell ACPI we're suspending */
3468 rc = ata_acpi_on_suspend(ap);
3469 if (rc)
3470 goto out;
3471
Tejun Heo500530f2006-07-03 16:07:27 +09003472 /* suspend */
3473 ata_eh_freeze_port(ap);
3474
3475 if (ap->ops->port_suspend)
3476 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
3477
Shaohua Libd3adca2007-11-02 09:32:38 +08003478 ata_acpi_set_state(ap, PMSG_SUSPEND);
Tejun Heo64578a32007-05-15 03:28:16 +09003479 out:
Tejun Heo500530f2006-07-03 16:07:27 +09003480 /* report result */
3481 spin_lock_irqsave(ap->lock, flags);
3482
3483 ap->pflags &= ~ATA_PFLAG_PM_PENDING;
3484 if (rc == 0)
3485 ap->pflags |= ATA_PFLAG_SUSPENDED;
Tejun Heo64578a32007-05-15 03:28:16 +09003486 else if (ap->pflags & ATA_PFLAG_FROZEN)
Tejun Heo500530f2006-07-03 16:07:27 +09003487 ata_port_schedule_eh(ap);
3488
3489 if (ap->pm_result) {
3490 *ap->pm_result = rc;
3491 ap->pm_result = NULL;
3492 }
3493
3494 spin_unlock_irqrestore(ap->lock, flags);
3495
3496 return;
3497}
3498
3499/**
3500 * ata_eh_handle_port_resume - perform port resume operation
3501 * @ap: port to resume
3502 *
3503 * Resume @ap.
3504 *
Tejun Heo500530f2006-07-03 16:07:27 +09003505 * LOCKING:
3506 * Kernel thread context (may sleep).
3507 */
3508static void ata_eh_handle_port_resume(struct ata_port *ap)
3509{
Tejun Heo6f9c1ea2009-04-23 09:55:28 +09003510 struct ata_link *link;
3511 struct ata_device *dev;
Tejun Heo500530f2006-07-03 16:07:27 +09003512 unsigned long flags;
Tejun Heo9666f402007-05-04 21:27:47 +02003513 int rc = 0;
Tejun Heo500530f2006-07-03 16:07:27 +09003514
3515 /* are we resuming? */
3516 spin_lock_irqsave(ap->lock, flags);
3517 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
3518 ap->pm_mesg.event != PM_EVENT_ON) {
3519 spin_unlock_irqrestore(ap->lock, flags);
3520 return;
3521 }
3522 spin_unlock_irqrestore(ap->lock, flags);
3523
Tejun Heo9666f402007-05-04 21:27:47 +02003524 WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
Tejun Heo500530f2006-07-03 16:07:27 +09003525
Tejun Heo6f9c1ea2009-04-23 09:55:28 +09003526 /*
3527 * Error timestamps are in jiffies which doesn't run while
3528 * suspended and PHY events during resume isn't too uncommon.
3529 * When the two are combined, it can lead to unnecessary speed
3530 * downs if the machine is suspended and resumed repeatedly.
3531 * Clear error history.
3532 */
3533 ata_for_each_link(link, ap, HOST_FIRST)
3534 ata_for_each_dev(dev, link, ALL)
3535 ata_ering_clear(&dev->ering);
3536
Shaohua Libd3adca2007-11-02 09:32:38 +08003537 ata_acpi_set_state(ap, PMSG_ON);
3538
Tejun Heo500530f2006-07-03 16:07:27 +09003539 if (ap->ops->port_resume)
3540 rc = ap->ops->port_resume(ap);
3541
Tejun Heo67465442007-05-15 03:28:16 +09003542 /* tell ACPI that we're resuming */
3543 ata_acpi_on_resume(ap);
3544
Tejun Heo9666f402007-05-04 21:27:47 +02003545 /* report result */
Tejun Heo500530f2006-07-03 16:07:27 +09003546 spin_lock_irqsave(ap->lock, flags);
3547 ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
3548 if (ap->pm_result) {
3549 *ap->pm_result = rc;
3550 ap->pm_result = NULL;
3551 }
3552 spin_unlock_irqrestore(ap->lock, flags);
3553}
Tejun Heo6ffa01d2007-03-02 17:32:47 +09003554#endif /* CONFIG_PM */