Blame view
drivers/ata/libata-eh.c
99.1 KB
ece1d6361 [PATCH] libata: s... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
/* * libata-eh.c - libata error handling * * Maintained by: Jeff Garzik <jgarzik@pobox.com> * Please ALWAYS copy linux-ide@vger.kernel.org * on emails. * * Copyright 2006 Tejun Heo <htejun@gmail.com> * * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; see the file COPYING. If not, write to * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, * USA. * * * libata documentation is available via 'make {ps|pdf}docs', * as Documentation/DocBook/libata.* * * Hardware documentation available from http://www.t13.org/ and * http://www.sata-io.org/ * */ |
ece1d6361 [PATCH] libata: s... |
34 |
#include <linux/kernel.h> |
242f9dcb8 block: unify requ... |
35 |
#include <linux/blkdev.h> |
2855568b1 [libata] struct p... |
36 |
#include <linux/pci.h> |
ece1d6361 [PATCH] libata: s... |
37 38 39 40 41 |
#include <scsi/scsi.h> #include <scsi/scsi_host.h> #include <scsi/scsi_eh.h> #include <scsi/scsi_device.h> #include <scsi/scsi_cmnd.h> |
6521148c6 libata: add comma... |
42 |
#include <scsi/scsi_dbg.h> |
c6fd28076 Move libata to dr... |
43 |
#include "../scsi/scsi_transport_api.h" |
ece1d6361 [PATCH] libata: s... |
44 45 46 47 |
#include <linux/libata.h> #include "libata.h" |
7d47e8d4d libata: put some ... |
48 |
enum { |
3884f7b0a libata: clean up ... |
49 |
/* speed down verdicts */ |
7d47e8d4d libata: put some ... |
50 51 52 |
ATA_EH_SPDN_NCQ_OFF = (1 << 0), ATA_EH_SPDN_SPEED_DOWN = (1 << 1), ATA_EH_SPDN_FALLBACK_TO_PIO = (1 << 2), |
76326ac1a libata: implement... |
53 |
ATA_EH_SPDN_KEEP_ERRORS = (1 << 3), |
3884f7b0a libata: clean up ... |
54 55 56 |
/* error flags */ ATA_EFLAG_IS_IO = (1 << 0), |
76326ac1a libata: implement... |
57 |
ATA_EFLAG_DUBIOUS_XFER = (1 << 1), |
3884f7b0a libata: clean up ... |
58 59 60 61 62 63 |
/* error categories */ ATA_ECAT_NONE = 0, ATA_ECAT_ATA_BUS = 1, ATA_ECAT_TOUT_HSM = 2, ATA_ECAT_UNK_DEV = 3, |
75f9cafc2 libata: fix off-b... |
64 65 66 67 68 |
ATA_ECAT_DUBIOUS_NONE = 4, ATA_ECAT_DUBIOUS_ATA_BUS = 5, ATA_ECAT_DUBIOUS_TOUT_HSM = 6, ATA_ECAT_DUBIOUS_UNK_DEV = 7, ATA_ECAT_NR = 8, |
7d47e8d4d libata: put some ... |
69 |
|
87fbc5a06 libata: improve E... |
70 |
ATA_EH_CMD_DFL_TIMEOUT = 5000, |
0a2c0f561 libata: improve E... |
71 72 |
/* always put at least this amount of time between resets */ ATA_EH_RESET_COOL_DOWN = 5000, |
341c2c958 libata: consisten... |
73 74 75 76 77 78 79 |
/* Waiting in ->prereset can never be reliable. It's * sometimes nice to wait there but it can't be depended upon; * otherwise, we wouldn't be resetting. Just give it enough * time for most drives to spin up. */ ATA_EH_PRERESET_TIMEOUT = 10000, ATA_EH_FASTDRAIN_INTERVAL = 3000, |
11fc33da8 libata-eh: clear ... |
80 81 |
ATA_EH_UA_TRIES = 5, |
c2c7a89c5 libata: improve p... |
82 83 84 85 |
/* probe speed down parameters, see ata_eh_schedule_probe() */ ATA_EH_PROBE_TRIAL_INTERVAL = 60000, /* 1 min */ ATA_EH_PROBE_TRIALS = 2, |
31daabda1 libata: reimpleme... |
86 87 88 89 90 91 92 93 94 |
}; /* The following table determines how we sequence resets. Each entry * represents timeout for that try. The first try can be soft or * hardreset. All others are hardreset if available. In most cases * the first reset w/ 10sec timeout should succeed. Following entries * are mostly for error handling, hotplug and retarded devices. */ static const unsigned long ata_eh_reset_timeouts[] = { |
341c2c958 libata: consisten... |
95 96 97 98 |
10000, /* most drives spin up by 10sec */ 10000, /* > 99% working drives spin up before 20sec */ 35000, /* give > 30 secs of idleness for retarded devices */ 5000, /* and sweet one last chance */ |
d8af0eb60 libata: use ULONG... |
99 |
ULONG_MAX, /* > 1 min has elapsed, give up */ |
31daabda1 libata: reimpleme... |
100 |
}; |
87fbc5a06 libata: improve E... |
101 102 103 104 105 106 |
static const unsigned long ata_eh_identify_timeouts[] = { 5000, /* covers > 99% of successes and not too boring on failures */ 10000, /* combined time till here is enough even for media access */ 30000, /* for true idiots */ ULONG_MAX, }; |
6013efd88 libata: retry fai... |
107 108 109 110 111 112 |
static const unsigned long ata_eh_flush_timeouts[] = { 15000, /* be generous with flush */ 15000, /* ditto */ 30000, /* and even more generous */ ULONG_MAX, }; |
87fbc5a06 libata: improve E... |
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 |
static const unsigned long ata_eh_other_timeouts[] = { 5000, /* same rationale as identify timeout */ 10000, /* ditto */ /* but no merciful 30sec for other commands, it just isn't worth it */ ULONG_MAX, }; struct ata_eh_cmd_timeout_ent { const u8 *commands; const unsigned long *timeouts; }; /* The following table determines timeouts to use for EH internal * commands. Each table entry is a command class and matches the * commands the entry applies to and the timeout table to use. * * On the retry after a command timed out, the next timeout value from * the table is used. If the table doesn't contain further entries, * the last value is used. * * ehc->cmd_timeout_idx keeps track of which timeout to use per * command class, so if SET_FEATURES times out on the first try, the * next try will use the second timeout value only for that class. */ #define CMDS(cmds...) (const u8 []){ cmds, 0 } static const struct ata_eh_cmd_timeout_ent ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = { { .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI), .timeouts = ata_eh_identify_timeouts, }, { .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT), .timeouts = ata_eh_other_timeouts, }, { .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT), .timeouts = ata_eh_other_timeouts, }, { .commands = CMDS(ATA_CMD_SET_FEATURES), .timeouts = ata_eh_other_timeouts, }, { .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS), .timeouts = ata_eh_other_timeouts, }, |
6013efd88 libata: retry fai... |
150 151 |
{ .commands = CMDS(ATA_CMD_FLUSH, ATA_CMD_FLUSH_EXT), .timeouts = ata_eh_flush_timeouts }, |
87fbc5a06 libata: improve E... |
152 153 |
}; #undef CMDS |
ad9e27624 [PATCH] libata-eh... |
154 |
static void __ata_port_freeze(struct ata_port *ap); |
6ffa01d88 libata: add CONFI... |
155 |
#ifdef CONFIG_PM |
500530f65 [PATCH] libata: r... |
156 157 |
static void ata_eh_handle_port_suspend(struct ata_port *ap); static void ata_eh_handle_port_resume(struct ata_port *ap); |
6ffa01d88 libata: add CONFI... |
158 159 160 161 162 163 |
#else /* CONFIG_PM */ static void ata_eh_handle_port_suspend(struct ata_port *ap) { } static void ata_eh_handle_port_resume(struct ata_port *ap) { } |
6ffa01d88 libata: add CONFI... |
164 |
#endif /* CONFIG_PM */ |
ad9e27624 [PATCH] libata-eh... |
165 |
|
b64bbc39f libata: improve E... |
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 |
static void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, const char *fmt, va_list args) { ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len, ATA_EH_DESC_LEN - ehi->desc_len, fmt, args); } /** * __ata_ehi_push_desc - push error description without adding separator * @ehi: target EHI * @fmt: printf format string * * Format string according to @fmt and append it to @ehi->desc. * * LOCKING: * spin_lock_irqsave(host lock) */ void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...) { va_list args; va_start(args, fmt); __ata_ehi_pushv_desc(ehi, fmt, args); va_end(args); } /** * ata_ehi_push_desc - push error description with separator * @ehi: target EHI * @fmt: printf format string * * Format string according to @fmt and append it to @ehi->desc. * If @ehi->desc is not empty, ", " is added in-between. * * LOCKING: * spin_lock_irqsave(host lock) */ void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...) { va_list args; if (ehi->desc_len) __ata_ehi_push_desc(ehi, ", "); va_start(args, fmt); __ata_ehi_pushv_desc(ehi, fmt, args); va_end(args); } /** * ata_ehi_clear_desc - clean error description * @ehi: target EHI * * Clear @ehi->desc. * * LOCKING: * spin_lock_irqsave(host lock) */ void ata_ehi_clear_desc(struct ata_eh_info *ehi) { ehi->desc[0] = '\0'; ehi->desc_len = 0; } |
cbcdd8759 libata: implement... |
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 |
/** * ata_port_desc - append port description * @ap: target ATA port * @fmt: printf format string * * Format string according to @fmt and append it to port * description. If port description is not empty, " " is added * in-between. This function is to be used while initializing * ata_host. The description is printed on host registration. * * LOCKING: * None. */ void ata_port_desc(struct ata_port *ap, const char *fmt, ...) { va_list args; WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING)); if (ap->link.eh_info.desc_len) __ata_ehi_push_desc(&ap->link.eh_info, " "); va_start(args, fmt); __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args); va_end(args); } #ifdef CONFIG_PCI /** * ata_port_pbar_desc - append PCI BAR description * @ap: target ATA port * @bar: target PCI BAR * @offset: offset into PCI BAR * @name: name of the area * * If @offset is negative, this function formats a string which * contains the name, address, size and type of the BAR and * appends it to the port description. If @offset is zero or * positive, only name and offsetted address is appended. * * LOCKING: * None. */ void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset, const char *name) { struct pci_dev *pdev = to_pci_dev(ap->host->dev); char *type = ""; unsigned long long start, len; if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) type = "m"; else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO) type = "i"; start = (unsigned long long)pci_resource_start(pdev, bar); len = (unsigned long long)pci_resource_len(pdev, bar); if (offset < 0) ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start); else |
e6a73ab1c drivers/ata/libat... |
292 293 |
ata_port_desc(ap, "%s 0x%llx", name, start + (unsigned long long)offset); |
cbcdd8759 libata: implement... |
294 295 296 |
} #endif /* CONFIG_PCI */ |
87fbc5a06 libata: improve E... |
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 |
static int ata_lookup_timeout_table(u8 cmd) { int i; for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) { const u8 *cur; for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++) if (*cur == cmd) return i; } return -1; } /** * ata_internal_cmd_timeout - determine timeout for an internal command * @dev: target device * @cmd: internal command to be issued * * Determine timeout for internal command @cmd for @dev. * * LOCKING: * EH context. * * RETURNS: * Determined timeout. */ unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd) { struct ata_eh_context *ehc = &dev->link->eh_context; int ent = ata_lookup_timeout_table(cmd); int idx; if (ent < 0) return ATA_EH_CMD_DFL_TIMEOUT; idx = ehc->cmd_timeout_idx[dev->devno][ent]; return ata_eh_cmd_timeout_table[ent].timeouts[idx]; } /** * ata_internal_cmd_timed_out - notification for internal command timeout * @dev: target device * @cmd: internal command which timed out * * Notify EH that internal command @cmd for @dev timed out. This * function should be called only for commands whose timeouts are * determined using ata_internal_cmd_timeout(). * * LOCKING: * EH context. */ void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd) { struct ata_eh_context *ehc = &dev->link->eh_context; int ent = ata_lookup_timeout_table(cmd); int idx; if (ent < 0) return; idx = ehc->cmd_timeout_idx[dev->devno][ent]; if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX) ehc->cmd_timeout_idx[dev->devno][ent]++; } |
3884f7b0a libata: clean up ... |
363 |
static void ata_ering_record(struct ata_ering *ering, unsigned int eflags, |
0c247c559 [PATCH] libata-eh... |
364 365 366 367 368 369 370 371 372 373 |
unsigned int err_mask) { struct ata_ering_entry *ent; WARN_ON(!err_mask); ering->cursor++; ering->cursor %= ATA_ERING_SIZE; ent = &ering->ring[ering->cursor]; |
3884f7b0a libata: clean up ... |
374 |
ent->eflags = eflags; |
0c247c559 [PATCH] libata-eh... |
375 376 377 |
ent->err_mask = err_mask; ent->timestamp = get_jiffies_64(); } |
76326ac1a libata: implement... |
378 379 380 381 382 383 384 385 |
static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering) { struct ata_ering_entry *ent = &ering->ring[ering->cursor]; if (ent->err_mask) return ent; return NULL; } |
7d47e8d4d libata: put some ... |
386 |
static void ata_ering_clear(struct ata_ering *ering) |
0c247c559 [PATCH] libata-eh... |
387 |
{ |
7d47e8d4d libata: put some ... |
388 |
memset(ering, 0, sizeof(*ering)); |
0c247c559 [PATCH] libata-eh... |
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 |
} static int ata_ering_map(struct ata_ering *ering, int (*map_fn)(struct ata_ering_entry *, void *), void *arg) { int idx, rc = 0; struct ata_ering_entry *ent; idx = ering->cursor; do { ent = &ering->ring[idx]; if (!ent->err_mask) break; rc = map_fn(ent, arg); if (rc) break; idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE; } while (idx != ering->cursor); return rc; } |
64f65ca6e [PATCH] libata: i... |
411 412 |
static unsigned int ata_eh_dev_action(struct ata_device *dev) { |
9af5c9c97 libata-link: intr... |
413 |
struct ata_eh_context *ehc = &dev->link->eh_context; |
64f65ca6e [PATCH] libata: i... |
414 415 416 |
return ehc->i.action | ehc->i.dev_action[dev->devno]; } |
f58229f80 libata-link: impl... |
417 |
static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev, |
af181c2d7 [PATCH] libata: m... |
418 419 |
struct ata_eh_info *ehi, unsigned int action) { |
f58229f80 libata-link: impl... |
420 |
struct ata_device *tdev; |
af181c2d7 [PATCH] libata: m... |
421 422 423 |
if (!dev) { ehi->action &= ~action; |
1eca4365b libata: beef up i... |
424 |
ata_for_each_dev(tdev, link, ALL) |
f58229f80 libata-link: impl... |
425 |
ehi->dev_action[tdev->devno] &= ~action; |
af181c2d7 [PATCH] libata: m... |
426 427 428 429 430 431 |
} else { /* doesn't make sense for port-wide EH actions */ WARN_ON(!(action & ATA_EH_PERDEV_MASK)); /* break ehi->action into ehi->dev_action */ if (ehi->action & action) { |
1eca4365b libata: beef up i... |
432 |
ata_for_each_dev(tdev, link, ALL) |
f58229f80 libata-link: impl... |
433 434 |
ehi->dev_action[tdev->devno] |= ehi->action & action; |
af181c2d7 [PATCH] libata: m... |
435 436 437 438 439 440 441 |
ehi->action &= ~action; } /* turn off the specified per-dev action */ ehi->dev_action[dev->devno] &= ~action; } } |
ece1d6361 [PATCH] libata: s... |
442 443 444 445 446 447 448 449 450 451 452 |
/** * ata_scsi_timed_out - SCSI layer time out callback * @cmd: timed out SCSI command * * Handles SCSI layer timeout. We race with normal completion of * the qc for @cmd. If the qc is already gone, we lose and let * the scsi command finish (EH_HANDLED). Otherwise, the qc has * timed out and EH should be invoked. Prevent ata_qc_complete() * from finishing it by setting EH_SCHEDULED and return * EH_NOT_HANDLED. * |
ad9e27624 [PATCH] libata-eh... |
453 454 |
* TODO: kill this function once old EH is gone. * |
ece1d6361 [PATCH] libata: s... |
455 456 457 458 459 460 |
* LOCKING: * Called from timer context * * RETURNS: * EH_HANDLED or EH_NOT_HANDLED */ |
242f9dcb8 block: unify requ... |
461 |
enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd) |
ece1d6361 [PATCH] libata: s... |
462 463 |
{ struct Scsi_Host *host = cmd->device->host; |
35bb94b11 libata: Add helpe... |
464 |
struct ata_port *ap = ata_shost_to_port(host); |
ece1d6361 [PATCH] libata: s... |
465 466 |
unsigned long flags; struct ata_queued_cmd *qc; |
242f9dcb8 block: unify requ... |
467 |
enum blk_eh_timer_return ret; |
ece1d6361 [PATCH] libata: s... |
468 469 470 |
DPRINTK("ENTER "); |
ad9e27624 [PATCH] libata-eh... |
471 |
if (ap->ops->error_handler) { |
242f9dcb8 block: unify requ... |
472 |
ret = BLK_EH_NOT_HANDLED; |
ad9e27624 [PATCH] libata-eh... |
473 474 |
goto out; } |
242f9dcb8 block: unify requ... |
475 |
ret = BLK_EH_HANDLED; |
ba6a13083 [libata] Add host... |
476 |
spin_lock_irqsave(ap->lock, flags); |
9af5c9c97 libata-link: intr... |
477 |
qc = ata_qc_from_tag(ap, ap->link.active_tag); |
ece1d6361 [PATCH] libata: s... |
478 479 480 481 |
if (qc) { WARN_ON(qc->scsicmd != cmd); qc->flags |= ATA_QCFLAG_EH_SCHEDULED; qc->err_mask |= AC_ERR_TIMEOUT; |
242f9dcb8 block: unify requ... |
482 |
ret = BLK_EH_NOT_HANDLED; |
ece1d6361 [PATCH] libata: s... |
483 |
} |
ba6a13083 [libata] Add host... |
484 |
spin_unlock_irqrestore(ap->lock, flags); |
ece1d6361 [PATCH] libata: s... |
485 |
|
ad9e27624 [PATCH] libata-eh... |
486 |
out: |
ece1d6361 [PATCH] libata: s... |
487 488 489 490 |
DPRINTK("EXIT, ret=%d ", ret); return ret; } |
ece180d1c libata: perform p... |
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 |
static void ata_eh_unload(struct ata_port *ap) { struct ata_link *link; struct ata_device *dev; unsigned long flags; /* Restore SControl IPM and SPD for the next driver and * disable attached devices. */ ata_for_each_link(link, ap, PMP_FIRST) { sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0); ata_for_each_dev(dev, link, ALL) ata_dev_disable(dev); } /* freeze and set UNLOADED */ spin_lock_irqsave(ap->lock, flags); ata_port_freeze(ap); /* won't be thawed */ ap->pflags &= ~ATA_PFLAG_EH_PENDING; /* clear pending from freeze */ ap->pflags |= ATA_PFLAG_UNLOADED; spin_unlock_irqrestore(ap->lock, flags); } |
ece1d6361 [PATCH] libata: s... |
515 516 517 518 519 520 521 522 523 524 525 526 |
/** * ata_scsi_error - SCSI layer error handler callback * @host: SCSI host on which error occurred * * Handles SCSI-layer-thrown error events. * * LOCKING: * Inherited from SCSI layer (none, can sleep) * * RETURNS: * Zero. */ |
381544bba libata: Fix EH me... |
527 |
void ata_scsi_error(struct Scsi_Host *host) |
ece1d6361 [PATCH] libata: s... |
528 |
{ |
35bb94b11 libata: Add helpe... |
529 |
struct ata_port *ap = ata_shost_to_port(host); |
a1e10f7e6 libata: move EH r... |
530 |
int i; |
ad9e27624 [PATCH] libata-eh... |
531 |
unsigned long flags; |
ece1d6361 [PATCH] libata: s... |
532 533 534 |
DPRINTK("ENTER "); |
c429137a6 libata-sff: port_... |
535 536 |
/* make sure sff pio task is not running */ ata_sff_flush_pio_task(ap); |
ece1d6361 [PATCH] libata: s... |
537 |
|
cca3974e4 libata: Grand ren... |
538 |
/* synchronize with host lock and sort out timeouts */ |
ad9e27624 [PATCH] libata-eh... |
539 540 541 |
/* For new EH, all qcs are finished in one of three ways - * normal completion, error completion, and SCSI timeout. |
c96f1732e [libata] Improve ... |
542 |
* Both completions can race against SCSI timeout. When normal |
ad9e27624 [PATCH] libata-eh... |
543 544 545 546 547 548 549 550 551 552 553 554 |
* completion wins, the qc never reaches EH. When error * completion wins, the qc has ATA_QCFLAG_FAILED set. * * When SCSI timeout wins, things are a bit more complex. * Normal or error completion can occur after the timeout but * before this point. In such cases, both types of * completions are honored. A scmd is determined to have * timed out iff its associated qc is active and not failed. */ if (ap->ops->error_handler) { struct scsi_cmnd *scmd, *tmp; int nr_timedout = 0; |
e30349d27 [PATCH] libata: r... |
555 |
spin_lock_irqsave(ap->lock, flags); |
c96f1732e [libata] Improve ... |
556 557 558 559 560 561 562 563 564 565 566 567 568 |
/* This must occur under the ap->lock as we don't want a polled recovery to race the real interrupt handler The lost_interrupt handler checks for any completed but non-notified command and completes much like an IRQ handler. We then fall into the error recovery code which will treat this as if normal completion won the race */ if (ap->ops->lost_interrupt) ap->ops->lost_interrupt(ap); |
ad9e27624 [PATCH] libata-eh... |
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 |
list_for_each_entry_safe(scmd, tmp, &host->eh_cmd_q, eh_entry) { struct ata_queued_cmd *qc; for (i = 0; i < ATA_MAX_QUEUE; i++) { qc = __ata_qc_from_tag(ap, i); if (qc->flags & ATA_QCFLAG_ACTIVE && qc->scsicmd == scmd) break; } if (i < ATA_MAX_QUEUE) { /* the scmd has an associated qc */ if (!(qc->flags & ATA_QCFLAG_FAILED)) { /* which hasn't failed yet, timeout */ qc->err_mask |= AC_ERR_TIMEOUT; qc->flags |= ATA_QCFLAG_FAILED; nr_timedout++; } } else { /* Normal completion occurred after * SCSI timeout but before this point. * Successfully complete it. */ scmd->retries = scmd->allowed; scsi_eh_finish_cmd(scmd, &ap->eh_done_q); } } /* If we have timed out qcs. They belong to EH from * this point but the state of the controller is * unknown. Freeze the port to make sure the IRQ * handler doesn't diddle with those qcs. This must * be done atomically w.r.t. setting QCFLAG_FAILED. */ if (nr_timedout) __ata_port_freeze(ap); |
e30349d27 [PATCH] libata: r... |
605 |
spin_unlock_irqrestore(ap->lock, flags); |
a1e10f7e6 libata: move EH r... |
606 607 608 |
/* initialize eh_tries */ ap->eh_tries = ATA_EH_MAX_TRIES; |
ad9e27624 [PATCH] libata-eh... |
609 |
} else |
e30349d27 [PATCH] libata: r... |
610 |
spin_unlock_wait(ap->lock); |
c96f1732e [libata] Improve ... |
611 612 613 |
/* If we timed raced normal completion and there is nothing to recover nr_timedout == 0 why exactly are we doing error recovery ? */ |
ad9e27624 [PATCH] libata-eh... |
614 615 616 617 |
repeat: /* invoke error handler */ if (ap->ops->error_handler) { |
cf1b86c8a libata-link: upda... |
618 |
struct ata_link *link; |
5ddf24c5e libata: implement... |
619 620 |
/* kill fast drain timer */ del_timer_sync(&ap->fastdrain_timer); |
500530f65 [PATCH] libata: r... |
621 622 |
/* process port resume request */ ata_eh_handle_port_resume(ap); |
f3e81b19a [PATCH] libata-eh... |
623 |
/* fetch & clear EH info */ |
e30349d27 [PATCH] libata: r... |
624 |
spin_lock_irqsave(ap->lock, flags); |
f3e81b19a [PATCH] libata-eh... |
625 |
|
1eca4365b libata: beef up i... |
626 |
ata_for_each_link(link, ap, HOST_FIRST) { |
00115e0f5 libata: implement... |
627 628 |
struct ata_eh_context *ehc = &link->eh_context; struct ata_device *dev; |
cf1b86c8a libata-link: upda... |
629 630 631 |
memset(&link->eh_context, 0, sizeof(link->eh_context)); link->eh_context.i = link->eh_info; memset(&link->eh_info, 0, sizeof(link->eh_info)); |
00115e0f5 libata: implement... |
632 |
|
1eca4365b libata: beef up i... |
633 |
ata_for_each_dev(dev, link, ENABLED) { |
00115e0f5 libata: implement... |
634 635 636 637 638 639 |
int devno = dev->devno; ehc->saved_xfer_mode[devno] = dev->xfer_mode; if (ata_ncq_enabled(dev)) ehc->saved_ncq_enabled |= 1 << devno; } |
cf1b86c8a libata-link: upda... |
640 |
} |
f3e81b19a [PATCH] libata-eh... |
641 |
|
b51e9e5db [PATCH] libata: a... |
642 643 |
ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS; ap->pflags &= ~ATA_PFLAG_EH_PENDING; |
da917d69d libata-pmp-prep: ... |
644 |
ap->excl_link = NULL; /* don't maintain exclusion over EH */ |
f3e81b19a [PATCH] libata-eh... |
645 |
|
e30349d27 [PATCH] libata: r... |
646 |
spin_unlock_irqrestore(ap->lock, flags); |
ad9e27624 [PATCH] libata-eh... |
647 |
|
500530f65 [PATCH] libata: r... |
648 649 |
/* invoke EH, skip if unloading or suspended */ if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED))) |
720ba1262 [PATCH] libata-hp... |
650 |
ap->ops->error_handler(ap); |
ece180d1c libata: perform p... |
651 652 653 654 655 |
else { /* if unloading, commence suicide */ if ((ap->pflags & ATA_PFLAG_UNLOADING) && !(ap->pflags & ATA_PFLAG_UNLOADED)) ata_eh_unload(ap); |
720ba1262 [PATCH] libata-hp... |
656 |
ata_eh_finish(ap); |
ece180d1c libata: perform p... |
657 |
} |
ad9e27624 [PATCH] libata-eh... |
658 |
|
500530f65 [PATCH] libata: r... |
659 660 |
/* process port suspend request */ ata_eh_handle_port_suspend(ap); |
ad9e27624 [PATCH] libata-eh... |
661 662 663 664 |
/* Exception might have happend after ->error_handler * recovered the port but before this point. Repeat * EH in such case. */ |
e30349d27 [PATCH] libata: r... |
665 |
spin_lock_irqsave(ap->lock, flags); |
ad9e27624 [PATCH] libata-eh... |
666 |
|
b51e9e5db [PATCH] libata: a... |
667 |
if (ap->pflags & ATA_PFLAG_EH_PENDING) { |
a1e10f7e6 libata: move EH r... |
668 |
if (--ap->eh_tries) { |
e30349d27 [PATCH] libata: r... |
669 |
spin_unlock_irqrestore(ap->lock, flags); |
ad9e27624 [PATCH] libata-eh... |
670 671 672 |
goto repeat; } ata_port_printk(ap, KERN_ERR, "EH pending after %d " |
a1e10f7e6 libata: move EH r... |
673 674 |
"tries, giving up ", ATA_EH_MAX_TRIES); |
914616a3c libata: fix infin... |
675 |
ap->pflags &= ~ATA_PFLAG_EH_PENDING; |
ad9e27624 [PATCH] libata-eh... |
676 |
} |
f3e81b19a [PATCH] libata-eh... |
677 |
/* this run is complete, make sure EH info is clear */ |
1eca4365b libata: beef up i... |
678 |
ata_for_each_link(link, ap, HOST_FIRST) |
cf1b86c8a libata-link: upda... |
679 |
memset(&link->eh_info, 0, sizeof(link->eh_info)); |
f3e81b19a [PATCH] libata-eh... |
680 |
|
e30349d27 [PATCH] libata: r... |
681 |
/* Clear host_eh_scheduled while holding ap->lock such |
ad9e27624 [PATCH] libata-eh... |
682 683 684 685 686 |
* that if exception occurs after this point but * before EH completion, SCSI midlayer will * re-initiate EH. */ host->host_eh_scheduled = 0; |
e30349d27 [PATCH] libata: r... |
687 |
spin_unlock_irqrestore(ap->lock, flags); |
ad9e27624 [PATCH] libata-eh... |
688 |
} else { |
9af5c9c97 libata-link: intr... |
689 |
WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL); |
ad9e27624 [PATCH] libata-eh... |
690 691 |
ap->ops->eng_timeout(ap); } |
ece1d6361 [PATCH] libata: s... |
692 |
|
ad9e27624 [PATCH] libata-eh... |
693 |
/* finish or retry handled scmd's and clean up */ |
ece1d6361 [PATCH] libata: s... |
694 695 696 |
WARN_ON(host->host_failed || !list_empty(&host->eh_cmd_q)); scsi_eh_flush_done_q(&ap->eh_done_q); |
ad9e27624 [PATCH] libata-eh... |
697 |
/* clean up */ |
e30349d27 [PATCH] libata: r... |
698 |
spin_lock_irqsave(ap->lock, flags); |
ad9e27624 [PATCH] libata-eh... |
699 |
|
1cdaf534f [PATCH] libata: i... |
700 |
if (ap->pflags & ATA_PFLAG_LOADING) |
b51e9e5db [PATCH] libata: a... |
701 |
ap->pflags &= ~ATA_PFLAG_LOADING; |
1cdaf534f [PATCH] libata: i... |
702 |
else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG) |
ad72cf988 libata: take adva... |
703 |
schedule_delayed_work(&ap->hotplug_task, 0); |
1cdaf534f [PATCH] libata: i... |
704 705 706 707 |
if (ap->pflags & ATA_PFLAG_RECOVERED) ata_port_printk(ap, KERN_INFO, "EH complete "); |
580b21023 [PATCH] libata-hp... |
708 |
|
b51e9e5db [PATCH] libata: a... |
709 |
ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED); |
ad9e27624 [PATCH] libata-eh... |
710 |
|
c6cf9e99d [PATCH] libata: i... |
711 |
/* tell wait_eh that we're done */ |
b51e9e5db [PATCH] libata: a... |
712 |
ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS; |
c6cf9e99d [PATCH] libata: i... |
713 |
wake_up_all(&ap->eh_wait_q); |
e30349d27 [PATCH] libata: r... |
714 |
spin_unlock_irqrestore(ap->lock, flags); |
ad9e27624 [PATCH] libata-eh... |
715 |
|
ece1d6361 [PATCH] libata: s... |
716 717 |
DPRINTK("EXIT "); |
ece1d6361 [PATCH] libata: s... |
718 719 720 |
} /** |
c6cf9e99d [PATCH] libata: i... |
721 722 723 724 725 726 727 728 729 730 731 732 733 734 |
* ata_port_wait_eh - Wait for the currently pending EH to complete * @ap: Port to wait EH for * * Wait until the currently pending EH is complete. * * LOCKING: * Kernel thread context (may sleep). */ void ata_port_wait_eh(struct ata_port *ap) { unsigned long flags; DEFINE_WAIT(wait); retry: |
ba6a13083 [libata] Add host... |
735 |
spin_lock_irqsave(ap->lock, flags); |
c6cf9e99d [PATCH] libata: i... |
736 |
|
b51e9e5db [PATCH] libata: a... |
737 |
while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) { |
c6cf9e99d [PATCH] libata: i... |
738 |
prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE); |
ba6a13083 [libata] Add host... |
739 |
spin_unlock_irqrestore(ap->lock, flags); |
c6cf9e99d [PATCH] libata: i... |
740 |
schedule(); |
ba6a13083 [libata] Add host... |
741 |
spin_lock_irqsave(ap->lock, flags); |
c6cf9e99d [PATCH] libata: i... |
742 |
} |
0a1b622ef [PATCH] libata: a... |
743 |
finish_wait(&ap->eh_wait_q, &wait); |
c6cf9e99d [PATCH] libata: i... |
744 |
|
ba6a13083 [libata] Add host... |
745 |
spin_unlock_irqrestore(ap->lock, flags); |
c6cf9e99d [PATCH] libata: i... |
746 747 |
/* make sure SCSI EH is complete */ |
cca3974e4 libata: Grand ren... |
748 |
if (scsi_host_in_recovery(ap->scsi_host)) { |
c6cf9e99d [PATCH] libata: i... |
749 750 751 752 |
msleep(10); goto retry; } } |
5ddf24c5e libata: implement... |
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 |
static int ata_eh_nr_in_flight(struct ata_port *ap) { unsigned int tag; int nr = 0; /* count only non-internal commands */ for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) if (ata_qc_from_tag(ap, tag)) nr++; return nr; } void ata_eh_fastdrain_timerfn(unsigned long arg) { struct ata_port *ap = (void *)arg; unsigned long flags; int cnt; spin_lock_irqsave(ap->lock, flags); cnt = ata_eh_nr_in_flight(ap); /* are we done? */ if (!cnt) goto out_unlock; if (cnt == ap->fastdrain_cnt) { unsigned int tag; /* No progress during the last interval, tag all * in-flight qcs as timed out and freeze the port. */ for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) { struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag); if (qc) qc->err_mask |= AC_ERR_TIMEOUT; } ata_port_freeze(ap); } else { /* some qcs have finished, give it another chance */ ap->fastdrain_cnt = cnt; ap->fastdrain_timer.expires = |
341c2c958 libata: consisten... |
797 |
ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL); |
5ddf24c5e libata: implement... |
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 |
add_timer(&ap->fastdrain_timer); } out_unlock: spin_unlock_irqrestore(ap->lock, flags); } /** * ata_eh_set_pending - set ATA_PFLAG_EH_PENDING and activate fast drain * @ap: target ATA port * @fastdrain: activate fast drain * * Set ATA_PFLAG_EH_PENDING and activate fast drain if @fastdrain * is non-zero and EH wasn't pending before. Fast drain ensures * that EH kicks in in timely manner. * * LOCKING: * spin_lock_irqsave(host lock) */ static void ata_eh_set_pending(struct ata_port *ap, int fastdrain) { int cnt; /* already scheduled? */ if (ap->pflags & ATA_PFLAG_EH_PENDING) return; ap->pflags |= ATA_PFLAG_EH_PENDING; if (!fastdrain) return; /* do we have in-flight qcs? */ cnt = ata_eh_nr_in_flight(ap); if (!cnt) return; /* activate fast drain */ ap->fastdrain_cnt = cnt; |
341c2c958 libata: consisten... |
837 838 |
ap->fastdrain_timer.expires = ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL); |
5ddf24c5e libata: implement... |
839 840 |
add_timer(&ap->fastdrain_timer); } |
f686bcb80 [PATCH] libata-eh... |
841 842 843 844 845 846 847 848 |
/** * ata_qc_schedule_eh - schedule qc for error handling * @qc: command to schedule error handling for * * Schedule error handling for @qc. EH will kick in as soon as * other commands are drained. * * LOCKING: |
cca3974e4 libata: Grand ren... |
849 |
* spin_lock_irqsave(host lock) |
f686bcb80 [PATCH] libata-eh... |
850 851 852 853 |
*/ void ata_qc_schedule_eh(struct ata_queued_cmd *qc) { struct ata_port *ap = qc->ap; |
fa41efdae libata: fix locki... |
854 855 |
struct request_queue *q = qc->scsicmd->device->request_queue; unsigned long flags; |
f686bcb80 [PATCH] libata-eh... |
856 857 858 859 |
WARN_ON(!ap->ops->error_handler); qc->flags |= ATA_QCFLAG_FAILED; |
5ddf24c5e libata: implement... |
860 |
ata_eh_set_pending(ap, 1); |
f686bcb80 [PATCH] libata-eh... |
861 862 863 864 865 866 |
/* The following will fail if timeout has already expired. * ata_scsi_error() takes care of such scmds on EH entry. * Note that ATA_QCFLAG_FAILED is unconditionally set after * this function completes. */ |
fa41efdae libata: fix locki... |
867 |
spin_lock_irqsave(q->queue_lock, flags); |
242f9dcb8 block: unify requ... |
868 |
blk_abort_request(qc->scsicmd->request); |
fa41efdae libata: fix locki... |
869 |
spin_unlock_irqrestore(q->queue_lock, flags); |
f686bcb80 [PATCH] libata-eh... |
870 |
} |
7b70fc039 [PATCH] libata-eh... |
871 872 873 874 875 876 877 878 |
/** * ata_port_schedule_eh - schedule error handling without a qc * @ap: ATA port to schedule EH for * * Schedule error handling for @ap. EH will kick in as soon as * all commands are drained. * * LOCKING: |
cca3974e4 libata: Grand ren... |
879 |
* spin_lock_irqsave(host lock) |
7b70fc039 [PATCH] libata-eh... |
880 881 882 883 |
*/ void ata_port_schedule_eh(struct ata_port *ap) { WARN_ON(!ap->ops->error_handler); |
f4d6d0046 libata: ignore EH... |
884 885 |
if (ap->pflags & ATA_PFLAG_INITIALIZING) return; |
5ddf24c5e libata: implement... |
886 |
ata_eh_set_pending(ap, 1); |
cca3974e4 libata: Grand ren... |
887 |
scsi_schedule_eh(ap->scsi_host); |
7b70fc039 [PATCH] libata-eh... |
888 889 890 891 |
DPRINTK("port EH scheduled "); } |
dbd826168 libata-link: impl... |
892 |
static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link) |
7b70fc039 [PATCH] libata-eh... |
893 894 895 896 |
{ int tag, nr_aborted = 0; WARN_ON(!ap->ops->error_handler); |
5ddf24c5e libata: implement... |
897 898 |
/* we're gonna abort all commands, no need for fast drain */ ata_eh_set_pending(ap, 0); |
7b70fc039 [PATCH] libata-eh... |
899 900 |
for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag); |
dbd826168 libata-link: impl... |
901 |
if (qc && (!link || qc->dev->link == link)) { |
7b70fc039 [PATCH] libata-eh... |
902 903 904 905 906 907 908 909 910 911 912 |
qc->flags |= ATA_QCFLAG_FAILED; ata_qc_complete(qc); nr_aborted++; } } if (!nr_aborted) ata_port_schedule_eh(ap); return nr_aborted; } |
e31804994 [PATCH] libata-eh... |
913 |
/** |
dbd826168 libata-link: impl... |
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 |
* ata_link_abort - abort all qc's on the link * @link: ATA link to abort qc's for * * Abort all active qc's active on @link and schedule EH. * * LOCKING: * spin_lock_irqsave(host lock) * * RETURNS: * Number of aborted qc's. */ int ata_link_abort(struct ata_link *link) { return ata_do_link_abort(link->ap, link); } /** * ata_port_abort - abort all qc's on the port * @ap: ATA port to abort qc's for * * Abort all active qc's of @ap and schedule EH. * * LOCKING: * spin_lock_irqsave(host_set lock) * * RETURNS: * Number of aborted qc's. */ int ata_port_abort(struct ata_port *ap) { return ata_do_link_abort(ap, NULL); } /** |
e31804994 [PATCH] libata-eh... |
948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 |
* __ata_port_freeze - freeze port * @ap: ATA port to freeze * * This function is called when HSM violation or some other * condition disrupts normal operation of the port. Frozen port * is not allowed to perform any operation until the port is * thawed, which usually follows a successful reset. * * ap->ops->freeze() callback can be used for freezing the port * hardware-wise (e.g. mask interrupt and stop DMA engine). If a * port cannot be frozen hardware-wise, the interrupt handler * must ack and clear interrupts unconditionally while the port * is frozen. * * LOCKING: |
cca3974e4 libata: Grand ren... |
963 |
* spin_lock_irqsave(host lock) |
e31804994 [PATCH] libata-eh... |
964 965 966 967 968 969 970 |
*/ static void __ata_port_freeze(struct ata_port *ap) { WARN_ON(!ap->ops->error_handler); if (ap->ops->freeze) ap->ops->freeze(ap); |
b51e9e5db [PATCH] libata: a... |
971 |
ap->pflags |= ATA_PFLAG_FROZEN; |
e31804994 [PATCH] libata-eh... |
972 |
|
44877b4e2 libata: s/ap->id/... |
973 974 |
DPRINTK("ata%u port frozen ", ap->print_id); |
e31804994 [PATCH] libata-eh... |
975 976 977 978 979 980 |
} /** * ata_port_freeze - abort & freeze port * @ap: ATA port to freeze * |
54c38444f [libata] EH: free... |
981 982 983 |
* Abort and freeze @ap. The freeze operation must be called * first, because some hardware requires special operations * before the taskfile registers are accessible. |
e31804994 [PATCH] libata-eh... |
984 985 |
* * LOCKING: |
cca3974e4 libata: Grand ren... |
986 |
* spin_lock_irqsave(host lock) |
e31804994 [PATCH] libata-eh... |
987 988 989 990 991 992 993 994 995 |
* * RETURNS: * Number of aborted commands. */ int ata_port_freeze(struct ata_port *ap) { int nr_aborted; WARN_ON(!ap->ops->error_handler); |
e31804994 [PATCH] libata-eh... |
996 |
__ata_port_freeze(ap); |
54c38444f [libata] EH: free... |
997 |
nr_aborted = ata_port_abort(ap); |
e31804994 [PATCH] libata-eh... |
998 999 1000 1001 1002 |
return nr_aborted; } /** |
7d77b2470 libata-pmp-prep: ... |
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 |
* sata_async_notification - SATA async notification handler * @ap: ATA port where async notification is received * * Handler to be called when async notification via SDB FIS is * received. This function schedules EH if necessary. * * LOCKING: * spin_lock_irqsave(host lock) * * RETURNS: * 1 if EH is scheduled, 0 otherwise. */ int sata_async_notification(struct ata_port *ap) { u32 sntf; int rc; if (!(ap->flags & ATA_FLAG_AN)) return 0; rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf); if (rc == 0) sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf); |
071f44b1d libata: implement... |
1026 |
if (!sata_pmp_attached(ap) || rc) { |
7d77b2470 libata-pmp-prep: ... |
1027 |
/* PMP is not attached or SNTF is not available */ |
071f44b1d libata: implement... |
1028 |
if (!sata_pmp_attached(ap)) { |
7d77b2470 libata-pmp-prep: ... |
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 |
/* PMP is not attached. Check whether ATAPI * AN is configured. If so, notify media * change. */ struct ata_device *dev = ap->link.device; if ((dev->class == ATA_DEV_ATAPI) && (dev->flags & ATA_DFLAG_AN)) ata_scsi_media_change_notify(dev); return 0; } else { /* PMP is attached but SNTF is not available. * ATAPI async media change notification is * not used. The PMP must be reporting PHY * status change, schedule EH. */ ata_port_schedule_eh(ap); return 1; } } else { /* PMP is attached and SNTF is available */ struct ata_link *link; /* check and notify ATAPI AN */ |
1eca4365b libata: beef up i... |
1053 |
ata_for_each_link(link, ap, EDGE) { |
7d77b2470 libata-pmp-prep: ... |
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 |
if (!(sntf & (1 << link->pmp))) continue; if ((link->device->class == ATA_DEV_ATAPI) && (link->device->flags & ATA_DFLAG_AN)) ata_scsi_media_change_notify(link->device); } /* If PMP is reporting that PHY status of some * downstream ports has changed, schedule EH. */ if (sntf & (1 << SATA_PMP_CTRL_PORT)) { ata_port_schedule_eh(ap); return 1; } return 0; } } /** |
e31804994 [PATCH] libata-eh... |
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 |
* ata_eh_freeze_port - EH helper to freeze port * @ap: ATA port to freeze * * Freeze @ap. * * LOCKING: * None. */ void ata_eh_freeze_port(struct ata_port *ap) { unsigned long flags; if (!ap->ops->error_handler) return; |
ba6a13083 [libata] Add host... |
1089 |
spin_lock_irqsave(ap->lock, flags); |
e31804994 [PATCH] libata-eh... |
1090 |
__ata_port_freeze(ap); |
ba6a13083 [libata] Add host... |
1091 |
spin_unlock_irqrestore(ap->lock, flags); |
e31804994 [PATCH] libata-eh... |
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 |
} /** * ata_port_thaw_port - EH helper to thaw port * @ap: ATA port to thaw * * Thaw frozen port @ap. * * LOCKING: * None. */ void ata_eh_thaw_port(struct ata_port *ap) { unsigned long flags; if (!ap->ops->error_handler) return; |
ba6a13083 [libata] Add host... |
1109 |
spin_lock_irqsave(ap->lock, flags); |
e31804994 [PATCH] libata-eh... |
1110 |
|
b51e9e5db [PATCH] libata: a... |
1111 |
ap->pflags &= ~ATA_PFLAG_FROZEN; |
e31804994 [PATCH] libata-eh... |
1112 1113 1114 |
if (ap->ops->thaw) ap->ops->thaw(ap); |
ba6a13083 [libata] Add host... |
1115 |
spin_unlock_irqrestore(ap->lock, flags); |
e31804994 [PATCH] libata-eh... |
1116 |
|
44877b4e2 libata: s/ap->id/... |
1117 1118 |
DPRINTK("ata%u port thawed ", ap->print_id); |
e31804994 [PATCH] libata-eh... |
1119 |
} |
ece1d6361 [PATCH] libata: s... |
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 |
static void ata_eh_scsidone(struct scsi_cmnd *scmd) { /* nada */ } static void __ata_eh_qc_complete(struct ata_queued_cmd *qc) { struct ata_port *ap = qc->ap; struct scsi_cmnd *scmd = qc->scsicmd; unsigned long flags; |
ba6a13083 [libata] Add host... |
1130 |
spin_lock_irqsave(ap->lock, flags); |
ece1d6361 [PATCH] libata: s... |
1131 1132 1133 |
qc->scsidone = ata_eh_scsidone; __ata_qc_complete(qc); WARN_ON(ata_tag_valid(qc->tag)); |
ba6a13083 [libata] Add host... |
1134 |
spin_unlock_irqrestore(ap->lock, flags); |
ece1d6361 [PATCH] libata: s... |
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 |
scsi_eh_finish_cmd(scmd, &ap->eh_done_q); } /** * ata_eh_qc_complete - Complete an active ATA command from EH * @qc: Command to complete * * Indicate to the mid and upper layers that an ATA command has * completed. To be used from EH. */ void ata_eh_qc_complete(struct ata_queued_cmd *qc) { struct scsi_cmnd *scmd = qc->scsicmd; scmd->retries = scmd->allowed; __ata_eh_qc_complete(qc); } /** * ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH * @qc: Command to retry * * Indicate to the mid and upper layers that an ATA command * should be retried. To be used from EH. * * SCSI midlayer limits the number of retries to scmd->allowed. * scmd->retries is decremented for commands which get retried * due to unrelated failures (qc->err_mask is zero). */ void ata_eh_qc_retry(struct ata_queued_cmd *qc) { struct scsi_cmnd *scmd = qc->scsicmd; if (!qc->err_mask && scmd->retries) scmd->retries--; __ata_eh_qc_complete(qc); } |
022bdb075 [PATCH] libata-eh... |
1171 1172 |
/** |
678afac67 libata: move ata_... |
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 |
* ata_dev_disable - disable ATA device * @dev: ATA device to disable * * Disable @dev. * * Locking: * EH context. */ void ata_dev_disable(struct ata_device *dev) { if (!ata_dev_enabled(dev)) return; if (ata_msg_drv(dev->link->ap)) ata_dev_printk(dev, KERN_WARNING, "disabled "); ata_acpi_on_disable(dev); ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET); dev->class++; |
99cf610aa libata: clear dev... |
1192 1193 1194 1195 1196 |
/* From now till the next successful probe, ering is used to * track probe failures. Clear accumulated device error info. */ ata_ering_clear(&dev->ering); |
678afac67 libata: move ata_... |
1197 1198 1199 |
} /** |
0ea035a3d [PATCH] libata-hp... |
1200 1201 1202 1203 1204 1205 1206 1207 |
* ata_eh_detach_dev - detach ATA device * @dev: ATA device to detach * * Detach @dev. * * LOCKING: * None. */ |
fb7fd6145 libata-pmp-prep: ... |
1208 |
void ata_eh_detach_dev(struct ata_device *dev) |
0ea035a3d [PATCH] libata-hp... |
1209 |
{ |
f58229f80 libata-link: impl... |
1210 1211 |
struct ata_link *link = dev->link; struct ata_port *ap = link->ap; |
90484ebfc libata: clear sav... |
1212 |
struct ata_eh_context *ehc = &link->eh_context; |
0ea035a3d [PATCH] libata-hp... |
1213 1214 1215 |
unsigned long flags; ata_dev_disable(dev); |
ba6a13083 [libata] Add host... |
1216 |
spin_lock_irqsave(ap->lock, flags); |
0ea035a3d [PATCH] libata-hp... |
1217 1218 1219 1220 1221 |
dev->flags &= ~ATA_DFLAG_DETACH; if (ata_scsi_offline_dev(dev)) { dev->flags |= ATA_DFLAG_DETACHED; |
b51e9e5db [PATCH] libata: a... |
1222 |
ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG; |
0ea035a3d [PATCH] libata-hp... |
1223 |
} |
90484ebfc libata: clear sav... |
1224 |
/* clear per-dev EH info */ |
f58229f80 libata-link: impl... |
1225 1226 |
ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK); ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK); |
90484ebfc libata: clear sav... |
1227 1228 |
ehc->saved_xfer_mode[dev->devno] = 0; ehc->saved_ncq_enabled &= ~(1 << dev->devno); |
beb07c1a5 [PATCH] libata: c... |
1229 |
|
ba6a13083 [libata] Add host... |
1230 |
spin_unlock_irqrestore(ap->lock, flags); |
0ea035a3d [PATCH] libata-hp... |
1231 1232 1233 |
} /** |
022bdb075 [PATCH] libata-eh... |
1234 |
* ata_eh_about_to_do - about to perform eh_action |
955e57dfd libata-link: link... |
1235 |
* @link: target ATA link |
47005f255 [PATCH] libata: i... |
1236 |
* @dev: target ATA dev for per-dev action (can be NULL) |
022bdb075 [PATCH] libata-eh... |
1237 1238 1239 |
* @action: action about to be performed * * Called just before performing EH actions to clear related bits |
955e57dfd libata-link: link... |
1240 1241 |
* in @link->eh_info such that eh actions are not unnecessarily * repeated. |
022bdb075 [PATCH] libata-eh... |
1242 1243 1244 1245 |
* * LOCKING: * None. */ |
fb7fd6145 libata-pmp-prep: ... |
1246 1247 |
void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev, unsigned int action) |
022bdb075 [PATCH] libata-eh... |
1248 |
{ |
955e57dfd libata-link: link... |
1249 1250 1251 |
struct ata_port *ap = link->ap; struct ata_eh_info *ehi = &link->eh_info; struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
1252 |
unsigned long flags; |
ba6a13083 [libata] Add host... |
1253 |
spin_lock_irqsave(ap->lock, flags); |
1cdaf534f [PATCH] libata: i... |
1254 |
|
955e57dfd libata-link: link... |
1255 |
ata_eh_clear_action(link, dev, ehi, action); |
1cdaf534f [PATCH] libata: i... |
1256 |
|
a568d1d2e libata-eh: fix sl... |
1257 1258 1259 1260 |
/* About to take EH action, set RECOVERED. Ignore actions on * slave links as master will do them again. */ if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link) |
1cdaf534f [PATCH] libata: i... |
1261 |
ap->pflags |= ATA_PFLAG_RECOVERED; |
ba6a13083 [libata] Add host... |
1262 |
spin_unlock_irqrestore(ap->lock, flags); |
022bdb075 [PATCH] libata-eh... |
1263 1264 1265 |
} /** |
47005f255 [PATCH] libata: i... |
1266 |
* ata_eh_done - EH action complete |
955e57dfd libata-link: link... |
1267 |
* @ap: target ATA port |
47005f255 [PATCH] libata: i... |
1268 1269 1270 1271 |
* @dev: target ATA dev for per-dev action (can be NULL) * @action: action just completed * * Called right after performing EH actions to clear related bits |
955e57dfd libata-link: link... |
1272 |
* in @link->eh_context. |
47005f255 [PATCH] libata: i... |
1273 1274 1275 1276 |
* * LOCKING: * None. */ |
fb7fd6145 libata-pmp-prep: ... |
1277 1278 |
void ata_eh_done(struct ata_link *link, struct ata_device *dev, unsigned int action) |
47005f255 [PATCH] libata: i... |
1279 |
{ |
955e57dfd libata-link: link... |
1280 |
struct ata_eh_context *ehc = &link->eh_context; |
9af5c9c97 libata-link: intr... |
1281 |
|
955e57dfd libata-link: link... |
1282 |
ata_eh_clear_action(link, dev, &ehc->i, action); |
47005f255 [PATCH] libata: i... |
1283 1284 1285 |
} /** |
022bdb075 [PATCH] libata-eh... |
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 |
* ata_err_string - convert err_mask to descriptive string * @err_mask: error mask to convert to string * * Convert @err_mask to descriptive string. Errors are * prioritized according to severity and only the most severe * error is reported. * * LOCKING: * None. * * RETURNS: * Descriptive string for @err_mask */ |
2dcb407e6 [libata] checkpat... |
1299 |
static const char *ata_err_string(unsigned int err_mask) |
022bdb075 [PATCH] libata-eh... |
1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 |
{ if (err_mask & AC_ERR_HOST_BUS) return "host bus error"; if (err_mask & AC_ERR_ATA_BUS) return "ATA bus error"; if (err_mask & AC_ERR_TIMEOUT) return "timeout"; if (err_mask & AC_ERR_HSM) return "HSM violation"; if (err_mask & AC_ERR_SYSTEM) return "internal error"; if (err_mask & AC_ERR_MEDIA) return "media error"; if (err_mask & AC_ERR_INVALID) return "invalid argument"; if (err_mask & AC_ERR_DEV) return "device error"; return "unknown error"; } /** |
e8ee84518 [PATCH] libata-nc... |
1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 |
* ata_read_log_page - read a specific log page * @dev: target device * @page: page to read * @buf: buffer to store read page * @sectors: number of sectors to read * * Read log page using READ_LOG_EXT command. * * LOCKING: * Kernel thread context (may sleep). * * RETURNS: * 0 on success, AC_ERR_* mask otherwise. */ static unsigned int ata_read_log_page(struct ata_device *dev, u8 page, void *buf, unsigned int sectors) { struct ata_taskfile tf; unsigned int err_mask; DPRINTK("read log page - page %d ", page); ata_tf_init(dev, &tf); tf.command = ATA_CMD_READ_LOG_EXT; tf.lbal = page; tf.nsect = sectors; tf.hob_nsect = sectors >> 8; tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE; tf.protocol = ATA_PROT_PIO; err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE, |
2b789108f libata: add @time... |
1353 |
buf, sectors * ATA_SECT_SIZE, 0); |
e8ee84518 [PATCH] libata-nc... |
1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 |
DPRINTK("EXIT, err_mask=%x ", err_mask); return err_mask; } /** * ata_eh_read_log_10h - Read log page 10h for NCQ error details * @dev: Device to read log page 10h from * @tag: Resulting tag of the failed command * @tf: Resulting taskfile registers of the failed command * * Read log page 10h to obtain NCQ error details and clear error * condition. * * LOCKING: * Kernel thread context (may sleep). * * RETURNS: * 0 on success, -errno otherwise. */ static int ata_eh_read_log_10h(struct ata_device *dev, int *tag, struct ata_taskfile *tf) { |
9af5c9c97 libata-link: intr... |
1378 |
u8 *buf = dev->link->ap->sector_buf; |
e8ee84518 [PATCH] libata-nc... |
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 |
unsigned int err_mask; u8 csum; int i; err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1); if (err_mask) return -EIO; csum = 0; for (i = 0; i < ATA_SECT_SIZE; i++) csum += buf[i]; if (csum) ata_dev_printk(dev, KERN_WARNING, "invalid checksum 0x%x on log page 10h ", csum); if (buf[0] & 0x80) return -ENOENT; *tag = buf[0] & 0x1f; tf->command = buf[2]; tf->feature = buf[3]; tf->lbal = buf[4]; tf->lbam = buf[5]; tf->lbah = buf[6]; tf->device = buf[7]; tf->hob_lbal = buf[8]; tf->hob_lbam = buf[9]; tf->hob_lbah = buf[10]; tf->nsect = buf[12]; tf->hob_nsect = buf[13]; return 0; } /** |
11fc33da8 libata-eh: clear ... |
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 |
* atapi_eh_tur - perform ATAPI TEST_UNIT_READY * @dev: target ATAPI device * @r_sense_key: out parameter for sense_key * * Perform ATAPI TEST_UNIT_READY. * * LOCKING: * EH context (may sleep). * * RETURNS: * 0 on success, AC_ERR_* mask on failure. */ static unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key) { u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 }; struct ata_taskfile tf; unsigned int err_mask; ata_tf_init(dev, &tf); tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; tf.command = ATA_CMD_PACKET; tf.protocol = ATAPI_PROT_NODATA; err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0); if (err_mask == AC_ERR_DEV) *r_sense_key = tf.feature >> 4; return err_mask; } /** |
022bdb075 [PATCH] libata-eh... |
1447 1448 1449 |
* atapi_eh_request_sense - perform ATAPI REQUEST_SENSE * @dev: device to perform REQUEST_SENSE to * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long) |
3eabddb8e libata-eh: update... |
1450 |
* @dfl_sense_key: default sense key to use |
022bdb075 [PATCH] libata-eh... |
1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 |
* * Perform ATAPI REQUEST_SENSE after the device reported CHECK * SENSE. This function is EH helper. * * LOCKING: * Kernel thread context (may sleep). * * RETURNS: * 0 on success, AC_ERR_* mask on failure */ |
3eabddb8e libata-eh: update... |
1461 1462 |
static unsigned int atapi_eh_request_sense(struct ata_device *dev, u8 *sense_buf, u8 dfl_sense_key) |
022bdb075 [PATCH] libata-eh... |
1463 |
{ |
3eabddb8e libata-eh: update... |
1464 1465 |
u8 cdb[ATAPI_CDB_LEN] = { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 }; |
9af5c9c97 libata-link: intr... |
1466 |
struct ata_port *ap = dev->link->ap; |
022bdb075 [PATCH] libata-eh... |
1467 |
struct ata_taskfile tf; |
022bdb075 [PATCH] libata-eh... |
1468 1469 1470 |
DPRINTK("ATAPI request sense "); |
022bdb075 [PATCH] libata-eh... |
1471 1472 |
/* FIXME: is this needed? */ memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE); |
56287768e libata: Clear tf ... |
1473 1474 1475 |
/* initialize sense_buf with the error register, * for the case where they are -not- overwritten */ |
022bdb075 [PATCH] libata-eh... |
1476 |
sense_buf[0] = 0x70; |
3eabddb8e libata-eh: update... |
1477 |
sense_buf[2] = dfl_sense_key; |
56287768e libata: Clear tf ... |
1478 |
|
a617c09f6 libata: Trim trai... |
1479 |
/* some devices time out if garbage left in tf */ |
56287768e libata: Clear tf ... |
1480 |
ata_tf_init(dev, &tf); |
022bdb075 [PATCH] libata-eh... |
1481 |
|
022bdb075 [PATCH] libata-eh... |
1482 1483 1484 1485 1486 |
tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; tf.command = ATA_CMD_PACKET; /* is it pointless to prefer PIO for "safety reasons"? */ if (ap->flags & ATA_FLAG_PIO_DMA) { |
0dc36888d libata: rename AT... |
1487 |
tf.protocol = ATAPI_PROT_DMA; |
022bdb075 [PATCH] libata-eh... |
1488 1489 |
tf.feature |= ATAPI_PKT_DMA; } else { |
0dc36888d libata: rename AT... |
1490 |
tf.protocol = ATAPI_PROT_PIO; |
f2dfc1a12 libata: update at... |
1491 1492 |
tf.lbam = SCSI_SENSE_BUFFERSIZE; tf.lbah = 0; |
022bdb075 [PATCH] libata-eh... |
1493 1494 1495 |
} return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE, |
2b789108f libata: add @time... |
1496 |
sense_buf, SCSI_SENSE_BUFFERSIZE, 0); |
022bdb075 [PATCH] libata-eh... |
1497 1498 1499 1500 |
} /** * ata_eh_analyze_serror - analyze SError for a failed port |
0260731f0 libata-link: link... |
1501 |
* @link: ATA link to analyze SError for |
022bdb075 [PATCH] libata-eh... |
1502 1503 1504 1505 1506 1507 1508 |
* * Analyze SError if available and further determine cause of * failure. * * LOCKING: * None. */ |
0260731f0 libata-link: link... |
1509 |
static void ata_eh_analyze_serror(struct ata_link *link) |
022bdb075 [PATCH] libata-eh... |
1510 |
{ |
0260731f0 libata-link: link... |
1511 |
struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
1512 1513 |
u32 serror = ehc->i.serror; unsigned int err_mask = 0, action = 0; |
f9df58cb2 libata-pmp-prep: ... |
1514 |
u32 hotplug_mask; |
022bdb075 [PATCH] libata-eh... |
1515 |
|
e0614db2a libata: ignore re... |
1516 |
if (serror & (SERR_PERSISTENT | SERR_DATA)) { |
022bdb075 [PATCH] libata-eh... |
1517 |
err_mask |= AC_ERR_ATA_BUS; |
cf4806265 libata: prefer ha... |
1518 |
action |= ATA_EH_RESET; |
022bdb075 [PATCH] libata-eh... |
1519 1520 1521 |
} if (serror & SERR_PROTOCOL) { err_mask |= AC_ERR_HSM; |
cf4806265 libata: prefer ha... |
1522 |
action |= ATA_EH_RESET; |
022bdb075 [PATCH] libata-eh... |
1523 1524 1525 |
} if (serror & SERR_INTERNAL) { err_mask |= AC_ERR_SYSTEM; |
cf4806265 libata: prefer ha... |
1526 |
action |= ATA_EH_RESET; |
022bdb075 [PATCH] libata-eh... |
1527 |
} |
f9df58cb2 libata-pmp-prep: ... |
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 |
/* Determine whether a hotplug event has occurred. Both * SError.N/X are considered hotplug events for enabled or * host links. For disabled PMP links, only N bit is * considered as X bit is left at 1 for link plugging. */ hotplug_mask = 0; if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link)) hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG; else hotplug_mask = SERR_PHYRDY_CHG; if (serror & hotplug_mask) |
084fe639b [PATCH] libata-hp... |
1542 |
ata_ehi_hotplugged(&ehc->i); |
022bdb075 [PATCH] libata-eh... |
1543 1544 1545 1546 1547 1548 |
ehc->i.err_mask |= err_mask; ehc->i.action |= action; } /** |
e8ee84518 [PATCH] libata-nc... |
1549 |
* ata_eh_analyze_ncq_error - analyze NCQ error |
0260731f0 libata-link: link... |
1550 |
* @link: ATA link to analyze NCQ error for |
e8ee84518 [PATCH] libata-nc... |
1551 1552 1553 1554 1555 1556 1557 1558 1559 |
* * Read log page 10h, determine the offending qc and acquire * error status TF. For NCQ device errors, all LLDDs have to do * is setting AC_ERR_DEV in ehi->err_mask. This function takes * care of the rest. * * LOCKING: * Kernel thread context (may sleep). */ |
10acf3b0d libata: export at... |
1560 |
void ata_eh_analyze_ncq_error(struct ata_link *link) |
e8ee84518 [PATCH] libata-nc... |
1561 |
{ |
0260731f0 libata-link: link... |
1562 1563 1564 |
struct ata_port *ap = link->ap; struct ata_eh_context *ehc = &link->eh_context; struct ata_device *dev = link->device; |
e8ee84518 [PATCH] libata-nc... |
1565 1566 1567 1568 1569 |
struct ata_queued_cmd *qc; struct ata_taskfile tf; int tag, rc; /* if frozen, we can't do much */ |
b51e9e5db [PATCH] libata: a... |
1570 |
if (ap->pflags & ATA_PFLAG_FROZEN) |
e8ee84518 [PATCH] libata-nc... |
1571 1572 1573 |
return; /* is it NCQ device error? */ |
0260731f0 libata-link: link... |
1574 |
if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV)) |
e8ee84518 [PATCH] libata-nc... |
1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 |
return; /* has LLDD analyzed already? */ for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { qc = __ata_qc_from_tag(ap, tag); if (!(qc->flags & ATA_QCFLAG_FAILED)) continue; if (qc->err_mask) return; } /* okay, this error is ours */ |
a09bf4cd5 libata: ensure NC... |
1589 |
memset(&tf, 0, sizeof(tf)); |
e8ee84518 [PATCH] libata-nc... |
1590 1591 |
rc = ata_eh_read_log_10h(dev, &tag, &tf); if (rc) { |
0260731f0 libata-link: link... |
1592 |
ata_link_printk(link, KERN_ERR, "failed to read log page 10h " |
e8ee84518 [PATCH] libata-nc... |
1593 1594 1595 1596 |
"(errno=%d) ", rc); return; } |
0260731f0 libata-link: link... |
1597 1598 |
if (!(link->sactive & (1 << tag))) { ata_link_printk(link, KERN_ERR, "log page 10h reported " |
e8ee84518 [PATCH] libata-nc... |
1599 1600 1601 1602 1603 1604 1605 1606 |
"inactive tag %d ", tag); return; } /* we've got the perpetrator, condemn it */ qc = __ata_qc_from_tag(ap, tag); memcpy(&qc->result_tf, &tf, sizeof(tf)); |
a6116c9e6 libata-eh set tf ... |
1607 |
qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48; |
5335b7290 libata: implement... |
1608 |
qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ; |
e8ee84518 [PATCH] libata-nc... |
1609 1610 1611 1612 |
ehc->i.err_mask &= ~AC_ERR_DEV; } /** |
022bdb075 [PATCH] libata-eh... |
1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 |
* ata_eh_analyze_tf - analyze taskfile of a failed qc * @qc: qc to analyze * @tf: Taskfile registers to analyze * * Analyze taskfile of @qc and further determine cause of * failure. This function also requests ATAPI sense data if * avaliable. * * LOCKING: * Kernel thread context (may sleep). * * RETURNS: * Determined recovery action */ static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc, const struct ata_taskfile *tf) { unsigned int tmp, action = 0; u8 stat = tf->command, err = tf->feature; if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) { qc->err_mask |= AC_ERR_HSM; |
cf4806265 libata: prefer ha... |
1635 |
return ATA_EH_RESET; |
022bdb075 [PATCH] libata-eh... |
1636 |
} |
a51d644af libata: improve A... |
1637 1638 1639 |
if (stat & (ATA_ERR | ATA_DF)) qc->err_mask |= AC_ERR_DEV; else |
022bdb075 [PATCH] libata-eh... |
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 |
return 0; switch (qc->dev->class) { case ATA_DEV_ATA: if (err & ATA_ICRC) qc->err_mask |= AC_ERR_ATA_BUS; if (err & ATA_UNC) qc->err_mask |= AC_ERR_MEDIA; if (err & ATA_IDNF) qc->err_mask |= AC_ERR_INVALID; break; case ATA_DEV_ATAPI: |
a569a30d3 [PATCH] libata: d... |
1653 |
if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) { |
3eabddb8e libata-eh: update... |
1654 1655 1656 |
tmp = atapi_eh_request_sense(qc->dev, qc->scsicmd->sense_buffer, qc->result_tf.feature >> 4); |
a569a30d3 [PATCH] libata: d... |
1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 |
if (!tmp) { /* ATA_QCFLAG_SENSE_VALID is used to * tell atapi_qc_complete() that sense * data is already valid. * * TODO: interpret sense data and set * appropriate err_mask. */ qc->flags |= ATA_QCFLAG_SENSE_VALID; } else qc->err_mask |= tmp; } |
022bdb075 [PATCH] libata-eh... |
1669 1670 1671 |
} if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS)) |
cf4806265 libata: prefer ha... |
1672 |
action |= ATA_EH_RESET; |
022bdb075 [PATCH] libata-eh... |
1673 1674 1675 |
return action; } |
76326ac1a libata: implement... |
1676 1677 |
static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask, int *xfer_ok) |
022bdb075 [PATCH] libata-eh... |
1678 |
{ |
76326ac1a libata: implement... |
1679 1680 1681 1682 1683 1684 |
int base = 0; if (!(eflags & ATA_EFLAG_DUBIOUS_XFER)) *xfer_ok = 1; if (!*xfer_ok) |
75f9cafc2 libata: fix off-b... |
1685 |
base = ATA_ECAT_DUBIOUS_NONE; |
76326ac1a libata: implement... |
1686 |
|
7d47e8d4d libata: put some ... |
1687 |
if (err_mask & AC_ERR_ATA_BUS) |
76326ac1a libata: implement... |
1688 |
return base + ATA_ECAT_ATA_BUS; |
022bdb075 [PATCH] libata-eh... |
1689 |
|
7d47e8d4d libata: put some ... |
1690 |
if (err_mask & AC_ERR_TIMEOUT) |
76326ac1a libata: implement... |
1691 |
return base + ATA_ECAT_TOUT_HSM; |
7d47e8d4d libata: put some ... |
1692 |
|
3884f7b0a libata: clean up ... |
1693 |
if (eflags & ATA_EFLAG_IS_IO) { |
7d47e8d4d libata: put some ... |
1694 |
if (err_mask & AC_ERR_HSM) |
76326ac1a libata: implement... |
1695 |
return base + ATA_ECAT_TOUT_HSM; |
7d47e8d4d libata: put some ... |
1696 1697 |
if ((err_mask & (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV) |
76326ac1a libata: implement... |
1698 |
return base + ATA_ECAT_UNK_DEV; |
022bdb075 [PATCH] libata-eh... |
1699 1700 1701 1702 |
} return 0; } |
7d47e8d4d libata: put some ... |
1703 |
struct speed_down_verdict_arg { |
022bdb075 [PATCH] libata-eh... |
1704 |
u64 since; |
76326ac1a libata: implement... |
1705 |
int xfer_ok; |
3884f7b0a libata: clean up ... |
1706 |
int nr_errors[ATA_ECAT_NR]; |
022bdb075 [PATCH] libata-eh... |
1707 |
}; |
7d47e8d4d libata: put some ... |
1708 |
static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg) |
022bdb075 [PATCH] libata-eh... |
1709 |
{ |
7d47e8d4d libata: put some ... |
1710 |
struct speed_down_verdict_arg *arg = void_arg; |
76326ac1a libata: implement... |
1711 |
int cat; |
022bdb075 [PATCH] libata-eh... |
1712 1713 1714 |
if (ent->timestamp < arg->since) return -1; |
76326ac1a libata: implement... |
1715 1716 |
cat = ata_eh_categorize_error(ent->eflags, ent->err_mask, &arg->xfer_ok); |
7d47e8d4d libata: put some ... |
1717 |
arg->nr_errors[cat]++; |
76326ac1a libata: implement... |
1718 |
|
022bdb075 [PATCH] libata-eh... |
1719 1720 1721 1722 |
return 0; } /** |
7d47e8d4d libata: put some ... |
1723 |
* ata_eh_speed_down_verdict - Determine speed down verdict |
022bdb075 [PATCH] libata-eh... |
1724 1725 1726 |
* @dev: Device of interest * * This function examines error ring of @dev and determines |
7d47e8d4d libata: put some ... |
1727 1728 |
* whether NCQ needs to be turned off, transfer speed should be * stepped down, or falling back to PIO is necessary. |
022bdb075 [PATCH] libata-eh... |
1729 |
* |
3884f7b0a libata: clean up ... |
1730 1731 1732 1733 1734 1735 1736 |
* ECAT_ATA_BUS : ATA_BUS error for any command * * ECAT_TOUT_HSM : TIMEOUT for any command or HSM violation for * IO commands * * ECAT_UNK_DEV : Unknown DEV error for IO commands * |
76326ac1a libata: implement... |
1737 1738 1739 |
* ECAT_DUBIOUS_* : Identical to above three but occurred while * data transfer hasn't been verified. * |
3884f7b0a libata: clean up ... |
1740 1741 1742 |
* Verdicts are * * NCQ_OFF : Turn off NCQ. |
022bdb075 [PATCH] libata-eh... |
1743 |
* |
3884f7b0a libata: clean up ... |
1744 1745 |
* SPEED_DOWN : Speed down transfer speed but don't fall back * to PIO. |
7d47e8d4d libata: put some ... |
1746 |
* |
3884f7b0a libata: clean up ... |
1747 |
* FALLBACK_TO_PIO : Fall back to PIO. |
022bdb075 [PATCH] libata-eh... |
1748 |
* |
3884f7b0a libata: clean up ... |
1749 |
* Even if multiple verdicts are returned, only one action is |
76326ac1a libata: implement... |
1750 1751 1752 1753 1754 1755 1756 |
* taken per error. An action triggered by non-DUBIOUS errors * clears ering, while one triggered by DUBIOUS_* errors doesn't. * This is to expedite speed down decisions right after device is * initially configured. * * The followings are speed down rules. #1 and #2 deal with * DUBIOUS errors. |
7d47e8d4d libata: put some ... |
1757 |
* |
76326ac1a libata: implement... |
1758 1759 1760 1761 1762 1763 1764 |
* 1. If more than one DUBIOUS_ATA_BUS or DUBIOUS_TOUT_HSM errors * occurred during last 5 mins, SPEED_DOWN and FALLBACK_TO_PIO. * * 2. If more than one DUBIOUS_TOUT_HSM or DUBIOUS_UNK_DEV errors * occurred during last 5 mins, NCQ_OFF. * * 3. If more than 8 ATA_BUS, TOUT_HSM or UNK_DEV errors |
3884f7b0a libata: clean up ... |
1765 |
* ocurred during last 5 mins, FALLBACK_TO_PIO |
7d47e8d4d libata: put some ... |
1766 |
* |
76326ac1a libata: implement... |
1767 |
* 4. If more than 3 TOUT_HSM or UNK_DEV errors occurred |
3884f7b0a libata: clean up ... |
1768 1769 |
* during last 10 mins, NCQ_OFF. * |
76326ac1a libata: implement... |
1770 |
* 5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6 |
3884f7b0a libata: clean up ... |
1771 |
* UNK_DEV errors occurred during last 10 mins, SPEED_DOWN. |
7d47e8d4d libata: put some ... |
1772 |
* |
022bdb075 [PATCH] libata-eh... |
1773 1774 1775 1776 |
* LOCKING: * Inherited from caller. * * RETURNS: |
7d47e8d4d libata: put some ... |
1777 |
* OR of ATA_EH_SPDN_* flags. |
022bdb075 [PATCH] libata-eh... |
1778 |
*/ |
7d47e8d4d libata: put some ... |
1779 |
static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev) |
022bdb075 [PATCH] libata-eh... |
1780 |
{ |
7d47e8d4d libata: put some ... |
1781 1782 1783 1784 |
const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ; u64 j64 = get_jiffies_64(); struct speed_down_verdict_arg arg; unsigned int verdict = 0; |
022bdb075 [PATCH] libata-eh... |
1785 |
|
3884f7b0a libata: clean up ... |
1786 |
/* scan past 5 mins of error history */ |
7d47e8d4d libata: put some ... |
1787 |
memset(&arg, 0, sizeof(arg)); |
3884f7b0a libata: clean up ... |
1788 |
arg.since = j64 - min(j64, j5mins); |
7d47e8d4d libata: put some ... |
1789 |
ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg); |
022bdb075 [PATCH] libata-eh... |
1790 |
|
76326ac1a libata: implement... |
1791 1792 1793 1794 1795 1796 1797 1798 |
if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] + arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1) verdict |= ATA_EH_SPDN_SPEED_DOWN | ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS; if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] + arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1) verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS; |
3884f7b0a libata: clean up ... |
1799 1800 |
if (arg.nr_errors[ATA_ECAT_ATA_BUS] + arg.nr_errors[ATA_ECAT_TOUT_HSM] + |
663f99b86 libata: adjust sp... |
1801 |
arg.nr_errors[ATA_ECAT_UNK_DEV] > 6) |
3884f7b0a libata: clean up ... |
1802 |
verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO; |
022bdb075 [PATCH] libata-eh... |
1803 |
|
3884f7b0a libata: clean up ... |
1804 |
/* scan past 10 mins of error history */ |
022bdb075 [PATCH] libata-eh... |
1805 |
memset(&arg, 0, sizeof(arg)); |
3884f7b0a libata: clean up ... |
1806 |
arg.since = j64 - min(j64, j10mins); |
7d47e8d4d libata: put some ... |
1807 |
ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg); |
022bdb075 [PATCH] libata-eh... |
1808 |
|
3884f7b0a libata: clean up ... |
1809 1810 1811 1812 1813 1814 |
if (arg.nr_errors[ATA_ECAT_TOUT_HSM] + arg.nr_errors[ATA_ECAT_UNK_DEV] > 3) verdict |= ATA_EH_SPDN_NCQ_OFF; if (arg.nr_errors[ATA_ECAT_ATA_BUS] + arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 || |
663f99b86 libata: adjust sp... |
1815 |
arg.nr_errors[ATA_ECAT_UNK_DEV] > 6) |
3884f7b0a libata: clean up ... |
1816 |
verdict |= ATA_EH_SPDN_SPEED_DOWN; |
022bdb075 [PATCH] libata-eh... |
1817 |
|
7d47e8d4d libata: put some ... |
1818 |
return verdict; |
022bdb075 [PATCH] libata-eh... |
1819 1820 1821 1822 1823 |
} /** * ata_eh_speed_down - record error and speed down if necessary * @dev: Failed device |
3884f7b0a libata: clean up ... |
1824 |
* @eflags: mask of ATA_EFLAG_* flags |
022bdb075 [PATCH] libata-eh... |
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 |
* @err_mask: err_mask of the error * * Record error and examine error history to determine whether * adjusting transmission speed is necessary. It also sets * transmission limits appropriately if such adjustment is * necessary. * * LOCKING: * Kernel thread context (may sleep). * * RETURNS: |
7d47e8d4d libata: put some ... |
1836 |
* Determined recovery action. |
022bdb075 [PATCH] libata-eh... |
1837 |
*/ |
3884f7b0a libata: clean up ... |
1838 1839 |
static unsigned int ata_eh_speed_down(struct ata_device *dev, unsigned int eflags, unsigned int err_mask) |
022bdb075 [PATCH] libata-eh... |
1840 |
{ |
b1c72916a libata: implement... |
1841 |
struct ata_link *link = ata_dev_phys_link(dev); |
76326ac1a libata: implement... |
1842 |
int xfer_ok = 0; |
7d47e8d4d libata: put some ... |
1843 1844 1845 1846 |
unsigned int verdict; unsigned int action = 0; /* don't bother if Cat-0 error */ |
76326ac1a libata: implement... |
1847 |
if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0) |
022bdb075 [PATCH] libata-eh... |
1848 1849 1850 |
return 0; /* record error and determine whether speed down is necessary */ |
3884f7b0a libata: clean up ... |
1851 |
ata_ering_record(&dev->ering, eflags, err_mask); |
7d47e8d4d libata: put some ... |
1852 |
verdict = ata_eh_speed_down_verdict(dev); |
022bdb075 [PATCH] libata-eh... |
1853 |
|
7d47e8d4d libata: put some ... |
1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 |
/* turn off NCQ? */ if ((verdict & ATA_EH_SPDN_NCQ_OFF) && (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ | ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) { dev->flags |= ATA_DFLAG_NCQ_OFF; ata_dev_printk(dev, KERN_WARNING, "NCQ disabled due to excessive errors "); goto done; } |
022bdb075 [PATCH] libata-eh... |
1864 |
|
7d47e8d4d libata: put some ... |
1865 1866 1867 |
/* speed down? */ if (verdict & ATA_EH_SPDN_SPEED_DOWN) { /* speed down SATA link speed if possible */ |
a07d499b4 libata: add @spd_... |
1868 |
if (sata_down_spd_limit(link, 0) == 0) { |
cf4806265 libata: prefer ha... |
1869 |
action |= ATA_EH_RESET; |
7d47e8d4d libata: put some ... |
1870 1871 |
goto done; } |
022bdb075 [PATCH] libata-eh... |
1872 |
|
7d47e8d4d libata: put some ... |
1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 |
/* lower transfer mode */ if (dev->spdn_cnt < 2) { static const int dma_dnxfer_sel[] = { ATA_DNXFER_DMA, ATA_DNXFER_40C }; static const int pio_dnxfer_sel[] = { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 }; int sel; if (dev->xfer_shift != ATA_SHIFT_PIO) sel = dma_dnxfer_sel[dev->spdn_cnt]; else sel = pio_dnxfer_sel[dev->spdn_cnt]; dev->spdn_cnt++; if (ata_down_xfermask_limit(dev, sel) == 0) { |
cf4806265 libata: prefer ha... |
1889 |
action |= ATA_EH_RESET; |
7d47e8d4d libata: put some ... |
1890 1891 1892 1893 1894 1895 |
goto done; } } } /* Fall back to PIO? Slowing down to PIO is meaningless for |
663f99b86 libata: adjust sp... |
1896 |
* SATA ATA devices. Consider it only for PATA and SATAPI. |
7d47e8d4d libata: put some ... |
1897 1898 |
*/ if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) && |
663f99b86 libata: adjust sp... |
1899 |
(link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) && |
7d47e8d4d libata: put some ... |
1900 1901 1902 |
(dev->xfer_shift != ATA_SHIFT_PIO)) { if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) { dev->spdn_cnt = 0; |
cf4806265 libata: prefer ha... |
1903 |
action |= ATA_EH_RESET; |
7d47e8d4d libata: put some ... |
1904 1905 1906 |
goto done; } } |
022bdb075 [PATCH] libata-eh... |
1907 |
|
022bdb075 [PATCH] libata-eh... |
1908 |
return 0; |
7d47e8d4d libata: put some ... |
1909 1910 |
done: /* device has been slowed down, blow error history */ |
76326ac1a libata: implement... |
1911 1912 |
if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS)) ata_ering_clear(&dev->ering); |
7d47e8d4d libata: put some ... |
1913 |
return action; |
022bdb075 [PATCH] libata-eh... |
1914 1915 1916 |
} /** |
9b1e2658f libata-link: upda... |
1917 1918 |
* ata_eh_link_autopsy - analyze error and determine recovery action * @link: host link to perform autopsy on |
022bdb075 [PATCH] libata-eh... |
1919 |
* |
0260731f0 libata-link: link... |
1920 1921 1922 |
* Analyze why @link failed and determine which recovery actions * are needed. This function also sets more detailed AC_ERR_* * values and fills sense data for ATAPI CHECK SENSE. |
022bdb075 [PATCH] libata-eh... |
1923 1924 1925 1926 |
* * LOCKING: * Kernel thread context (may sleep). */ |
9b1e2658f libata-link: upda... |
1927 |
static void ata_eh_link_autopsy(struct ata_link *link) |
022bdb075 [PATCH] libata-eh... |
1928 |
{ |
0260731f0 libata-link: link... |
1929 |
struct ata_port *ap = link->ap; |
936fd7328 libata-link: link... |
1930 |
struct ata_eh_context *ehc = &link->eh_context; |
dfcc173d7 libata: consider ... |
1931 |
struct ata_device *dev; |
3884f7b0a libata: clean up ... |
1932 1933 |
unsigned int all_err_mask = 0, eflags = 0; int tag; |
022bdb075 [PATCH] libata-eh... |
1934 1935 1936 1937 1938 |
u32 serror; int rc; DPRINTK("ENTER "); |
1cdaf534f [PATCH] libata: i... |
1939 1940 |
if (ehc->i.flags & ATA_EHI_NO_AUTOPSY) return; |
022bdb075 [PATCH] libata-eh... |
1941 |
/* obtain and analyze SError */ |
936fd7328 libata-link: link... |
1942 |
rc = sata_scr_read(link, SCR_ERROR, &serror); |
022bdb075 [PATCH] libata-eh... |
1943 1944 |
if (rc == 0) { ehc->i.serror |= serror; |
0260731f0 libata-link: link... |
1945 |
ata_eh_analyze_serror(link); |
4e57c517b libata: schedule ... |
1946 |
} else if (rc != -EOPNOTSUPP) { |
cf4806265 libata: prefer ha... |
1947 |
/* SError read failed, force reset and probing */ |
b558edddb libata: kill ata_... |
1948 |
ehc->i.probe_mask |= ATA_ALL_DEVICES; |
cf4806265 libata: prefer ha... |
1949 |
ehc->i.action |= ATA_EH_RESET; |
4e57c517b libata: schedule ... |
1950 1951 |
ehc->i.err_mask |= AC_ERR_OTHER; } |
022bdb075 [PATCH] libata-eh... |
1952 |
|
e8ee84518 [PATCH] libata-nc... |
1953 |
/* analyze NCQ failure */ |
0260731f0 libata-link: link... |
1954 |
ata_eh_analyze_ncq_error(link); |
e8ee84518 [PATCH] libata-nc... |
1955 |
|
022bdb075 [PATCH] libata-eh... |
1956 1957 1958 1959 1960 1961 1962 1963 |
/* any real error trumps AC_ERR_OTHER */ if (ehc->i.err_mask & ~AC_ERR_OTHER) ehc->i.err_mask &= ~AC_ERR_OTHER; all_err_mask |= ehc->i.err_mask; for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); |
b1c72916a libata: implement... |
1964 1965 |
if (!(qc->flags & ATA_QCFLAG_FAILED) || ata_dev_phys_link(qc->dev) != link) |
022bdb075 [PATCH] libata-eh... |
1966 1967 1968 1969 |
continue; /* inherit upper level err_mask */ qc->err_mask |= ehc->i.err_mask; |
022bdb075 [PATCH] libata-eh... |
1970 |
/* analyze TF */ |
4528e4da7 [PATCH] libata: f... |
1971 |
ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf); |
022bdb075 [PATCH] libata-eh... |
1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 |
/* DEV errors are probably spurious in case of ATA_BUS error */ if (qc->err_mask & AC_ERR_ATA_BUS) qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA | AC_ERR_INVALID); /* any real error trumps unknown error */ if (qc->err_mask & ~AC_ERR_OTHER) qc->err_mask &= ~AC_ERR_OTHER; /* SENSE_VALID trumps dev/unknown error and revalidation */ |
f90f0828e libata: stop bein... |
1983 |
if (qc->flags & ATA_QCFLAG_SENSE_VALID) |
022bdb075 [PATCH] libata-eh... |
1984 |
qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER); |
022bdb075 [PATCH] libata-eh... |
1985 |
|
03faab782 libata: implement... |
1986 |
/* determine whether the command is worth retrying */ |
534ead709 libata: retry FS ... |
1987 1988 1989 |
if (qc->flags & ATA_QCFLAG_IO || (!(qc->err_mask & AC_ERR_INVALID) && qc->err_mask != AC_ERR_DEV)) |
03faab782 libata: implement... |
1990 |
qc->flags |= ATA_QCFLAG_RETRY; |
022bdb075 [PATCH] libata-eh... |
1991 |
/* accumulate error info */ |
4528e4da7 [PATCH] libata: f... |
1992 |
ehc->i.dev = qc->dev; |
022bdb075 [PATCH] libata-eh... |
1993 1994 |
all_err_mask |= qc->err_mask; if (qc->flags & ATA_QCFLAG_IO) |
3884f7b0a libata: clean up ... |
1995 |
eflags |= ATA_EFLAG_IS_IO; |
022bdb075 [PATCH] libata-eh... |
1996 |
} |
a20f33ffd [PATCH] libata: e... |
1997 |
/* enforce default EH actions */ |
b51e9e5db [PATCH] libata: a... |
1998 |
if (ap->pflags & ATA_PFLAG_FROZEN || |
a20f33ffd [PATCH] libata: e... |
1999 |
all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT)) |
cf4806265 libata: prefer ha... |
2000 |
ehc->i.action |= ATA_EH_RESET; |
3884f7b0a libata: clean up ... |
2001 2002 |
else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) || (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV))) |
4528e4da7 [PATCH] libata: f... |
2003 |
ehc->i.action |= ATA_EH_REVALIDATE; |
022bdb075 [PATCH] libata-eh... |
2004 |
|
dfcc173d7 libata: consider ... |
2005 2006 2007 |
/* If we have offending qcs and the associated failed device, * perform per-dev EH action only on the offending device. */ |
4528e4da7 [PATCH] libata: f... |
2008 |
if (ehc->i.dev) { |
4528e4da7 [PATCH] libata: f... |
2009 2010 2011 |
ehc->i.dev_action[ehc->i.dev->devno] |= ehc->i.action & ATA_EH_PERDEV_MASK; ehc->i.action &= ~ATA_EH_PERDEV_MASK; |
47005f255 [PATCH] libata: i... |
2012 |
} |
2695e3661 libata-pmp: propa... |
2013 2014 2015 2016 2017 |
/* propagate timeout to host link */ if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link)) ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT; /* record error and consider speeding down */ |
dfcc173d7 libata: consider ... |
2018 |
dev = ehc->i.dev; |
2695e3661 libata-pmp: propa... |
2019 2020 2021 |
if (!dev && ((ata_link_max_devices(link) == 1 && ata_dev_enabled(link->device)))) dev = link->device; |
dfcc173d7 libata: consider ... |
2022 |
|
76326ac1a libata: implement... |
2023 2024 2025 |
if (dev) { if (dev->flags & ATA_DFLAG_DUBIOUS_XFER) eflags |= ATA_EFLAG_DUBIOUS_XFER; |
3884f7b0a libata: clean up ... |
2026 |
ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask); |
76326ac1a libata: implement... |
2027 |
} |
dfcc173d7 libata: consider ... |
2028 |
|
022bdb075 [PATCH] libata-eh... |
2029 2030 2031 2032 2033 |
DPRINTK("EXIT "); } /** |
9b1e2658f libata-link: upda... |
2034 2035 2036 2037 2038 2039 2040 2041 2042 |
* ata_eh_autopsy - analyze error and determine recovery action * @ap: host port to perform autopsy on * * Analyze all links of @ap and determine why they failed and * which recovery actions are needed. * * LOCKING: * Kernel thread context (may sleep). */ |
fb7fd6145 libata-pmp-prep: ... |
2043 |
void ata_eh_autopsy(struct ata_port *ap) |
9b1e2658f libata-link: upda... |
2044 2045 |
{ struct ata_link *link; |
1eca4365b libata: beef up i... |
2046 |
ata_for_each_link(link, ap, EDGE) |
9b1e2658f libata-link: upda... |
2047 |
ata_eh_link_autopsy(link); |
2695e3661 libata-pmp: propa... |
2048 |
|
b1c72916a libata: implement... |
2049 2050 2051 2052 2053 2054 2055 |
/* Handle the frigging slave link. Autopsy is done similarly * but actions and flags are transferred over to the master * link and handled from there. */ if (ap->slave_link) { struct ata_eh_context *mehc = &ap->link.eh_context; struct ata_eh_context *sehc = &ap->slave_link->eh_context; |
848e4c68c libata: transfer ... |
2056 2057 2058 2059 |
/* transfer control flags from master to slave */ sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK; /* perform autopsy on the slave link */ |
b1c72916a libata: implement... |
2060 |
ata_eh_link_autopsy(ap->slave_link); |
848e4c68c libata: transfer ... |
2061 |
/* transfer actions from slave to master and clear slave */ |
b1c72916a libata: implement... |
2062 2063 2064 2065 2066 2067 |
ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS); mehc->i.action |= sehc->i.action; mehc->i.dev_action[1] |= sehc->i.dev_action[1]; mehc->i.flags |= sehc->i.flags; ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS); } |
2695e3661 libata-pmp: propa... |
2068 2069 2070 |
/* Autopsy of fanout ports can affect host link autopsy. * Perform host link autopsy last. */ |
071f44b1d libata: implement... |
2071 |
if (sata_pmp_attached(ap)) |
2695e3661 libata-pmp: propa... |
2072 |
ata_eh_link_autopsy(&ap->link); |
9b1e2658f libata-link: upda... |
2073 2074 2075 |
} /** |
6521148c6 libata: add comma... |
2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 |
* ata_get_cmd_descript - get description for ATA command * @command: ATA command code to get description for * * Return a textual description of the given command, or NULL if the * command is not known. * * LOCKING: * None */ const char *ata_get_cmd_descript(u8 command) { #ifdef CONFIG_ATA_VERBOSE_ERROR static const struct { u8 command; const char *text; } cmd_descr[] = { { ATA_CMD_DEV_RESET, "DEVICE RESET" }, { ATA_CMD_CHK_POWER, "CHECK POWER MODE" }, { ATA_CMD_STANDBY, "STANDBY" }, { ATA_CMD_IDLE, "IDLE" }, { ATA_CMD_EDD, "EXECUTE DEVICE DIAGNOSTIC" }, { ATA_CMD_DOWNLOAD_MICRO, "DOWNLOAD MICROCODE" }, { ATA_CMD_NOP, "NOP" }, { ATA_CMD_FLUSH, "FLUSH CACHE" }, { ATA_CMD_FLUSH_EXT, "FLUSH CACHE EXT" }, { ATA_CMD_ID_ATA, "IDENTIFY DEVICE" }, { ATA_CMD_ID_ATAPI, "IDENTIFY PACKET DEVICE" }, { ATA_CMD_SERVICE, "SERVICE" }, { ATA_CMD_READ, "READ DMA" }, { ATA_CMD_READ_EXT, "READ DMA EXT" }, { ATA_CMD_READ_QUEUED, "READ DMA QUEUED" }, { ATA_CMD_READ_STREAM_EXT, "READ STREAM EXT" }, { ATA_CMD_READ_STREAM_DMA_EXT, "READ STREAM DMA EXT" }, { ATA_CMD_WRITE, "WRITE DMA" }, { ATA_CMD_WRITE_EXT, "WRITE DMA EXT" }, { ATA_CMD_WRITE_QUEUED, "WRITE DMA QUEUED EXT" }, { ATA_CMD_WRITE_STREAM_EXT, "WRITE STREAM EXT" }, { ATA_CMD_WRITE_STREAM_DMA_EXT, "WRITE STREAM DMA EXT" }, { ATA_CMD_WRITE_FUA_EXT, "WRITE DMA FUA EXT" }, { ATA_CMD_WRITE_QUEUED_FUA_EXT, "WRITE DMA QUEUED FUA EXT" }, { ATA_CMD_FPDMA_READ, "READ FPDMA QUEUED" }, { ATA_CMD_FPDMA_WRITE, "WRITE FPDMA QUEUED" }, { ATA_CMD_PIO_READ, "READ SECTOR(S)" }, { ATA_CMD_PIO_READ_EXT, "READ SECTOR(S) EXT" }, { ATA_CMD_PIO_WRITE, "WRITE SECTOR(S)" }, { ATA_CMD_PIO_WRITE_EXT, "WRITE SECTOR(S) EXT" }, { ATA_CMD_READ_MULTI, "READ MULTIPLE" }, { ATA_CMD_READ_MULTI_EXT, "READ MULTIPLE EXT" }, { ATA_CMD_WRITE_MULTI, "WRITE MULTIPLE" }, { ATA_CMD_WRITE_MULTI_EXT, "WRITE MULTIPLE EXT" }, { ATA_CMD_WRITE_MULTI_FUA_EXT, "WRITE MULTIPLE FUA EXT" }, { ATA_CMD_SET_FEATURES, "SET FEATURES" }, { ATA_CMD_SET_MULTI, "SET MULTIPLE MODE" }, { ATA_CMD_VERIFY, "READ VERIFY SECTOR(S)" }, { ATA_CMD_VERIFY_EXT, "READ VERIFY SECTOR(S) EXT" }, { ATA_CMD_WRITE_UNCORR_EXT, "WRITE UNCORRECTABLE EXT" }, { ATA_CMD_STANDBYNOW1, "STANDBY IMMEDIATE" }, { ATA_CMD_IDLEIMMEDIATE, "IDLE IMMEDIATE" }, { ATA_CMD_SLEEP, "SLEEP" }, { ATA_CMD_INIT_DEV_PARAMS, "INITIALIZE DEVICE PARAMETERS" }, { ATA_CMD_READ_NATIVE_MAX, "READ NATIVE MAX ADDRESS" }, { ATA_CMD_READ_NATIVE_MAX_EXT, "READ NATIVE MAX ADDRESS EXT" }, { ATA_CMD_SET_MAX, "SET MAX ADDRESS" }, { ATA_CMD_SET_MAX_EXT, "SET MAX ADDRESS EXT" }, { ATA_CMD_READ_LOG_EXT, "READ LOG EXT" }, { ATA_CMD_WRITE_LOG_EXT, "WRITE LOG EXT" }, { ATA_CMD_READ_LOG_DMA_EXT, "READ LOG DMA EXT" }, { ATA_CMD_WRITE_LOG_DMA_EXT, "WRITE LOG DMA EXT" }, { ATA_CMD_TRUSTED_RCV, "TRUSTED RECEIVE" }, { ATA_CMD_TRUSTED_RCV_DMA, "TRUSTED RECEIVE DMA" }, { ATA_CMD_TRUSTED_SND, "TRUSTED SEND" }, { ATA_CMD_TRUSTED_SND_DMA, "TRUSTED SEND DMA" }, { ATA_CMD_PMP_READ, "READ BUFFER" }, { ATA_CMD_PMP_WRITE, "WRITE BUFFER" }, { ATA_CMD_CONF_OVERLAY, "DEVICE CONFIGURATION OVERLAY" }, { ATA_CMD_SEC_SET_PASS, "SECURITY SET PASSWORD" }, { ATA_CMD_SEC_UNLOCK, "SECURITY UNLOCK" }, { ATA_CMD_SEC_ERASE_PREP, "SECURITY ERASE PREPARE" }, { ATA_CMD_SEC_ERASE_UNIT, "SECURITY ERASE UNIT" }, { ATA_CMD_SEC_FREEZE_LOCK, "SECURITY FREEZE LOCK" }, { ATA_CMD_SEC_DISABLE_PASS, "SECURITY DISABLE PASSWORD" }, { ATA_CMD_CONFIG_STREAM, "CONFIGURE STREAM" }, { ATA_CMD_SMART, "SMART" }, { ATA_CMD_MEDIA_LOCK, "DOOR LOCK" }, { ATA_CMD_MEDIA_UNLOCK, "DOOR UNLOCK" }, |
acad76272 [libata] add ATA_... |
2162 |
{ ATA_CMD_DSM, "DATA SET MANAGEMENT" }, |
6521148c6 libata: add comma... |
2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 |
{ ATA_CMD_CHK_MED_CRD_TYP, "CHECK MEDIA CARD TYPE" }, { ATA_CMD_CFA_REQ_EXT_ERR, "CFA REQUEST EXTENDED ERROR" }, { ATA_CMD_CFA_WRITE_NE, "CFA WRITE SECTORS WITHOUT ERASE" }, { ATA_CMD_CFA_TRANS_SECT, "CFA TRANSLATE SECTOR" }, { ATA_CMD_CFA_ERASE, "CFA ERASE SECTORS" }, { ATA_CMD_CFA_WRITE_MULT_NE, "CFA WRITE MULTIPLE WITHOUT ERASE" }, { ATA_CMD_READ_LONG, "READ LONG (with retries)" }, { ATA_CMD_READ_LONG_ONCE, "READ LONG (without retries)" }, { ATA_CMD_WRITE_LONG, "WRITE LONG (with retries)" }, { ATA_CMD_WRITE_LONG_ONCE, "WRITE LONG (without retries)" }, { ATA_CMD_RESTORE, "RECALIBRATE" }, { 0, NULL } /* terminate list */ }; unsigned int i; for (i = 0; cmd_descr[i].text; i++) if (cmd_descr[i].command == command) return cmd_descr[i].text; #endif return NULL; } /** |
9b1e2658f libata-link: upda... |
2187 |
* ata_eh_link_report - report error handling to user |
0260731f0 libata-link: link... |
2188 |
* @link: ATA link EH is going on |
022bdb075 [PATCH] libata-eh... |
2189 2190 2191 2192 2193 2194 |
* * Report EH to user. * * LOCKING: * None. */ |
9b1e2658f libata-link: upda... |
2195 |
static void ata_eh_link_report(struct ata_link *link) |
022bdb075 [PATCH] libata-eh... |
2196 |
{ |
0260731f0 libata-link: link... |
2197 2198 |
struct ata_port *ap = link->ap; struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
2199 |
const char *frozen, *desc; |
a1e10f7e6 libata: move EH r... |
2200 |
char tries_buf[6]; |
022bdb075 [PATCH] libata-eh... |
2201 |
int tag, nr_failed = 0; |
94ff3d540 libata: skip supp... |
2202 2203 |
if (ehc->i.flags & ATA_EHI_QUIET) return; |
022bdb075 [PATCH] libata-eh... |
2204 2205 2206 2207 2208 2209 |
desc = NULL; if (ehc->i.desc[0] != '\0') desc = ehc->i.desc; for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); |
b1c72916a libata: implement... |
2210 2211 |
if (!(qc->flags & ATA_QCFLAG_FAILED) || ata_dev_phys_link(qc->dev) != link || |
e027bd36c libata: implement... |
2212 2213 |
((qc->flags & ATA_QCFLAG_QUIET) && qc->err_mask == AC_ERR_DEV)) |
022bdb075 [PATCH] libata-eh... |
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 |
continue; if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask) continue; nr_failed++; } if (!nr_failed && !ehc->i.err_mask) return; frozen = ""; |
b51e9e5db [PATCH] libata: a... |
2225 |
if (ap->pflags & ATA_PFLAG_FROZEN) |
022bdb075 [PATCH] libata-eh... |
2226 |
frozen = " frozen"; |
a1e10f7e6 libata: move EH r... |
2227 2228 2229 2230 |
memset(tries_buf, 0, sizeof(tries_buf)); if (ap->eh_tries < ATA_EH_MAX_TRIES) snprintf(tries_buf, sizeof(tries_buf) - 1, " t%d", ap->eh_tries); |
022bdb075 [PATCH] libata-eh... |
2231 |
if (ehc->i.dev) { |
e8ee84518 [PATCH] libata-nc... |
2232 |
ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x " |
a1e10f7e6 libata: move EH r... |
2233 2234 2235 2236 |
"SAct 0x%x SErr 0x%x action 0x%x%s%s ", ehc->i.err_mask, link->sactive, ehc->i.serror, ehc->i.action, frozen, tries_buf); |
022bdb075 [PATCH] libata-eh... |
2237 |
if (desc) |
b64bbc39f libata: improve E... |
2238 2239 |
ata_dev_printk(ehc->i.dev, KERN_ERR, "%s ", desc); |
022bdb075 [PATCH] libata-eh... |
2240 |
} else { |
0260731f0 libata-link: link... |
2241 |
ata_link_printk(link, KERN_ERR, "exception Emask 0x%x " |
a1e10f7e6 libata: move EH r... |
2242 2243 2244 2245 |
"SAct 0x%x SErr 0x%x action 0x%x%s%s ", ehc->i.err_mask, link->sactive, ehc->i.serror, ehc->i.action, frozen, tries_buf); |
022bdb075 [PATCH] libata-eh... |
2246 |
if (desc) |
0260731f0 libata-link: link... |
2247 2248 |
ata_link_printk(link, KERN_ERR, "%s ", desc); |
022bdb075 [PATCH] libata-eh... |
2249 |
} |
6521148c6 libata: add comma... |
2250 |
#ifdef CONFIG_ATA_VERBOSE_ERROR |
1333e1943 libata: add human... |
2251 |
if (ehc->i.serror) |
da0e21d3f libata: use ata_l... |
2252 |
ata_link_printk(link, KERN_ERR, |
1333e1943 libata: add human... |
2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 |
"SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s} ", ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "", ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "", ehc->i.serror & SERR_DATA ? "UnrecovData " : "", ehc->i.serror & SERR_PERSISTENT ? "Persist " : "", ehc->i.serror & SERR_PROTOCOL ? "Proto " : "", ehc->i.serror & SERR_INTERNAL ? "HostInt " : "", ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "", ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "", ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "", ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "", ehc->i.serror & SERR_DISPARITY ? "Dispar " : "", ehc->i.serror & SERR_CRC ? "BadCRC " : "", ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "", ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "", ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "", ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "", |
2dcb407e6 [libata] checkpat... |
2271 |
ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : ""); |
6521148c6 libata: add comma... |
2272 |
#endif |
1333e1943 libata: add human... |
2273 |
|
022bdb075 [PATCH] libata-eh... |
2274 2275 |
for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); |
8a9375817 [PATCH] libata: i... |
2276 |
struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf; |
abb6a8897 libata: report pr... |
2277 2278 2279 |
const u8 *cdb = qc->cdb; char data_buf[20] = ""; char cdb_buf[70] = ""; |
022bdb075 [PATCH] libata-eh... |
2280 |
|
0260731f0 libata-link: link... |
2281 |
if (!(qc->flags & ATA_QCFLAG_FAILED) || |
b1c72916a libata: implement... |
2282 |
ata_dev_phys_link(qc->dev) != link || !qc->err_mask) |
022bdb075 [PATCH] libata-eh... |
2283 |
continue; |
abb6a8897 libata: report pr... |
2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 |
if (qc->dma_dir != DMA_NONE) { static const char *dma_str[] = { [DMA_BIDIRECTIONAL] = "bidi", [DMA_TO_DEVICE] = "out", [DMA_FROM_DEVICE] = "in", }; static const char *prot_str[] = { [ATA_PROT_PIO] = "pio", [ATA_PROT_DMA] = "dma", [ATA_PROT_NCQ] = "ncq", |
0dc36888d libata: rename AT... |
2294 2295 |
[ATAPI_PROT_PIO] = "pio", [ATAPI_PROT_DMA] = "dma", |
abb6a8897 libata: report pr... |
2296 2297 2298 2299 2300 2301 |
}; snprintf(data_buf, sizeof(data_buf), " %s %u %s", prot_str[qc->tf.protocol], qc->nbytes, dma_str[qc->dma_dir]); } |
6521148c6 libata: add comma... |
2302 2303 2304 2305 2306 |
if (ata_is_atapi(qc->tf.protocol)) { if (qc->scsicmd) scsi_print_command(qc->scsicmd); else snprintf(cdb_buf, sizeof(cdb_buf), |
abb6a8897 libata: report pr... |
2307 2308 2309 2310 2311 2312 2313 |
"cdb %02x %02x %02x %02x %02x %02x %02x %02x " "%02x %02x %02x %02x %02x %02x %02x %02x ", cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7], cdb[8], cdb[9], cdb[10], cdb[11], cdb[12], cdb[13], cdb[14], cdb[15]); |
6521148c6 libata: add comma... |
2314 2315 2316 2317 2318 2319 2320 |
} else { const char *descr = ata_get_cmd_descript(cmd->command); if (descr) ata_dev_printk(qc->dev, KERN_ERR, "failed command: %s ", descr); } |
abb6a8897 libata: report pr... |
2321 |
|
8a9375817 [PATCH] libata: i... |
2322 2323 |
ata_dev_printk(qc->dev, KERN_ERR, "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x " |
abb6a8897 libata: report pr... |
2324 2325 |
"tag %d%s %s" |
8a9375817 [PATCH] libata: i... |
2326 |
"res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x " |
5335b7290 libata: implement... |
2327 2328 |
"Emask 0x%x (%s)%s ", |
8a9375817 [PATCH] libata: i... |
2329 2330 2331 2332 |
cmd->command, cmd->feature, cmd->nsect, cmd->lbal, cmd->lbam, cmd->lbah, cmd->hob_feature, cmd->hob_nsect, cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah, |
abb6a8897 libata: report pr... |
2333 |
cmd->device, qc->tag, data_buf, cdb_buf, |
8a9375817 [PATCH] libata: i... |
2334 2335 2336 2337 |
res->command, res->feature, res->nsect, res->lbal, res->lbam, res->lbah, res->hob_feature, res->hob_nsect, res->hob_lbal, res->hob_lbam, res->hob_lbah, |
5335b7290 libata: implement... |
2338 2339 |
res->device, qc->err_mask, ata_err_string(qc->err_mask), qc->err_mask & AC_ERR_NCQ ? " <F>" : ""); |
1333e1943 libata: add human... |
2340 |
|
6521148c6 libata: add comma... |
2341 |
#ifdef CONFIG_ATA_VERBOSE_ERROR |
1333e1943 libata: add human... |
2342 |
if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ | |
2dcb407e6 [libata] checkpat... |
2343 |
ATA_ERR)) { |
1333e1943 libata: add human... |
2344 2345 |
if (res->command & ATA_BUSY) ata_dev_printk(qc->dev, KERN_ERR, |
2dcb407e6 [libata] checkpat... |
2346 2347 |
"status: { Busy } "); |
1333e1943 libata: add human... |
2348 2349 2350 2351 2352 2353 2354 |
else ata_dev_printk(qc->dev, KERN_ERR, "status: { %s%s%s%s} ", res->command & ATA_DRDY ? "DRDY " : "", res->command & ATA_DF ? "DF " : "", res->command & ATA_DRQ ? "DRQ " : "", |
2dcb407e6 [libata] checkpat... |
2355 |
res->command & ATA_ERR ? "ERR " : ""); |
1333e1943 libata: add human... |
2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 |
} if (cmd->command != ATA_CMD_PACKET && (res->feature & (ATA_ICRC | ATA_UNC | ATA_IDNF | ATA_ABORTED))) ata_dev_printk(qc->dev, KERN_ERR, "error: { %s%s%s%s} ", res->feature & ATA_ICRC ? "ICRC " : "", res->feature & ATA_UNC ? "UNC " : "", res->feature & ATA_IDNF ? "IDNF " : "", |
2dcb407e6 [libata] checkpat... |
2367 |
res->feature & ATA_ABORTED ? "ABRT " : ""); |
6521148c6 libata: add comma... |
2368 |
#endif |
022bdb075 [PATCH] libata-eh... |
2369 2370 |
} } |
9b1e2658f libata-link: upda... |
2371 2372 2373 2374 2375 2376 2377 2378 2379 |
/** * ata_eh_report - report error handling to user * @ap: ATA port to report EH about * * Report EH to user. * * LOCKING: * None. */ |
fb7fd6145 libata-pmp-prep: ... |
2380 |
void ata_eh_report(struct ata_port *ap) |
9b1e2658f libata-link: upda... |
2381 2382 |
{ struct ata_link *link; |
1eca4365b libata: beef up i... |
2383 |
ata_for_each_link(link, ap, HOST_FIRST) |
9b1e2658f libata-link: upda... |
2384 2385 |
ata_eh_link_report(link); } |
cc0680a58 libata-link: link... |
2386 |
static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset, |
b1c72916a libata: implement... |
2387 2388 |
unsigned int *classes, unsigned long deadline, bool clear_classes) |
d87fa38e7 [PATCH] libata-hp... |
2389 |
{ |
f58229f80 libata-link: impl... |
2390 |
struct ata_device *dev; |
d87fa38e7 [PATCH] libata-hp... |
2391 |
|
b1c72916a libata: implement... |
2392 |
if (clear_classes) |
1eca4365b libata: beef up i... |
2393 |
ata_for_each_dev(dev, link, ALL) |
b1c72916a libata: implement... |
2394 |
classes[dev->devno] = ATA_DEV_UNKNOWN; |
d87fa38e7 [PATCH] libata-hp... |
2395 |
|
f046519fc libata: kill hotp... |
2396 |
return reset(link, classes, deadline); |
d87fa38e7 [PATCH] libata-hp... |
2397 |
} |
ae791c056 libata-pmp-prep: ... |
2398 |
static int ata_eh_followup_srst_needed(struct ata_link *link, |
5dbfc9cb5 libata: always do... |
2399 |
int rc, const unsigned int *classes) |
664faf09a [PATCH] libata-hp... |
2400 |
{ |
45db2f6c9 libata: move link... |
2401 |
if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link)) |
ae791c056 libata-pmp-prep: ... |
2402 |
return 0; |
5dbfc9cb5 libata: always do... |
2403 2404 |
if (rc == -EAGAIN) return 1; |
071f44b1d libata: implement... |
2405 |
if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) |
3495de733 libata-pmp: updat... |
2406 |
return 1; |
664faf09a [PATCH] libata-hp... |
2407 2408 |
return 0; } |
fb7fd6145 libata-pmp-prep: ... |
2409 2410 2411 |
int ata_eh_reset(struct ata_link *link, int classify, ata_prereset_fn_t prereset, ata_reset_fn_t softreset, ata_reset_fn_t hardreset, ata_postreset_fn_t postreset) |
022bdb075 [PATCH] libata-eh... |
2412 |
{ |
afaa5c373 libata: implement... |
2413 |
struct ata_port *ap = link->ap; |
b1c72916a libata: implement... |
2414 |
struct ata_link *slave = ap->slave_link; |
936fd7328 libata-link: link... |
2415 |
struct ata_eh_context *ehc = &link->eh_context; |
705d20141 libata: add missi... |
2416 |
struct ata_eh_context *sehc = slave ? &slave->eh_context : NULL; |
664faf09a [PATCH] libata-hp... |
2417 |
unsigned int *classes = ehc->classes; |
416dc9ed2 libata: cosmetic ... |
2418 |
unsigned int lflags = link->flags; |
1cdaf534f [PATCH] libata: i... |
2419 |
int verbose = !(ehc->i.flags & ATA_EHI_QUIET); |
d8af0eb60 libata: use ULONG... |
2420 |
int max_tries = 0, try = 0; |
b1c72916a libata: implement... |
2421 |
struct ata_link *failed_link; |
f58229f80 libata-link: impl... |
2422 |
struct ata_device *dev; |
416dc9ed2 libata: cosmetic ... |
2423 |
unsigned long deadline, now; |
022bdb075 [PATCH] libata-eh... |
2424 |
ata_reset_fn_t reset; |
afaa5c373 libata: implement... |
2425 |
unsigned long flags; |
416dc9ed2 libata: cosmetic ... |
2426 |
u32 sstatus; |
b1c72916a libata: implement... |
2427 |
int nr_unknown, rc; |
022bdb075 [PATCH] libata-eh... |
2428 |
|
932648b00 libata: reorganiz... |
2429 2430 2431 |
/* * Prepare to reset */ |
d8af0eb60 libata: use ULONG... |
2432 2433 |
while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX) max_tries++; |
05944bdf6 libata: implement... |
2434 2435 2436 2437 |
if (link->flags & ATA_LFLAG_NO_HRST) hardreset = NULL; if (link->flags & ATA_LFLAG_NO_SRST) softreset = NULL; |
d8af0eb60 libata: use ULONG... |
2438 |
|
19b723218 libata: fix last_... |
2439 2440 2441 2442 2443 2444 2445 2446 2447 |
/* make sure each reset attemp is at least COOL_DOWN apart */ if (ehc->i.flags & ATA_EHI_DID_RESET) { now = jiffies; WARN_ON(time_after(ehc->last_reset, now)); deadline = ata_deadline(ehc->last_reset, ATA_EH_RESET_COOL_DOWN); if (time_before(now, deadline)) schedule_timeout_uninterruptible(deadline - now); } |
0a2c0f561 libata: improve E... |
2448 |
|
afaa5c373 libata: implement... |
2449 2450 2451 |
spin_lock_irqsave(ap->lock, flags); ap->pflags |= ATA_PFLAG_RESETTING; spin_unlock_irqrestore(ap->lock, flags); |
cf4806265 libata: prefer ha... |
2452 |
ata_eh_about_to_do(link, NULL, ATA_EH_RESET); |
13abf50df [PATCH] libata: i... |
2453 |
|
1eca4365b libata: beef up i... |
2454 |
ata_for_each_dev(dev, link, ALL) { |
cdeab1140 libata: relocate ... |
2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 |
/* If we issue an SRST then an ATA drive (not ATAPI) * may change configuration and be in PIO0 timing. If * we do a hard reset (or are coming from power on) * this is true for ATA or ATAPI. Until we've set a * suitable controller mode we should not touch the * bus as we may be talking too fast. */ dev->pio_mode = XFER_PIO_0; /* If the controller has a pio mode setup function * then use it to set the chipset to rights. Don't * touch the DMA setup as that will be dealt with when * configuring devices. */ if (ap->ops->set_piomode) ap->ops->set_piomode(ap, dev); } |
cf4806265 libata: prefer ha... |
2472 |
/* prefer hardreset */ |
932648b00 libata: reorganiz... |
2473 |
reset = NULL; |
cf4806265 libata: prefer ha... |
2474 2475 2476 |
ehc->i.action &= ~ATA_EH_RESET; if (hardreset) { reset = hardreset; |
a674050e0 libata: fix EH ac... |
2477 |
ehc->i.action |= ATA_EH_HARDRESET; |
4f7faa3f2 libata: make EH f... |
2478 |
} else if (softreset) { |
cf4806265 libata: prefer ha... |
2479 |
reset = softreset; |
a674050e0 libata: fix EH ac... |
2480 |
ehc->i.action |= ATA_EH_SOFTRESET; |
cf4806265 libata: prefer ha... |
2481 |
} |
f5914a461 [PATCH] libata-hp... |
2482 2483 |
if (prereset) { |
b1c72916a libata: implement... |
2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 |
unsigned long deadline = ata_deadline(jiffies, ATA_EH_PRERESET_TIMEOUT); if (slave) { sehc->i.action &= ~ATA_EH_RESET; sehc->i.action |= ehc->i.action; } rc = prereset(link, deadline); /* If present, do prereset on slave link too. Reset * is skipped iff both master and slave links report * -ENOENT or clear ATA_EH_RESET. */ if (slave && (rc == 0 || rc == -ENOENT)) { int tmp; tmp = prereset(slave, deadline); if (tmp != -ENOENT) rc = tmp; ehc->i.action |= sehc->i.action; } |
f5914a461 [PATCH] libata-hp... |
2507 |
if (rc) { |
c961922b7 [PATCH] libata-eh... |
2508 |
if (rc == -ENOENT) { |
cc0680a58 libata-link: link... |
2509 |
ata_link_printk(link, KERN_DEBUG, |
4aa9ab67f libata: don't whi... |
2510 2511 |
"port disabled. ignoring. "); |
cf4806265 libata: prefer ha... |
2512 |
ehc->i.action &= ~ATA_EH_RESET; |
4aa9ab67f libata: don't whi... |
2513 |
|
1eca4365b libata: beef up i... |
2514 |
ata_for_each_dev(dev, link, ALL) |
f58229f80 libata-link: impl... |
2515 |
classes[dev->devno] = ATA_DEV_NONE; |
4aa9ab67f libata: don't whi... |
2516 2517 |
rc = 0; |
c961922b7 [PATCH] libata-eh... |
2518 |
} else |
cc0680a58 libata-link: link... |
2519 |
ata_link_printk(link, KERN_ERR, |
f5914a461 [PATCH] libata-hp... |
2520 2521 |
"prereset failed (errno=%d) ", rc); |
fccb6ea5c libata: clear HOT... |
2522 |
goto out; |
f5914a461 [PATCH] libata-hp... |
2523 |
} |
f5914a461 [PATCH] libata-hp... |
2524 |
|
932648b00 libata: reorganiz... |
2525 |
/* prereset() might have cleared ATA_EH_RESET. If so, |
d6515e6ff libata: make sure... |
2526 |
* bang classes, thaw and return. |
932648b00 libata: reorganiz... |
2527 2528 |
*/ if (reset && !(ehc->i.action & ATA_EH_RESET)) { |
1eca4365b libata: beef up i... |
2529 |
ata_for_each_dev(dev, link, ALL) |
932648b00 libata: reorganiz... |
2530 |
classes[dev->devno] = ATA_DEV_NONE; |
d6515e6ff libata: make sure... |
2531 2532 2533 |
if ((ap->pflags & ATA_PFLAG_FROZEN) && ata_is_host_link(link)) ata_eh_thaw_port(ap); |
932648b00 libata: reorganiz... |
2534 2535 2536 |
rc = 0; goto out; } |
f5914a461 [PATCH] libata-hp... |
2537 |
} |
022bdb075 [PATCH] libata-eh... |
2538 |
retry: |
932648b00 libata: reorganiz... |
2539 2540 2541 |
/* * Perform reset */ |
dc98c32cb libata: move rese... |
2542 2543 |
if (ata_is_host_link(link)) ata_eh_freeze_port(ap); |
341c2c958 libata: consisten... |
2544 |
deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]); |
31daabda1 libata: reimpleme... |
2545 |
|
932648b00 libata: reorganiz... |
2546 2547 2548 2549 2550 2551 2552 |
if (reset) { if (verbose) ata_link_printk(link, KERN_INFO, "%s resetting link ", reset == softreset ? "soft" : "hard"); /* mark that this EH session started with reset */ |
19b723218 libata: fix last_... |
2553 |
ehc->last_reset = jiffies; |
932648b00 libata: reorganiz... |
2554 2555 2556 2557 |
if (reset == hardreset) ehc->i.flags |= ATA_EHI_DID_HARDRESET; else ehc->i.flags |= ATA_EHI_DID_SOFTRESET; |
022bdb075 [PATCH] libata-eh... |
2558 |
|
b1c72916a libata: implement... |
2559 2560 2561 |
rc = ata_do_reset(link, reset, classes, deadline, true); if (rc && rc != -EAGAIN) { failed_link = link; |
5dbfc9cb5 libata: always do... |
2562 |
goto fail; |
b1c72916a libata: implement... |
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 |
} /* hardreset slave link if existent */ if (slave && reset == hardreset) { int tmp; if (verbose) ata_link_printk(slave, KERN_INFO, "hard resetting link "); ata_eh_about_to_do(slave, NULL, ATA_EH_RESET); tmp = ata_do_reset(slave, reset, classes, deadline, false); switch (tmp) { case -EAGAIN: rc = -EAGAIN; case 0: break; default: failed_link = slave; rc = tmp; goto fail; } } |
022bdb075 [PATCH] libata-eh... |
2588 |
|
b1c72916a libata: implement... |
2589 |
/* perform follow-up SRST if necessary */ |
932648b00 libata: reorganiz... |
2590 |
if (reset == hardreset && |
5dbfc9cb5 libata: always do... |
2591 |
ata_eh_followup_srst_needed(link, rc, classes)) { |
932648b00 libata: reorganiz... |
2592 |
reset = softreset; |
022bdb075 [PATCH] libata-eh... |
2593 |
|
932648b00 libata: reorganiz... |
2594 2595 2596 2597 2598 |
if (!reset) { ata_link_printk(link, KERN_ERR, "follow-up softreset required " "but no softreset avaliable "); |
b1c72916a libata: implement... |
2599 |
failed_link = link; |
932648b00 libata: reorganiz... |
2600 2601 2602 |
rc = -EINVAL; goto fail; } |
664faf09a [PATCH] libata-hp... |
2603 |
|
932648b00 libata: reorganiz... |
2604 |
ata_eh_about_to_do(link, NULL, ATA_EH_RESET); |
b1c72916a libata: implement... |
2605 |
rc = ata_do_reset(link, reset, classes, deadline, true); |
fe2c4d018 libata: fix follo... |
2606 2607 2608 2609 |
if (rc) { failed_link = link; goto fail; } |
664faf09a [PATCH] libata-hp... |
2610 |
} |
932648b00 libata: reorganiz... |
2611 2612 2613 2614 2615 2616 2617 |
} else { if (verbose) ata_link_printk(link, KERN_INFO, "no reset method " "available, skipping reset "); if (!(lflags & ATA_LFLAG_ASSUME_CLASS)) lflags |= ATA_LFLAG_ASSUME_ATA; |
664faf09a [PATCH] libata-hp... |
2618 |
} |
932648b00 libata: reorganiz... |
2619 2620 2621 |
/* * Post-reset processing */ |
1eca4365b libata: beef up i... |
2622 |
ata_for_each_dev(dev, link, ALL) { |
416dc9ed2 libata: cosmetic ... |
2623 2624 2625 2626 2627 2628 |
/* After the reset, the device state is PIO 0 and the * controller state is undefined. Reset also wakes up * drives from sleeping mode. */ dev->pio_mode = XFER_PIO_0; dev->flags &= ~ATA_DFLAG_SLEEPING; |
31daabda1 libata: reimpleme... |
2629 |
|
3b761d3d4 libata: fix incor... |
2630 2631 2632 2633 2634 2635 2636 2637 |
if (ata_phys_link_offline(ata_dev_phys_link(dev))) continue; /* apply class override */ if (lflags & ATA_LFLAG_ASSUME_ATA) classes[dev->devno] = ATA_DEV_ATA; else if (lflags & ATA_LFLAG_ASSUME_SEMB) classes[dev->devno] = ATA_DEV_SEMB_UNSUP; |
022bdb075 [PATCH] libata-eh... |
2638 |
} |
416dc9ed2 libata: cosmetic ... |
2639 2640 2641 |
/* record current link speed */ if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0) link->sata_spd = (sstatus >> 4) & 0xf; |
b1c72916a libata: implement... |
2642 2643 |
if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0) slave->sata_spd = (sstatus >> 4) & 0xf; |
008a78961 libata: improve S... |
2644 |
|
dc98c32cb libata: move rese... |
2645 2646 2647 |
/* thaw the port */ if (ata_is_host_link(link)) ata_eh_thaw_port(ap); |
f046519fc libata: kill hotp... |
2648 2649 2650 2651 2652 2653 2654 |
/* postreset() should clear hardware SError. Although SError * is cleared during link resume, clearing SError here is * necessary as some PHYs raise hotplug events after SRST. * This introduces race condition where hotplug occurs between * reset and here. This race is mediated by cross checking * link onlineness and classification result later. */ |
b1c72916a libata: implement... |
2655 |
if (postreset) { |
416dc9ed2 libata: cosmetic ... |
2656 |
postreset(link, classes); |
b1c72916a libata: implement... |
2657 2658 2659 |
if (slave) postreset(slave, classes); } |
20952b699 [PATCH] libata: s... |
2660 |
|
1e641060c libata: clear eh_... |
2661 2662 2663 2664 2665 2666 |
/* * Some controllers can't be frozen very well and may set * spuruious error conditions during reset. Clear accumulated * error information. As reset is the final recovery action, * nothing is lost by doing this. */ |
f046519fc libata: kill hotp... |
2667 |
spin_lock_irqsave(link->ap->lock, flags); |
1e641060c libata: clear eh_... |
2668 |
memset(&link->eh_info, 0, sizeof(link->eh_info)); |
b1c72916a libata: implement... |
2669 |
if (slave) |
1e641060c libata: clear eh_... |
2670 2671 |
memset(&slave->eh_info, 0, sizeof(link->eh_info)); ap->pflags &= ~ATA_PFLAG_EH_PENDING; |
f046519fc libata: kill hotp... |
2672 |
spin_unlock_irqrestore(link->ap->lock, flags); |
3b761d3d4 libata: fix incor... |
2673 2674 |
/* * Make sure onlineness and classification result correspond. |
f046519fc libata: kill hotp... |
2675 2676 2677 |
* Hotplug could have happened during reset and some * controllers fail to wait while a drive is spinning up after * being hotplugged causing misdetection. By cross checking |
3b761d3d4 libata: fix incor... |
2678 2679 |
* link on/offlineness and classification result, those * conditions can be reliably detected and retried. |
f046519fc libata: kill hotp... |
2680 |
*/ |
b1c72916a libata: implement... |
2681 |
nr_unknown = 0; |
1eca4365b libata: beef up i... |
2682 |
ata_for_each_dev(dev, link, ALL) { |
3b761d3d4 libata: fix incor... |
2683 2684 2685 2686 2687 2688 |
if (ata_phys_link_online(ata_dev_phys_link(dev))) { if (classes[dev->devno] == ATA_DEV_UNKNOWN) { ata_dev_printk(dev, KERN_DEBUG, "link online " "but device misclassifed "); classes[dev->devno] = ATA_DEV_NONE; |
b1c72916a libata: implement... |
2689 |
nr_unknown++; |
3b761d3d4 libata: fix incor... |
2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 |
} } else if (ata_phys_link_offline(ata_dev_phys_link(dev))) { if (ata_class_enabled(classes[dev->devno])) ata_dev_printk(dev, KERN_DEBUG, "link offline, " "clearing class %d to NONE ", classes[dev->devno]); classes[dev->devno] = ATA_DEV_NONE; } else if (classes[dev->devno] == ATA_DEV_UNKNOWN) { ata_dev_printk(dev, KERN_DEBUG, "link status unknown, " "clearing UNKNOWN to NONE "); classes[dev->devno] = ATA_DEV_NONE; |
b1c72916a libata: implement... |
2703 |
} |
f046519fc libata: kill hotp... |
2704 |
} |
b1c72916a libata: implement... |
2705 |
if (classify && nr_unknown) { |
f046519fc libata: kill hotp... |
2706 2707 |
if (try < max_tries) { ata_link_printk(link, KERN_WARNING, "link online but " |
3b761d3d4 libata: fix incor... |
2708 2709 2710 |
"%d devices misclassified, retrying ", nr_unknown); |
b1c72916a libata: implement... |
2711 |
failed_link = link; |
f046519fc libata: kill hotp... |
2712 2713 2714 2715 |
rc = -EAGAIN; goto fail; } ata_link_printk(link, KERN_WARNING, |
3b761d3d4 libata: fix incor... |
2716 2717 2718 |
"link online but %d devices misclassified, " "device detection might fail ", nr_unknown); |
f046519fc libata: kill hotp... |
2719 |
} |
416dc9ed2 libata: cosmetic ... |
2720 |
/* reset successful, schedule revalidation */ |
cf4806265 libata: prefer ha... |
2721 |
ata_eh_done(link, NULL, ATA_EH_RESET); |
b1c72916a libata: implement... |
2722 2723 |
if (slave) ata_eh_done(slave, NULL, ATA_EH_RESET); |
19b723218 libata: fix last_... |
2724 |
ehc->last_reset = jiffies; /* update to completion time */ |
416dc9ed2 libata: cosmetic ... |
2725 |
ehc->i.action |= ATA_EH_REVALIDATE; |
ae791c056 libata-pmp-prep: ... |
2726 |
|
416dc9ed2 libata: cosmetic ... |
2727 |
rc = 0; |
fccb6ea5c libata: clear HOT... |
2728 2729 2730 |
out: /* clear hotplug flag */ ehc->i.flags &= ~ATA_EHI_HOTPLUGGED; |
b1c72916a libata: implement... |
2731 2732 |
if (slave) sehc->i.flags &= ~ATA_EHI_HOTPLUGGED; |
afaa5c373 libata: implement... |
2733 2734 2735 2736 |
spin_lock_irqsave(ap->lock, flags); ap->pflags &= ~ATA_PFLAG_RESETTING; spin_unlock_irqrestore(ap->lock, flags); |
022bdb075 [PATCH] libata-eh... |
2737 |
return rc; |
416dc9ed2 libata: cosmetic ... |
2738 2739 |
fail: |
5958e3025 libata: move PMP ... |
2740 2741 2742 2743 |
/* if SCR isn't accessible on a fan-out port, PMP needs to be reset */ if (!ata_is_host_link(link) && sata_scr_read(link, SCR_STATUS, &sstatus)) rc = -ERESTART; |
416dc9ed2 libata: cosmetic ... |
2744 2745 2746 2747 2748 2749 |
if (rc == -ERESTART || try >= max_tries) goto out; now = jiffies; if (time_before(now, deadline)) { unsigned long delta = deadline - now; |
b1c72916a libata: implement... |
2750 |
ata_link_printk(failed_link, KERN_WARNING, |
0a2c0f561 libata: improve E... |
2751 2752 2753 |
"reset failed (errno=%d), retrying in %u secs ", rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000)); |
416dc9ed2 libata: cosmetic ... |
2754 2755 2756 2757 |
while (delta) delta = schedule_timeout_uninterruptible(delta); } |
b1c72916a libata: implement... |
2758 |
if (try == max_tries - 1) { |
a07d499b4 libata: add @spd_... |
2759 |
sata_down_spd_limit(link, 0); |
b1c72916a libata: implement... |
2760 |
if (slave) |
a07d499b4 libata: add @spd_... |
2761 |
sata_down_spd_limit(slave, 0); |
b1c72916a libata: implement... |
2762 |
} else if (rc == -EPIPE) |
a07d499b4 libata: add @spd_... |
2763 |
sata_down_spd_limit(failed_link, 0); |
b1c72916a libata: implement... |
2764 |
|
416dc9ed2 libata: cosmetic ... |
2765 2766 2767 |
if (hardreset) reset = hardreset; goto retry; |
022bdb075 [PATCH] libata-eh... |
2768 |
} |
45fabbb77 libata: Implement... |
2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 |
static inline void ata_eh_pull_park_action(struct ata_port *ap) { struct ata_link *link; struct ata_device *dev; unsigned long flags; /* * This function can be thought of as an extended version of * ata_eh_about_to_do() specially crafted to accommodate the * requirements of ATA_EH_PARK handling. Since the EH thread * does not leave the do {} while () loop in ata_eh_recover as * long as the timeout for a park request to *one* device on * the port has not expired, and since we still want to pick * up park requests to other devices on the same port or * timeout updates for the same device, we have to pull * ATA_EH_PARK actions from eh_info into eh_context.i * ourselves at the beginning of each pass over the loop. * * Additionally, all write accesses to &ap->park_req_pending * through INIT_COMPLETION() (see below) or complete_all() * (see ata_scsi_park_store()) are protected by the host lock. * As a result we have that park_req_pending.done is zero on * exit from this function, i.e. when ATA_EH_PARK actions for * *all* devices on port ap have been pulled into the * respective eh_context structs. If, and only if, * park_req_pending.done is non-zero by the time we reach * wait_for_completion_timeout(), another ATA_EH_PARK action * has been scheduled for at least one of the devices on port * ap and we have to cycle over the do {} while () loop in * ata_eh_recover() again. */ spin_lock_irqsave(ap->lock, flags); INIT_COMPLETION(ap->park_req_pending); |
1eca4365b libata: beef up i... |
2803 2804 |
ata_for_each_link(link, ap, EDGE) { ata_for_each_dev(dev, link, ALL) { |
45fabbb77 libata: Implement... |
2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 |
struct ata_eh_info *ehi = &link->eh_info; link->eh_context.i.dev_action[dev->devno] |= ehi->dev_action[dev->devno] & ATA_EH_PARK; ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK); } } spin_unlock_irqrestore(ap->lock, flags); } static void ata_eh_park_issue_cmd(struct ata_device *dev, int park) { struct ata_eh_context *ehc = &dev->link->eh_context; struct ata_taskfile tf; unsigned int err_mask; ata_tf_init(dev, &tf); if (park) { ehc->unloaded_mask |= 1 << dev->devno; tf.command = ATA_CMD_IDLEIMMEDIATE; tf.feature = 0x44; tf.lbal = 0x4c; tf.lbam = 0x4e; tf.lbah = 0x55; } else { ehc->unloaded_mask &= ~(1 << dev->devno); tf.command = ATA_CMD_CHK_POWER; } tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; tf.protocol |= ATA_PROT_NODATA; err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); if (park && (err_mask || tf.lbal != 0xc4)) { ata_dev_printk(dev, KERN_ERR, "head unload failed! "); ehc->unloaded_mask &= ~(1 << dev->devno); } } |
0260731f0 libata-link: link... |
2843 |
static int ata_eh_revalidate_and_attach(struct ata_link *link, |
084fe639b [PATCH] libata-hp... |
2844 |
struct ata_device **r_failed_dev) |
022bdb075 [PATCH] libata-eh... |
2845 |
{ |
0260731f0 libata-link: link... |
2846 2847 |
struct ata_port *ap = link->ap; struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
2848 |
struct ata_device *dev; |
8c3c52a8f libata: IDENTIFY ... |
2849 |
unsigned int new_mask = 0; |
084fe639b [PATCH] libata-hp... |
2850 |
unsigned long flags; |
f58229f80 libata-link: impl... |
2851 |
int rc = 0; |
022bdb075 [PATCH] libata-eh... |
2852 2853 2854 |
DPRINTK("ENTER "); |
8c3c52a8f libata: IDENTIFY ... |
2855 2856 2857 2858 |
/* For PATA drive side cable detection to work, IDENTIFY must * be done backwards such that PDIAG- is released by the slave * device before the master device is identified. */ |
1eca4365b libata: beef up i... |
2859 |
ata_for_each_dev(dev, link, ALL_REVERSE) { |
f58229f80 libata-link: impl... |
2860 2861 |
unsigned int action = ata_eh_dev_action(dev); unsigned int readid_flags = 0; |
022bdb075 [PATCH] libata-eh... |
2862 |
|
bff046476 [PATCH] libata: c... |
2863 2864 |
if (ehc->i.flags & ATA_EHI_DID_RESET) readid_flags |= ATA_READID_POSTRESET; |
9666f4009 libata: reimpleme... |
2865 |
if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) { |
633273a3e libata-pmp: hook ... |
2866 |
WARN_ON(dev->class == ATA_DEV_PMP); |
b1c72916a libata: implement... |
2867 |
if (ata_phys_link_offline(ata_dev_phys_link(dev))) { |
022bdb075 [PATCH] libata-eh... |
2868 |
rc = -EIO; |
8c3c52a8f libata: IDENTIFY ... |
2869 |
goto err; |
022bdb075 [PATCH] libata-eh... |
2870 |
} |
0260731f0 libata-link: link... |
2871 |
ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE); |
422c9daa8 libata-pmp-prep: ... |
2872 2873 |
rc = ata_dev_revalidate(dev, ehc->classes[dev->devno], readid_flags); |
022bdb075 [PATCH] libata-eh... |
2874 |
if (rc) |
8c3c52a8f libata: IDENTIFY ... |
2875 |
goto err; |
022bdb075 [PATCH] libata-eh... |
2876 |
|
0260731f0 libata-link: link... |
2877 |
ata_eh_done(link, dev, ATA_EH_REVALIDATE); |
47005f255 [PATCH] libata: i... |
2878 |
|
baa1e78a8 [PATCH] libata: i... |
2879 2880 2881 2882 |
/* Configuration may have changed, reconfigure * transfer mode. */ ehc->i.flags |= ATA_EHI_SETMODE; |
3057ac3c1 [PATCH] Snoop SET... |
2883 |
/* schedule the scsi_rescan_device() here */ |
ad72cf988 libata: take adva... |
2884 |
schedule_work(&(ap->scsi_rescan_task)); |
084fe639b [PATCH] libata-hp... |
2885 2886 2887 |
} else if (dev->class == ATA_DEV_UNKNOWN && ehc->tries[dev->devno] && ata_class_enabled(ehc->classes[dev->devno])) { |
842faa6c1 libata: fix attac... |
2888 2889 2890 2891 2892 2893 |
/* Temporarily set dev->class, it will be * permanently set once all configurations are * complete. This is necessary because new * device configuration is done in two * separate loops. */ |
084fe639b [PATCH] libata-hp... |
2894 |
dev->class = ehc->classes[dev->devno]; |
633273a3e libata-pmp: hook ... |
2895 2896 2897 2898 2899 |
if (dev->class == ATA_DEV_PMP) rc = sata_pmp_attach(dev); else rc = ata_dev_read_id(dev, &dev->class, readid_flags, dev->id); |
842faa6c1 libata: fix attac... |
2900 2901 2902 2903 |
/* read_id might have changed class, store and reset */ ehc->classes[dev->devno] = dev->class; dev->class = ATA_DEV_UNKNOWN; |
8c3c52a8f libata: IDENTIFY ... |
2904 2905 |
switch (rc) { case 0: |
99cf610aa libata: clear dev... |
2906 2907 |
/* clear error info accumulated during probe */ ata_ering_clear(&dev->ering); |
f58229f80 libata-link: impl... |
2908 |
new_mask |= 1 << dev->devno; |
8c3c52a8f libata: IDENTIFY ... |
2909 2910 |
break; case -ENOENT: |
55a8e2c83 [PATCH] libata: i... |
2911 2912 |
/* IDENTIFY was issued to non-existent * device. No need to reset. Just |
842faa6c1 libata: fix attac... |
2913 |
* thaw and ignore the device. |
55a8e2c83 [PATCH] libata: i... |
2914 2915 |
*/ ata_eh_thaw_port(ap); |
084fe639b [PATCH] libata-hp... |
2916 |
break; |
8c3c52a8f libata: IDENTIFY ... |
2917 |
default: |
8c3c52a8f libata: IDENTIFY ... |
2918 |
goto err; |
084fe639b [PATCH] libata-hp... |
2919 |
} |
8c3c52a8f libata: IDENTIFY ... |
2920 2921 |
} } |
084fe639b [PATCH] libata-hp... |
2922 |
|
c1c4e8d55 libata: add missi... |
2923 |
/* PDIAG- should have been released, ask cable type if post-reset */ |
332673257 libata: implement... |
2924 2925 2926 2927 2928 |
if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) { if (ap->ops->cable_detect) ap->cbl = ap->ops->cable_detect(ap); ata_force_cbl(ap); } |
c1c4e8d55 libata: add missi... |
2929 |
|
8c3c52a8f libata: IDENTIFY ... |
2930 2931 2932 |
/* Configure new devices forward such that user doesn't see * device detection messages backwards. */ |
1eca4365b libata: beef up i... |
2933 |
ata_for_each_dev(dev, link, ALL) { |
4f7c28749 libata: fix PMP i... |
2934 |
if (!(new_mask & (1 << dev->devno))) |
8c3c52a8f libata: IDENTIFY ... |
2935 |
continue; |
842faa6c1 libata: fix attac... |
2936 |
dev->class = ehc->classes[dev->devno]; |
4f7c28749 libata: fix PMP i... |
2937 2938 |
if (dev->class == ATA_DEV_PMP) continue; |
8c3c52a8f libata: IDENTIFY ... |
2939 2940 2941 |
ehc->i.flags |= ATA_EHI_PRINTINFO; rc = ata_dev_configure(dev); ehc->i.flags &= ~ATA_EHI_PRINTINFO; |
842faa6c1 libata: fix attac... |
2942 2943 |
if (rc) { dev->class = ATA_DEV_UNKNOWN; |
8c3c52a8f libata: IDENTIFY ... |
2944 |
goto err; |
842faa6c1 libata: fix attac... |
2945 |
} |
8c3c52a8f libata: IDENTIFY ... |
2946 2947 2948 2949 2950 2951 2952 |
spin_lock_irqsave(ap->lock, flags); ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG; spin_unlock_irqrestore(ap->lock, flags); /* new device discovered, configure xfermode */ ehc->i.flags |= ATA_EHI_SETMODE; |
022bdb075 [PATCH] libata-eh... |
2953 |
} |
8c3c52a8f libata: IDENTIFY ... |
2954 |
return 0; |
022bdb075 [PATCH] libata-eh... |
2955 |
|
8c3c52a8f libata: IDENTIFY ... |
2956 2957 2958 2959 |
err: *r_failed_dev = dev; DPRINTK("EXIT rc=%d ", rc); |
022bdb075 [PATCH] libata-eh... |
2960 2961 |
return rc; } |
6f1d1e3a0 libata: move ata_... |
2962 2963 2964 |
/** * ata_set_mode - Program timings and issue SET FEATURES - XFER * @link: link on which timings will be programmed |
98a1708de trivial: fix typo... |
2965 |
* @r_failed_dev: out parameter for failed device |
6f1d1e3a0 libata: move ata_... |
2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 |
* * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If * ata_set_mode() fails, pointer to the failing device is * returned in @r_failed_dev. * * LOCKING: * PCI/etc. bus probe sem. * * RETURNS: * 0 on success, negative errno otherwise */ int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev) { struct ata_port *ap = link->ap; |
00115e0f5 libata: implement... |
2980 2981 |
struct ata_device *dev; int rc; |
6f1d1e3a0 libata: move ata_... |
2982 |
|
76326ac1a libata: implement... |
2983 |
/* if data transfer is verified, clear DUBIOUS_XFER on ering top */ |
1eca4365b libata: beef up i... |
2984 |
ata_for_each_dev(dev, link, ENABLED) { |
76326ac1a libata: implement... |
2985 2986 2987 2988 2989 2990 2991 2992 |
if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) { struct ata_ering_entry *ent; ent = ata_ering_top(&dev->ering); if (ent) ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER; } } |
6f1d1e3a0 libata: move ata_... |
2993 2994 |
/* has private set_mode? */ if (ap->ops->set_mode) |
00115e0f5 libata: implement... |
2995 2996 2997 2998 2999 |
rc = ap->ops->set_mode(link, r_failed_dev); else rc = ata_do_set_mode(link, r_failed_dev); /* if transfer mode has changed, set DUBIOUS_XFER on device */ |
1eca4365b libata: beef up i... |
3000 |
ata_for_each_dev(dev, link, ENABLED) { |
00115e0f5 libata: implement... |
3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 |
struct ata_eh_context *ehc = &link->eh_context; u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno]; u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno)); if (dev->xfer_mode != saved_xfer_mode || ata_ncq_enabled(dev) != saved_ncq) dev->flags |= ATA_DFLAG_DUBIOUS_XFER; } return rc; |
6f1d1e3a0 libata: move ata_... |
3011 |
} |
11fc33da8 libata-eh: clear ... |
3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 |
/** * atapi_eh_clear_ua - Clear ATAPI UNIT ATTENTION after reset * @dev: ATAPI device to clear UA for * * Resets and other operations can make an ATAPI device raise * UNIT ATTENTION which causes the next operation to fail. This * function clears UA. * * LOCKING: * EH context (may sleep). * * RETURNS: * 0 on success, -errno on failure. */ static int atapi_eh_clear_ua(struct ata_device *dev) { int i; for (i = 0; i < ATA_EH_UA_TRIES; i++) { |
b53570814 libata: don't use... |
3031 |
u8 *sense_buffer = dev->link->ap->sector_buf; |
11fc33da8 libata-eh: clear ... |
3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 |
u8 sense_key = 0; unsigned int err_mask; err_mask = atapi_eh_tur(dev, &sense_key); if (err_mask != 0 && err_mask != AC_ERR_DEV) { ata_dev_printk(dev, KERN_WARNING, "TEST_UNIT_READY " "failed (err_mask=0x%x) ", err_mask); return -EIO; } if (!err_mask || sense_key != UNIT_ATTENTION) return 0; err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key); if (err_mask) { ata_dev_printk(dev, KERN_WARNING, "failed to clear " "UNIT ATTENTION (err_mask=0x%x) ", err_mask); return -EIO; } } ata_dev_printk(dev, KERN_WARNING, "UNIT ATTENTION persists after %d tries ", ATA_EH_UA_TRIES); return 0; } |
6013efd88 libata: retry fai... |
3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 |
/** * ata_eh_maybe_retry_flush - Retry FLUSH if necessary * @dev: ATA device which may need FLUSH retry * * If @dev failed FLUSH, it needs to be reported upper layer * immediately as it means that @dev failed to remap and already * lost at least a sector and further FLUSH retrials won't make * any difference to the lost sector. However, if FLUSH failed * for other reasons, for example transmission error, FLUSH needs * to be retried. * * This function determines whether FLUSH failure retry is * necessary and performs it if so. * * RETURNS: * 0 if EH can continue, -errno if EH needs to be repeated. */ static int ata_eh_maybe_retry_flush(struct ata_device *dev) { struct ata_link *link = dev->link; struct ata_port *ap = link->ap; struct ata_queued_cmd *qc; struct ata_taskfile tf; unsigned int err_mask; int rc = 0; /* did flush fail for this device? */ if (!ata_tag_valid(link->active_tag)) return 0; qc = __ata_qc_from_tag(ap, link->active_tag); if (qc->dev != dev || (qc->tf.command != ATA_CMD_FLUSH_EXT && qc->tf.command != ATA_CMD_FLUSH)) return 0; /* if the device failed it, it should be reported to upper layers */ if (qc->err_mask & AC_ERR_DEV) return 0; /* flush failed for some other reason, give it another shot */ ata_tf_init(dev, &tf); tf.command = qc->tf.command; tf.flags |= ATA_TFLAG_DEVICE; tf.protocol = ATA_PROT_NODATA; ata_dev_printk(dev, KERN_WARNING, "retrying FLUSH 0x%x Emask 0x%x ", tf.command, qc->err_mask); err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); if (!err_mask) { /* * FLUSH is complete but there's no way to * successfully complete a failed command from EH. * Making sure retry is allowed at least once and * retrying it should do the trick - whatever was in * the cache is already on the platter and this won't * cause infinite loop. */ qc->scsicmd->allowed = max(qc->scsicmd->allowed, 1); } else { ata_dev_printk(dev, KERN_WARNING, "FLUSH failed Emask 0x%x ", err_mask); rc = -EIO; /* if device failed it, report it to upper layers */ if (err_mask & AC_ERR_DEV) { qc->err_mask |= AC_ERR_DEV; qc->result_tf = tf; if (!(ap->pflags & ATA_PFLAG_FROZEN)) rc = 0; } } return rc; } |
0260731f0 libata-link: link... |
3138 |
static int ata_link_nr_enabled(struct ata_link *link) |
022bdb075 [PATCH] libata-eh... |
3139 |
{ |
f58229f80 libata-link: impl... |
3140 3141 |
struct ata_device *dev; int cnt = 0; |
022bdb075 [PATCH] libata-eh... |
3142 |
|
1eca4365b libata: beef up i... |
3143 3144 |
ata_for_each_dev(dev, link, ENABLED) cnt++; |
022bdb075 [PATCH] libata-eh... |
3145 3146 |
return cnt; } |
0260731f0 libata-link: link... |
3147 |
static int ata_link_nr_vacant(struct ata_link *link) |
084fe639b [PATCH] libata-hp... |
3148 |
{ |
f58229f80 libata-link: impl... |
3149 3150 |
struct ata_device *dev; int cnt = 0; |
084fe639b [PATCH] libata-hp... |
3151 |
|
1eca4365b libata: beef up i... |
3152 |
ata_for_each_dev(dev, link, ALL) |
f58229f80 libata-link: impl... |
3153 |
if (dev->class == ATA_DEV_UNKNOWN) |
084fe639b [PATCH] libata-hp... |
3154 3155 3156 |
cnt++; return cnt; } |
0260731f0 libata-link: link... |
3157 |
static int ata_eh_skip_recovery(struct ata_link *link) |
084fe639b [PATCH] libata-hp... |
3158 |
{ |
672b2d65b libata: kill ATA_... |
3159 |
struct ata_port *ap = link->ap; |
0260731f0 libata-link: link... |
3160 |
struct ata_eh_context *ehc = &link->eh_context; |
f58229f80 libata-link: impl... |
3161 |
struct ata_device *dev; |
084fe639b [PATCH] libata-hp... |
3162 |
|
f9df58cb2 libata-pmp-prep: ... |
3163 3164 3165 |
/* skip disabled links */ if (link->flags & ATA_LFLAG_DISABLED) return 1; |
672b2d65b libata: kill ATA_... |
3166 3167 3168 3169 3170 3171 3172 |
/* thaw frozen port and recover failed devices */ if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link)) return 0; /* reset at least once if reset is requested */ if ((ehc->i.action & ATA_EH_RESET) && !(ehc->i.flags & ATA_EHI_DID_RESET)) |
084fe639b [PATCH] libata-hp... |
3173 3174 3175 |
return 0; /* skip if class codes for all vacant slots are ATA_DEV_NONE */ |
1eca4365b libata: beef up i... |
3176 |
ata_for_each_dev(dev, link, ALL) { |
084fe639b [PATCH] libata-hp... |
3177 3178 3179 3180 3181 3182 3183 |
if (dev->class == ATA_DEV_UNKNOWN && ehc->classes[dev->devno] != ATA_DEV_NONE) return 0; } return 1; } |
c2c7a89c5 libata: improve p... |
3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 |
static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg) { u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL); u64 now = get_jiffies_64(); int *trials = void_arg; if (ent->timestamp < now - min(now, interval)) return -1; (*trials)++; return 0; } |
02c05a27e libata: factor ou... |
3196 3197 3198 |
static int ata_eh_schedule_probe(struct ata_device *dev) { struct ata_eh_context *ehc = &dev->link->eh_context; |
c2c7a89c5 libata: improve p... |
3199 3200 |
struct ata_link *link = ata_dev_phys_link(dev); int trials = 0; |
02c05a27e libata: factor ou... |
3201 3202 3203 3204 3205 3206 3207 3208 |
if (!(ehc->i.probe_mask & (1 << dev->devno)) || (ehc->did_probe_mask & (1 << dev->devno))) return 0; ata_eh_detach_dev(dev); ata_dev_init(dev); ehc->did_probe_mask |= (1 << dev->devno); |
cf4806265 libata: prefer ha... |
3209 |
ehc->i.action |= ATA_EH_RESET; |
00115e0f5 libata: implement... |
3210 3211 |
ehc->saved_xfer_mode[dev->devno] = 0; ehc->saved_ncq_enabled &= ~(1 << dev->devno); |
02c05a27e libata: factor ou... |
3212 |
|
c2c7a89c5 libata: improve p... |
3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 |
/* Record and count probe trials on the ering. The specific * error mask used is irrelevant. Because a successful device * detection clears the ering, this count accumulates only if * there are consecutive failed probes. * * If the count is equal to or higher than ATA_EH_PROBE_TRIALS * in the last ATA_EH_PROBE_TRIAL_INTERVAL, link speed is * forced to 1.5Gbps. * * This is to work around cases where failed link speed * negotiation results in device misdetection leading to * infinite DEVXCHG or PHRDY CHG events. */ ata_ering_record(&dev->ering, 0, AC_ERR_OTHER); ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials); if (trials > ATA_EH_PROBE_TRIALS) sata_down_spd_limit(link, 1); |
02c05a27e libata: factor ou... |
3231 3232 |
return 1; } |
9b1e2658f libata-link: upda... |
3233 |
static int ata_eh_handle_dev_fail(struct ata_device *dev, int err) |
fee7ca72d libata-link: sepa... |
3234 |
{ |
9af5c9c97 libata-link: intr... |
3235 |
struct ata_eh_context *ehc = &dev->link->eh_context; |
fee7ca72d libata-link: sepa... |
3236 |
|
cf9a590a9 libata: add no pe... |
3237 3238 3239 3240 3241 |
/* -EAGAIN from EH routine indicates retry without prejudice. * The requester is responsible for ensuring forward progress. */ if (err != -EAGAIN) ehc->tries[dev->devno]--; |
fee7ca72d libata-link: sepa... |
3242 3243 3244 3245 3246 3247 3248 3249 3250 |
switch (err) { case -ENODEV: /* device missing or wrong IDENTIFY data, schedule probing */ ehc->i.probe_mask |= (1 << dev->devno); case -EINVAL: /* give it just one more chance */ ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1); case -EIO: |
d89293abd libata: fix EH de... |
3251 |
if (ehc->tries[dev->devno] == 1) { |
fee7ca72d libata-link: sepa... |
3252 3253 3254 |
/* This is the last chance, better to slow * down than lose it. */ |
a07d499b4 libata: add @spd_... |
3255 |
sata_down_spd_limit(ata_dev_phys_link(dev), 0); |
d89293abd libata: fix EH de... |
3256 3257 |
if (dev->pio_mode > XFER_PIO_0) ata_down_xfermask_limit(dev, ATA_DNXFER_PIO); |
fee7ca72d libata-link: sepa... |
3258 3259 3260 3261 3262 3263 3264 3265 |
} } if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) { /* disable device if it has used up all its chances */ ata_dev_disable(dev); /* detach if offline */ |
b1c72916a libata: implement... |
3266 |
if (ata_phys_link_offline(ata_dev_phys_link(dev))) |
fee7ca72d libata-link: sepa... |
3267 |
ata_eh_detach_dev(dev); |
02c05a27e libata: factor ou... |
3268 |
/* schedule probe if necessary */ |
87fbc5a06 libata: improve E... |
3269 |
if (ata_eh_schedule_probe(dev)) { |
fee7ca72d libata-link: sepa... |
3270 |
ehc->tries[dev->devno] = ATA_EH_DEV_TRIES; |
87fbc5a06 libata: improve E... |
3271 3272 3273 |
memset(ehc->cmd_timeout_idx[dev->devno], 0, sizeof(ehc->cmd_timeout_idx[dev->devno])); } |
9b1e2658f libata-link: upda... |
3274 3275 |
return 1; |
fee7ca72d libata-link: sepa... |
3276 |
} else { |
cf4806265 libata: prefer ha... |
3277 |
ehc->i.action |= ATA_EH_RESET; |
9b1e2658f libata-link: upda... |
3278 |
return 0; |
fee7ca72d libata-link: sepa... |
3279 3280 |
} } |
022bdb075 [PATCH] libata-eh... |
3281 3282 3283 |
/** * ata_eh_recover - recover host port after error * @ap: host port to recover |
f5914a461 [PATCH] libata-hp... |
3284 |
* @prereset: prereset method (can be NULL) |
022bdb075 [PATCH] libata-eh... |
3285 3286 3287 |
* @softreset: softreset method (can be NULL) * @hardreset: hardreset method (can be NULL) * @postreset: postreset method (can be NULL) |
9b1e2658f libata-link: upda... |
3288 |
* @r_failed_link: out parameter for failed link |
022bdb075 [PATCH] libata-eh... |
3289 3290 3291 |
* * This is the alpha and omega, eum and yang, heart and soul of * libata exception handling. On entry, actions required to |
9b1e2658f libata-link: upda... |
3292 3293 3294 |
* recover each link and hotplug requests are recorded in the * link's eh_context. This function executes all the operations * with appropriate retrials and fallbacks to resurrect failed |
084fe639b [PATCH] libata-hp... |
3295 |
* devices, detach goners and greet newcomers. |
022bdb075 [PATCH] libata-eh... |
3296 3297 3298 3299 3300 3301 3302 |
* * LOCKING: * Kernel thread context (may sleep). * * RETURNS: * 0 on success, -errno on failure. */ |
fb7fd6145 libata-pmp-prep: ... |
3303 3304 3305 3306 |
int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset, ata_reset_fn_t softreset, ata_reset_fn_t hardreset, ata_postreset_fn_t postreset, struct ata_link **r_failed_link) |
022bdb075 [PATCH] libata-eh... |
3307 |
{ |
9b1e2658f libata-link: upda... |
3308 |
struct ata_link *link; |
022bdb075 [PATCH] libata-eh... |
3309 |
struct ata_device *dev; |
0a2c0f561 libata: improve E... |
3310 |
int nr_failed_devs; |
dc98c32cb libata: move rese... |
3311 |
int rc; |
45fabbb77 libata: Implement... |
3312 |
unsigned long flags, deadline; |
022bdb075 [PATCH] libata-eh... |
3313 3314 3315 3316 3317 |
DPRINTK("ENTER "); /* prep for recovery */ |
1eca4365b libata: beef up i... |
3318 |
ata_for_each_link(link, ap, EDGE) { |
9b1e2658f libata-link: upda... |
3319 |
struct ata_eh_context *ehc = &link->eh_context; |
084fe639b [PATCH] libata-hp... |
3320 |
|
f9df58cb2 libata-pmp-prep: ... |
3321 3322 3323 3324 3325 3326 3327 3328 |
/* re-enable link? */ if (ehc->i.action & ATA_EH_ENABLE_LINK) { ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK); spin_lock_irqsave(ap->lock, flags); link->flags &= ~ATA_LFLAG_DISABLED; spin_unlock_irqrestore(ap->lock, flags); ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK); } |
1eca4365b libata: beef up i... |
3329 |
ata_for_each_dev(dev, link, ALL) { |
fd995f703 libata-pmp-prep: ... |
3330 3331 3332 3333 |
if (link->flags & ATA_LFLAG_NO_RETRY) ehc->tries[dev->devno] = 1; else ehc->tries[dev->devno] = ATA_EH_DEV_TRIES; |
084fe639b [PATCH] libata-hp... |
3334 |
|
9b1e2658f libata-link: upda... |
3335 3336 3337 3338 3339 3340 3341 3342 |
/* collect port action mask recorded in dev actions */ ehc->i.action |= ehc->i.dev_action[dev->devno] & ~ATA_EH_PERDEV_MASK; ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK; /* process hotplug request */ if (dev->flags & ATA_DFLAG_DETACH) ata_eh_detach_dev(dev); |
02c05a27e libata: factor ou... |
3343 3344 3345 |
/* schedule probe if necessary */ if (!ata_dev_enabled(dev)) ata_eh_schedule_probe(dev); |
084fe639b [PATCH] libata-hp... |
3346 |
} |
022bdb075 [PATCH] libata-eh... |
3347 3348 3349 |
} retry: |
022bdb075 [PATCH] libata-eh... |
3350 |
rc = 0; |
9b1e2658f libata-link: upda... |
3351 |
nr_failed_devs = 0; |
022bdb075 [PATCH] libata-eh... |
3352 |
|
aeb2ecd60 [PATCH] libata: f... |
3353 |
/* if UNLOADING, finish immediately */ |
b51e9e5db [PATCH] libata: a... |
3354 |
if (ap->pflags & ATA_PFLAG_UNLOADING) |
aeb2ecd60 [PATCH] libata: f... |
3355 |
goto out; |
9b1e2658f libata-link: upda... |
3356 |
/* prep for EH */ |
1eca4365b libata: beef up i... |
3357 |
ata_for_each_link(link, ap, EDGE) { |
9b1e2658f libata-link: upda... |
3358 |
struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
3359 |
|
9b1e2658f libata-link: upda... |
3360 3361 3362 |
/* skip EH if possible. */ if (ata_eh_skip_recovery(link)) ehc->i.action = 0; |
1eca4365b libata: beef up i... |
3363 |
ata_for_each_dev(dev, link, ALL) |
9b1e2658f libata-link: upda... |
3364 3365 |
ehc->classes[dev->devno] = ATA_DEV_UNKNOWN; } |
084fe639b [PATCH] libata-hp... |
3366 |
|
022bdb075 [PATCH] libata-eh... |
3367 |
/* reset */ |
1eca4365b libata: beef up i... |
3368 |
ata_for_each_link(link, ap, EDGE) { |
dc98c32cb libata: move rese... |
3369 |
struct ata_eh_context *ehc = &link->eh_context; |
9b1e2658f libata-link: upda... |
3370 |
|
dc98c32cb libata: move rese... |
3371 3372 |
if (!(ehc->i.action & ATA_EH_RESET)) continue; |
9b1e2658f libata-link: upda... |
3373 |
|
dc98c32cb libata: move rese... |
3374 3375 3376 3377 3378 3379 3380 |
rc = ata_eh_reset(link, ata_link_nr_vacant(link), prereset, softreset, hardreset, postreset); if (rc) { ata_link_printk(link, KERN_ERR, "reset failed, giving up "); goto out; |
022bdb075 [PATCH] libata-eh... |
3381 |
} |
022bdb075 [PATCH] libata-eh... |
3382 |
} |
45fabbb77 libata: Implement... |
3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 |
do { unsigned long now; /* * clears ATA_EH_PARK in eh_info and resets * ap->park_req_pending */ ata_eh_pull_park_action(ap); deadline = jiffies; |
1eca4365b libata: beef up i... |
3393 3394 |
ata_for_each_link(link, ap, EDGE) { ata_for_each_dev(dev, link, ALL) { |
45fabbb77 libata: Implement... |
3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 |
struct ata_eh_context *ehc = &link->eh_context; unsigned long tmp; if (dev->class != ATA_DEV_ATA) continue; if (!(ehc->i.dev_action[dev->devno] & ATA_EH_PARK)) continue; tmp = dev->unpark_deadline; if (time_before(deadline, tmp)) deadline = tmp; else if (time_before_eq(tmp, jiffies)) continue; if (ehc->unloaded_mask & (1 << dev->devno)) continue; ata_eh_park_issue_cmd(dev, 1); } } now = jiffies; if (time_before_eq(deadline, now)) break; deadline = wait_for_completion_timeout(&ap->park_req_pending, deadline - now); } while (deadline); |
1eca4365b libata: beef up i... |
3422 3423 |
ata_for_each_link(link, ap, EDGE) { ata_for_each_dev(dev, link, ALL) { |
45fabbb77 libata: Implement... |
3424 3425 3426 3427 3428 3429 3430 3431 |
if (!(link->eh_context.unloaded_mask & (1 << dev->devno))) continue; ata_eh_park_issue_cmd(dev, 0); ata_eh_done(link, dev, ATA_EH_PARK); } } |
9b1e2658f libata-link: upda... |
3432 |
/* the rest */ |
1eca4365b libata: beef up i... |
3433 |
ata_for_each_link(link, ap, EDGE) { |
9b1e2658f libata-link: upda... |
3434 |
struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
3435 |
|
9b1e2658f libata-link: upda... |
3436 3437 |
/* revalidate existing devices and attach new ones */ rc = ata_eh_revalidate_and_attach(link, &dev); |
4ae72a1e4 libata: improve p... |
3438 |
if (rc) |
022bdb075 [PATCH] libata-eh... |
3439 |
goto dev_fail; |
022bdb075 [PATCH] libata-eh... |
3440 |
|
633273a3e libata-pmp: hook ... |
3441 3442 3443 3444 3445 |
/* if PMP got attached, return, pmp EH will take care of it */ if (link->device->class == ATA_DEV_PMP) { ehc->i.action = 0; return 0; } |
9b1e2658f libata-link: upda... |
3446 3447 3448 3449 3450 3451 3452 |
/* configure transfer mode if necessary */ if (ehc->i.flags & ATA_EHI_SETMODE) { rc = ata_set_mode(link, &dev); if (rc) goto dev_fail; ehc->i.flags &= ~ATA_EHI_SETMODE; } |
11fc33da8 libata-eh: clear ... |
3453 3454 3455 3456 |
/* If reset has been issued, clear UA to avoid * disrupting the current users of the device. */ if (ehc->i.flags & ATA_EHI_DID_RESET) { |
1eca4365b libata: beef up i... |
3457 |
ata_for_each_dev(dev, link, ALL) { |
11fc33da8 libata-eh: clear ... |
3458 3459 3460 3461 3462 3463 3464 |
if (dev->class != ATA_DEV_ATAPI) continue; rc = atapi_eh_clear_ua(dev); if (rc) goto dev_fail; } } |
6013efd88 libata: retry fai... |
3465 3466 3467 3468 3469 3470 3471 3472 |
/* retry flush if necessary */ ata_for_each_dev(dev, link, ALL) { if (dev->class != ATA_DEV_ATA) continue; rc = ata_eh_maybe_retry_flush(dev); if (rc) goto dev_fail; } |
11fc33da8 libata-eh: clear ... |
3473 |
/* configure link power saving */ |
3ec25ebd6 libata: ATA_EHI_L... |
3474 |
if (ehc->i.action & ATA_EH_LPM) |
1eca4365b libata: beef up i... |
3475 |
ata_for_each_dev(dev, link, ALL) |
ca77329fb [libata] Link pow... |
3476 |
ata_dev_enable_pm(dev, ap->pm_policy); |
9b1e2658f libata-link: upda... |
3477 3478 3479 |
/* this link is okay now */ ehc->i.flags = 0; continue; |
022bdb075 [PATCH] libata-eh... |
3480 |
|
2dcb407e6 [libata] checkpat... |
3481 |
dev_fail: |
9b1e2658f libata-link: upda... |
3482 |
nr_failed_devs++; |
0a2c0f561 libata: improve E... |
3483 |
ata_eh_handle_dev_fail(dev, rc); |
022bdb075 [PATCH] libata-eh... |
3484 |
|
b06ce3e51 libata: use ata_e... |
3485 3486 3487 3488 |
if (ap->pflags & ATA_PFLAG_FROZEN) { /* PMP reset requires working host port. * Can't retry if it's frozen. */ |
071f44b1d libata: implement... |
3489 |
if (sata_pmp_attached(ap)) |
b06ce3e51 libata: use ata_e... |
3490 |
goto out; |
9b1e2658f libata-link: upda... |
3491 |
break; |
b06ce3e51 libata: use ata_e... |
3492 |
} |
022bdb075 [PATCH] libata-eh... |
3493 |
} |
0a2c0f561 libata: improve E... |
3494 |
if (nr_failed_devs) |
9b1e2658f libata-link: upda... |
3495 |
goto retry; |
022bdb075 [PATCH] libata-eh... |
3496 |
|
9b1e2658f libata-link: upda... |
3497 3498 3499 |
out: if (rc && r_failed_link) *r_failed_link = link; |
022bdb075 [PATCH] libata-eh... |
3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 |
DPRINTK("EXIT, rc=%d ", rc); return rc; } /** * ata_eh_finish - finish up EH * @ap: host port to finish EH for * * Recovery is complete. Clean up EH states and retry or finish * failed qcs. * * LOCKING: * None. */ |
fb7fd6145 libata-pmp-prep: ... |
3515 |
void ata_eh_finish(struct ata_port *ap) |
022bdb075 [PATCH] libata-eh... |
3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 |
{ int tag; /* retry or finish qcs */ for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); if (!(qc->flags & ATA_QCFLAG_FAILED)) continue; if (qc->err_mask) { /* FIXME: Once EH migration is complete, * generate sense data in this function, * considering both err_mask and tf. */ |
03faab782 libata: implement... |
3531 |
if (qc->flags & ATA_QCFLAG_RETRY) |
022bdb075 [PATCH] libata-eh... |
3532 |
ata_eh_qc_retry(qc); |
03faab782 libata: implement... |
3533 3534 |
else ata_eh_qc_complete(qc); |
022bdb075 [PATCH] libata-eh... |
3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 |
} else { if (qc->flags & ATA_QCFLAG_SENSE_VALID) { ata_eh_qc_complete(qc); } else { /* feed zero TF to sense generation */ memset(&qc->result_tf, 0, sizeof(qc->result_tf)); ata_eh_qc_retry(qc); } } } |
da917d69d libata-pmp-prep: ... |
3545 3546 3547 3548 |
/* make sure nr_active_links is zero after EH */ WARN_ON(ap->nr_active_links); ap->nr_active_links = 0; |
022bdb075 [PATCH] libata-eh... |
3549 3550 3551 3552 3553 |
} /** * ata_do_eh - do standard error handling * @ap: host port to handle error for |
a1efdaba2 libata: make rese... |
3554 |
* |
f5914a461 [PATCH] libata-hp... |
3555 |
* @prereset: prereset method (can be NULL) |
022bdb075 [PATCH] libata-eh... |
3556 3557 3558 3559 3560 3561 3562 3563 3564 |
* @softreset: softreset method (can be NULL) * @hardreset: hardreset method (can be NULL) * @postreset: postreset method (can be NULL) * * Perform standard error handling sequence. * * LOCKING: * Kernel thread context (may sleep). */ |
f5914a461 [PATCH] libata-hp... |
3565 3566 3567 |
void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset, ata_reset_fn_t softreset, ata_reset_fn_t hardreset, ata_postreset_fn_t postreset) |
022bdb075 [PATCH] libata-eh... |
3568 |
{ |
9b1e2658f libata-link: upda... |
3569 3570 3571 3572 3573 3574 3575 3576 3577 |
struct ata_device *dev; int rc; ata_eh_autopsy(ap); ata_eh_report(ap); rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset, NULL); if (rc) { |
1eca4365b libata: beef up i... |
3578 |
ata_for_each_dev(dev, &ap->link, ALL) |
9b1e2658f libata-link: upda... |
3579 3580 |
ata_dev_disable(dev); } |
022bdb075 [PATCH] libata-eh... |
3581 3582 |
ata_eh_finish(ap); } |
500530f65 [PATCH] libata: r... |
3583 |
|
a1efdaba2 libata: make rese... |
3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 |
/** * ata_std_error_handler - standard error handler * @ap: host port to handle error for * * Standard error handler * * LOCKING: * Kernel thread context (may sleep). */ void ata_std_error_handler(struct ata_port *ap) { struct ata_port_operations *ops = ap->ops; ata_reset_fn_t hardreset = ops->hardreset; |
57c9efdfb libata: implement... |
3597 |
/* ignore built-in hardreset if SCR access is not available */ |
fe06e5f9b libata-sff: separ... |
3598 |
if (hardreset == sata_std_hardreset && !sata_scr_valid(&ap->link)) |
a1efdaba2 libata: make rese... |
3599 3600 3601 3602 |
hardreset = NULL; ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset); } |
6ffa01d88 libata: add CONFI... |
3603 |
#ifdef CONFIG_PM |
500530f65 [PATCH] libata: r... |
3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 |
/** * ata_eh_handle_port_suspend - perform port suspend operation * @ap: port to suspend * * Suspend @ap. * * LOCKING: * Kernel thread context (may sleep). */ static void ata_eh_handle_port_suspend(struct ata_port *ap) { unsigned long flags; int rc = 0; /* are we suspending? */ spin_lock_irqsave(ap->lock, flags); if (!(ap->pflags & ATA_PFLAG_PM_PENDING) || ap->pm_mesg.event == PM_EVENT_ON) { spin_unlock_irqrestore(ap->lock, flags); return; } spin_unlock_irqrestore(ap->lock, flags); WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED); |
64578a3de libata-acpi: impl... |
3628 3629 3630 3631 |
/* tell ACPI we're suspending */ rc = ata_acpi_on_suspend(ap); if (rc) goto out; |
500530f65 [PATCH] libata: r... |
3632 3633 3634 3635 3636 |
/* suspend */ ata_eh_freeze_port(ap); if (ap->ops->port_suspend) rc = ap->ops->port_suspend(ap, ap->pm_mesg); |
bd3adca52 libata-acpi: add ... |
3637 |
ata_acpi_set_state(ap, PMSG_SUSPEND); |
64578a3de libata-acpi: impl... |
3638 |
out: |
500530f65 [PATCH] libata: r... |
3639 3640 3641 3642 3643 3644 |
/* report result */ spin_lock_irqsave(ap->lock, flags); ap->pflags &= ~ATA_PFLAG_PM_PENDING; if (rc == 0) ap->pflags |= ATA_PFLAG_SUSPENDED; |
64578a3de libata-acpi: impl... |
3645 |
else if (ap->pflags & ATA_PFLAG_FROZEN) |
500530f65 [PATCH] libata: r... |
3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 |
ata_port_schedule_eh(ap); if (ap->pm_result) { *ap->pm_result = rc; ap->pm_result = NULL; } spin_unlock_irqrestore(ap->lock, flags); return; } /** * ata_eh_handle_port_resume - perform port resume operation * @ap: port to resume * * Resume @ap. * |
500530f65 [PATCH] libata: r... |
3664 3665 3666 3667 3668 |
* LOCKING: * Kernel thread context (may sleep). */ static void ata_eh_handle_port_resume(struct ata_port *ap) { |
6f9c1ea2c libata: clear eri... |
3669 3670 |
struct ata_link *link; struct ata_device *dev; |
500530f65 [PATCH] libata: r... |
3671 |
unsigned long flags; |
9666f4009 libata: reimpleme... |
3672 |
int rc = 0; |
500530f65 [PATCH] libata: r... |
3673 3674 3675 3676 3677 3678 3679 3680 3681 |
/* are we resuming? */ spin_lock_irqsave(ap->lock, flags); if (!(ap->pflags & ATA_PFLAG_PM_PENDING) || ap->pm_mesg.event != PM_EVENT_ON) { spin_unlock_irqrestore(ap->lock, flags); return; } spin_unlock_irqrestore(ap->lock, flags); |
9666f4009 libata: reimpleme... |
3682 |
WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED)); |
500530f65 [PATCH] libata: r... |
3683 |
|
6f9c1ea2c libata: clear eri... |
3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 |
/* * Error timestamps are in jiffies which doesn't run while * suspended and PHY events during resume isn't too uncommon. * When the two are combined, it can lead to unnecessary speed * downs if the machine is suspended and resumed repeatedly. * Clear error history. */ ata_for_each_link(link, ap, HOST_FIRST) ata_for_each_dev(dev, link, ALL) ata_ering_clear(&dev->ering); |
bd3adca52 libata-acpi: add ... |
3694 |
ata_acpi_set_state(ap, PMSG_ON); |
500530f65 [PATCH] libata: r... |
3695 3696 |
if (ap->ops->port_resume) rc = ap->ops->port_resume(ap); |
6746544c3 libata: reimpleme... |
3697 3698 |
/* tell ACPI that we're resuming */ ata_acpi_on_resume(ap); |
9666f4009 libata: reimpleme... |
3699 |
/* report result */ |
500530f65 [PATCH] libata: r... |
3700 3701 3702 3703 3704 3705 3706 3707 |
spin_lock_irqsave(ap->lock, flags); ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED); if (ap->pm_result) { *ap->pm_result = rc; ap->pm_result = NULL; } spin_unlock_irqrestore(ap->lock, flags); } |
6ffa01d88 libata: add CONFI... |
3708 |
#endif /* CONFIG_PM */ |