Blame view
drivers/ata/libata-eh.c
112 KB
ece1d6361 [PATCH] libata: s... |
1 2 3 |
/* * libata-eh.c - libata error handling * |
8c3d3d4b1 libata: update "M... |
4 |
* Maintained by: Tejun Heo <tj@kernel.org> |
ece1d6361 [PATCH] libata: s... |
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 |
* 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> |
38789fda2 ide/ata: Add expo... |
36 |
#include <linux/export.h> |
2855568b1 [libata] struct p... |
37 |
#include <linux/pci.h> |
ece1d6361 [PATCH] libata: s... |
38 39 40 41 42 |
#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... |
43 |
#include <scsi/scsi_dbg.h> |
c6fd28076 Move libata to dr... |
44 |
#include "../scsi/scsi_transport_api.h" |
ece1d6361 [PATCH] libata: s... |
45 46 |
#include <linux/libata.h> |
255c03d15 libata: Add trace... |
47 |
#include <trace/events/libata.h> |
ece1d6361 [PATCH] libata: s... |
48 |
#include "libata.h" |
7d47e8d4d libata: put some ... |
49 |
enum { |
3884f7b0a libata: clean up ... |
50 |
/* speed down verdicts */ |
7d47e8d4d libata: put some ... |
51 52 53 |
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... |
54 |
ATA_EH_SPDN_KEEP_ERRORS = (1 << 3), |
3884f7b0a libata: clean up ... |
55 56 57 |
/* error flags */ ATA_EFLAG_IS_IO = (1 << 0), |
76326ac1a libata: implement... |
58 |
ATA_EFLAG_DUBIOUS_XFER = (1 << 1), |
d9027470b [libata] Add ATA ... |
59 |
ATA_EFLAG_OLD_ER = (1 << 31), |
3884f7b0a libata: clean up ... |
60 61 62 63 64 65 |
/* 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... |
66 67 68 69 70 |
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 ... |
71 |
|
87fbc5a06 libata: improve E... |
72 |
ATA_EH_CMD_DFL_TIMEOUT = 5000, |
0a2c0f561 libata: improve E... |
73 74 |
/* always put at least this amount of time between resets */ ATA_EH_RESET_COOL_DOWN = 5000, |
341c2c958 libata: consisten... |
75 76 77 78 79 80 81 |
/* 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 ... |
82 83 |
ATA_EH_UA_TRIES = 5, |
c2c7a89c5 libata: improve p... |
84 85 86 87 |
/* 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... |
88 89 90 91 92 93 |
}; /* 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 |
35bf88212 libata: end the r... |
94 95 |
* are mostly for error handling, hotplug and those outlier devices that * take an exceptionally long time to recover from reset. |
31daabda1 libata: reimpleme... |
96 97 |
*/ static const unsigned long ata_eh_reset_timeouts[] = { |
341c2c958 libata: consisten... |
98 99 |
10000, /* most drives spin up by 10sec */ 10000, /* > 99% working drives spin up before 20sec */ |
35bf88212 libata: end the r... |
100 |
35000, /* give > 30 secs of idleness for outlier devices */ |
341c2c958 libata: consisten... |
101 |
5000, /* and sweet one last chance */ |
d8af0eb60 libata: use ULONG... |
102 |
ULONG_MAX, /* > 1 min has elapsed, give up */ |
31daabda1 libata: reimpleme... |
103 |
}; |
87fbc5a06 libata: improve E... |
104 105 106 107 108 109 |
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... |
110 111 112 113 114 115 |
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... |
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 150 151 152 |
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... |
153 154 |
{ .commands = CMDS(ATA_CMD_FLUSH, ATA_CMD_FLUSH_EXT), .timeouts = ata_eh_flush_timeouts }, |
87fbc5a06 libata: improve E... |
155 156 |
}; #undef CMDS |
ad9e27624 [PATCH] libata-eh... |
157 |
static void __ata_port_freeze(struct ata_port *ap); |
6ffa01d88 libata: add CONFI... |
158 |
#ifdef CONFIG_PM |
500530f65 [PATCH] libata: r... |
159 160 |
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... |
161 162 163 164 165 166 |
#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... |
167 |
#endif /* CONFIG_PM */ |
ad9e27624 [PATCH] libata-eh... |
168 |
|
b64bbc39f libata: improve E... |
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 230 231 232 |
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... |
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 292 293 294 |
/** * 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... |
295 296 |
ata_port_desc(ap, "%s 0x%llx", name, start + (unsigned long long)offset); |
cbcdd8759 libata: implement... |
297 298 299 |
} #endif /* CONFIG_PCI */ |
87fbc5a06 libata: improve E... |
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 363 364 365 |
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 ... |
366 |
static void ata_ering_record(struct ata_ering *ering, unsigned int eflags, |
0c247c559 [PATCH] libata-eh... |
367 368 369 370 371 372 373 374 375 376 |
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 ... |
377 |
ent->eflags = eflags; |
0c247c559 [PATCH] libata-eh... |
378 379 380 |
ent->err_mask = err_mask; ent->timestamp = get_jiffies_64(); } |
76326ac1a libata: implement... |
381 382 383 384 385 386 387 388 |
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; } |
d9027470b [libata] Add ATA ... |
389 390 391 |
int ata_ering_map(struct ata_ering *ering, int (*map_fn)(struct ata_ering_entry *, void *), void *arg) |
0c247c559 [PATCH] libata-eh... |
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 |
{ 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; } |
604284071 libata-eh.c: loca... |
409 |
static int ata_ering_clear_cb(struct ata_ering_entry *ent, void *void_arg) |
d9027470b [libata] Add ATA ... |
410 411 412 413 414 415 416 417 418 |
{ ent->eflags |= ATA_EFLAG_OLD_ER; return 0; } static void ata_ering_clear(struct ata_ering *ering) { ata_ering_map(ering, ata_ering_clear_cb, NULL); } |
64f65ca6e [PATCH] libata: i... |
419 420 |
static unsigned int ata_eh_dev_action(struct ata_device *dev) { |
9af5c9c97 libata-link: intr... |
421 |
struct ata_eh_context *ehc = &dev->link->eh_context; |
64f65ca6e [PATCH] libata: i... |
422 423 424 |
return ehc->i.action | ehc->i.dev_action[dev->devno]; } |
f58229f80 libata-link: impl... |
425 |
static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev, |
af181c2d7 [PATCH] libata: m... |
426 427 |
struct ata_eh_info *ehi, unsigned int action) { |
f58229f80 libata-link: impl... |
428 |
struct ata_device *tdev; |
af181c2d7 [PATCH] libata: m... |
429 430 431 |
if (!dev) { ehi->action &= ~action; |
1eca4365b libata: beef up i... |
432 |
ata_for_each_dev(tdev, link, ALL) |
f58229f80 libata-link: impl... |
433 |
ehi->dev_action[tdev->devno] &= ~action; |
af181c2d7 [PATCH] libata: m... |
434 435 436 437 438 439 |
} 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... |
440 |
ata_for_each_dev(tdev, link, ALL) |
f58229f80 libata-link: impl... |
441 442 |
ehi->dev_action[tdev->devno] |= ehi->action & action; |
af181c2d7 [PATCH] libata: m... |
443 444 445 446 447 448 449 |
ehi->action &= ~action; } /* turn off the specified per-dev action */ ehi->dev_action[dev->devno] &= ~action; } } |
ece1d6361 [PATCH] libata: s... |
450 |
/** |
c0c362b60 libata: implement... |
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 |
* ata_eh_acquire - acquire EH ownership * @ap: ATA port to acquire EH ownership for * * Acquire EH ownership for @ap. This is the basic exclusion * mechanism for ports sharing a host. Only one port hanging off * the same host can claim the ownership of EH. * * LOCKING: * EH context. */ void ata_eh_acquire(struct ata_port *ap) { mutex_lock(&ap->host->eh_mutex); WARN_ON_ONCE(ap->host->eh_owner); ap->host->eh_owner = current; } /** * ata_eh_release - release EH ownership * @ap: ATA port to release EH ownership for * * Release EH ownership for @ap if the caller. The caller must * have acquired EH ownership using ata_eh_acquire() previously. * * LOCKING: * EH context. */ void ata_eh_release(struct ata_port *ap) { WARN_ON_ONCE(ap->host->eh_owner != current); ap->host->eh_owner = NULL; mutex_unlock(&ap->host->eh_mutex); } /** |
ece1d6361 [PATCH] libata: s... |
486 487 488 489 490 491 492 493 494 495 |
* 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... |
496 497 |
* TODO: kill this function once old EH is gone. * |
ece1d6361 [PATCH] libata: s... |
498 499 500 501 502 503 |
* LOCKING: * Called from timer context * * RETURNS: * EH_HANDLED or EH_NOT_HANDLED */ |
242f9dcb8 block: unify requ... |
504 |
enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd) |
ece1d6361 [PATCH] libata: s... |
505 506 |
{ struct Scsi_Host *host = cmd->device->host; |
35bb94b11 libata: Add helpe... |
507 |
struct ata_port *ap = ata_shost_to_port(host); |
ece1d6361 [PATCH] libata: s... |
508 509 |
unsigned long flags; struct ata_queued_cmd *qc; |
242f9dcb8 block: unify requ... |
510 |
enum blk_eh_timer_return ret; |
ece1d6361 [PATCH] libata: s... |
511 512 513 |
DPRINTK("ENTER "); |
ad9e27624 [PATCH] libata-eh... |
514 |
if (ap->ops->error_handler) { |
242f9dcb8 block: unify requ... |
515 |
ret = BLK_EH_NOT_HANDLED; |
ad9e27624 [PATCH] libata-eh... |
516 517 |
goto out; } |
242f9dcb8 block: unify requ... |
518 |
ret = BLK_EH_HANDLED; |
ba6a13083 [libata] Add host... |
519 |
spin_lock_irqsave(ap->lock, flags); |
9af5c9c97 libata-link: intr... |
520 |
qc = ata_qc_from_tag(ap, ap->link.active_tag); |
ece1d6361 [PATCH] libata: s... |
521 522 523 524 |
if (qc) { WARN_ON(qc->scsicmd != cmd); qc->flags |= ATA_QCFLAG_EH_SCHEDULED; qc->err_mask |= AC_ERR_TIMEOUT; |
242f9dcb8 block: unify requ... |
525 |
ret = BLK_EH_NOT_HANDLED; |
ece1d6361 [PATCH] libata: s... |
526 |
} |
ba6a13083 [libata] Add host... |
527 |
spin_unlock_irqrestore(ap->lock, flags); |
ece1d6361 [PATCH] libata: s... |
528 |
|
ad9e27624 [PATCH] libata-eh... |
529 |
out: |
ece1d6361 [PATCH] libata: s... |
530 531 532 533 |
DPRINTK("EXIT, ret=%d ", ret); return ret; } |
ece180d1c libata: perform p... |
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 |
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... |
558 559 560 561 562 563 564 565 566 567 568 569 |
/** * 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... |
570 |
void ata_scsi_error(struct Scsi_Host *host) |
ece1d6361 [PATCH] libata: s... |
571 |
{ |
35bb94b11 libata: Add helpe... |
572 |
struct ata_port *ap = ata_shost_to_port(host); |
ad9e27624 [PATCH] libata-eh... |
573 |
unsigned long flags; |
c34aeebc0 libata: fix eh lo... |
574 |
LIST_HEAD(eh_work_q); |
ece1d6361 [PATCH] libata: s... |
575 576 577 |
DPRINTK("ENTER "); |
c34aeebc0 libata: fix eh lo... |
578 579 580 |
spin_lock_irqsave(host->host_lock, flags); list_splice_init(&host->eh_cmd_q, &eh_work_q); spin_unlock_irqrestore(host->host_lock, flags); |
0e0b494ca libata: separate ... |
581 582 583 584 585 586 587 |
ata_scsi_cmd_error_handler(host, ap, &eh_work_q); /* If we timed raced normal completion and there is nothing to recover nr_timedout == 0 why exactly are we doing error recovery ? */ ata_scsi_port_error_handler(host, ap); /* finish or retry handled scmd's and clean up */ |
72d8c36ec scsi: fix race be... |
588 |
WARN_ON(!list_empty(&eh_work_q)); |
0e0b494ca libata: separate ... |
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 |
DPRINTK("EXIT "); } /** * ata_scsi_cmd_error_handler - error callback for a list of commands * @host: scsi host containing the port * @ap: ATA port within the host * @eh_work_q: list of commands to process * * process the given list of commands and return those finished to the * ap->eh_done_q. This function is the first part of the libata error * handler which processes a given list of failed commands. */ void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap, struct list_head *eh_work_q) { int i; unsigned long flags; |
c429137a6 libata-sff: port_... |
609 610 |
/* make sure sff pio task is not running */ ata_sff_flush_pio_task(ap); |
ece1d6361 [PATCH] libata: s... |
611 |
|
cca3974e4 libata: Grand ren... |
612 |
/* synchronize with host lock and sort out timeouts */ |
ad9e27624 [PATCH] libata-eh... |
613 614 615 |
/* For new EH, all qcs are finished in one of three ways - * normal completion, error completion, and SCSI timeout. |
c96f1732e [libata] Improve ... |
616 |
* Both completions can race against SCSI timeout. When normal |
ad9e27624 [PATCH] libata-eh... |
617 618 619 620 621 622 623 624 625 626 627 628 |
* 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... |
629 |
spin_lock_irqsave(ap->lock, flags); |
d9027470b [libata] Add ATA ... |
630 |
|
c96f1732e [libata] Improve ... |
631 632 |
/* This must occur under the ap->lock as we don't want a polled recovery to race the real interrupt handler |
d9027470b [libata] Add ATA ... |
633 |
|
c96f1732e [libata] Improve ... |
634 635 |
The lost_interrupt handler checks for any completed but non-notified command and completes much like an IRQ handler. |
d9027470b [libata] Add ATA ... |
636 |
|
c96f1732e [libata] Improve ... |
637 638 639 640 641 |
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); |
d9027470b [libata] Add ATA ... |
642 |
|
0e0b494ca libata: separate ... |
643 |
list_for_each_entry_safe(scmd, tmp, eh_work_q, eh_entry) { |
ad9e27624 [PATCH] libata-eh... |
644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 |
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... |
679 |
spin_unlock_irqrestore(ap->lock, flags); |
a1e10f7e6 libata: move EH r... |
680 681 682 |
/* initialize eh_tries */ ap->eh_tries = ATA_EH_MAX_TRIES; |
ad9e27624 [PATCH] libata-eh... |
683 |
} else |
e30349d27 [PATCH] libata: r... |
684 |
spin_unlock_wait(ap->lock); |
d9027470b [libata] Add ATA ... |
685 |
|
0e0b494ca libata: separate ... |
686 687 688 689 690 691 692 693 694 695 696 697 698 699 |
} EXPORT_SYMBOL(ata_scsi_cmd_error_handler); /** * ata_scsi_port_error_handler - recover the port after the commands * @host: SCSI host containing the port * @ap: the ATA port * * Handle the recovery of the port @ap after all the commands * have been recovered. */ void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap) { unsigned long flags; |
ad9e27624 [PATCH] libata-eh... |
700 |
|
ad9e27624 [PATCH] libata-eh... |
701 702 |
/* invoke error handler */ if (ap->ops->error_handler) { |
cf1b86c8a libata-link: upda... |
703 |
struct ata_link *link; |
c0c362b60 libata: implement... |
704 705 706 |
/* acquire EH ownership */ ata_eh_acquire(ap); repeat: |
5ddf24c5e libata: implement... |
707 708 |
/* kill fast drain timer */ del_timer_sync(&ap->fastdrain_timer); |
500530f65 [PATCH] libata: r... |
709 710 |
/* process port resume request */ ata_eh_handle_port_resume(ap); |
f3e81b19a [PATCH] libata-eh... |
711 |
/* fetch & clear EH info */ |
e30349d27 [PATCH] libata: r... |
712 |
spin_lock_irqsave(ap->lock, flags); |
f3e81b19a [PATCH] libata-eh... |
713 |
|
1eca4365b libata: beef up i... |
714 |
ata_for_each_link(link, ap, HOST_FIRST) { |
00115e0f5 libata: implement... |
715 716 |
struct ata_eh_context *ehc = &link->eh_context; struct ata_device *dev; |
cf1b86c8a libata-link: upda... |
717 718 719 |
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... |
720 |
|
1eca4365b libata: beef up i... |
721 |
ata_for_each_dev(dev, link, ENABLED) { |
00115e0f5 libata: implement... |
722 723 724 725 726 727 |
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... |
728 |
} |
f3e81b19a [PATCH] libata-eh... |
729 |
|
b51e9e5db [PATCH] libata: a... |
730 731 |
ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS; ap->pflags &= ~ATA_PFLAG_EH_PENDING; |
da917d69d libata-pmp-prep: ... |
732 |
ap->excl_link = NULL; /* don't maintain exclusion over EH */ |
f3e81b19a [PATCH] libata-eh... |
733 |
|
e30349d27 [PATCH] libata: r... |
734 |
spin_unlock_irqrestore(ap->lock, flags); |
ad9e27624 [PATCH] libata-eh... |
735 |
|
500530f65 [PATCH] libata: r... |
736 737 |
/* invoke EH, skip if unloading or suspended */ if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED))) |
720ba1262 [PATCH] libata-hp... |
738 |
ap->ops->error_handler(ap); |
ece180d1c libata: perform p... |
739 740 741 742 743 |
else { /* if unloading, commence suicide */ if ((ap->pflags & ATA_PFLAG_UNLOADING) && !(ap->pflags & ATA_PFLAG_UNLOADED)) ata_eh_unload(ap); |
720ba1262 [PATCH] libata-hp... |
744 |
ata_eh_finish(ap); |
ece180d1c libata: perform p... |
745 |
} |
ad9e27624 [PATCH] libata-eh... |
746 |
|
500530f65 [PATCH] libata: r... |
747 748 |
/* process port suspend request */ ata_eh_handle_port_suspend(ap); |
25985edce Fix common misspe... |
749 |
/* Exception might have happened after ->error_handler |
ad9e27624 [PATCH] libata-eh... |
750 751 752 |
* recovered the port but before this point. Repeat * EH in such case. */ |
e30349d27 [PATCH] libata: r... |
753 |
spin_lock_irqsave(ap->lock, flags); |
ad9e27624 [PATCH] libata-eh... |
754 |
|
b51e9e5db [PATCH] libata: a... |
755 |
if (ap->pflags & ATA_PFLAG_EH_PENDING) { |
a1e10f7e6 libata: move EH r... |
756 |
if (--ap->eh_tries) { |
e30349d27 [PATCH] libata: r... |
757 |
spin_unlock_irqrestore(ap->lock, flags); |
ad9e27624 [PATCH] libata-eh... |
758 759 |
goto repeat; } |
a9a79dfec ata: Convert ata_... |
760 761 762 763 |
ata_port_err(ap, "EH pending after %d tries, giving up ", ATA_EH_MAX_TRIES); |
914616a3c libata: fix infin... |
764 |
ap->pflags &= ~ATA_PFLAG_EH_PENDING; |
ad9e27624 [PATCH] libata-eh... |
765 |
} |
f3e81b19a [PATCH] libata-eh... |
766 |
/* this run is complete, make sure EH info is clear */ |
1eca4365b libata: beef up i... |
767 |
ata_for_each_link(link, ap, HOST_FIRST) |
cf1b86c8a libata-link: upda... |
768 |
memset(&link->eh_info, 0, sizeof(link->eh_info)); |
f3e81b19a [PATCH] libata-eh... |
769 |
|
e4a9c3732 [SCSI] libata, li... |
770 771 772 |
/* end eh (clear host_eh_scheduled) while holding * ap->lock such that if exception occurs after this * point but before EH completion, SCSI midlayer will |
ad9e27624 [PATCH] libata-eh... |
773 774 |
* re-initiate EH. */ |
e4a9c3732 [SCSI] libata, li... |
775 |
ap->ops->end_eh(ap); |
ad9e27624 [PATCH] libata-eh... |
776 |
|
e30349d27 [PATCH] libata: r... |
777 |
spin_unlock_irqrestore(ap->lock, flags); |
c0c362b60 libata: implement... |
778 |
ata_eh_release(ap); |
ad9e27624 [PATCH] libata-eh... |
779 |
} else { |
9af5c9c97 libata-link: intr... |
780 |
WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL); |
ad9e27624 [PATCH] libata-eh... |
781 782 |
ap->ops->eng_timeout(ap); } |
ece1d6361 [PATCH] libata: s... |
783 |
|
ece1d6361 [PATCH] libata: s... |
784 |
scsi_eh_flush_done_q(&ap->eh_done_q); |
ad9e27624 [PATCH] libata-eh... |
785 |
/* clean up */ |
e30349d27 [PATCH] libata: r... |
786 |
spin_lock_irqsave(ap->lock, flags); |
ad9e27624 [PATCH] libata-eh... |
787 |
|
1cdaf534f [PATCH] libata: i... |
788 |
if (ap->pflags & ATA_PFLAG_LOADING) |
b51e9e5db [PATCH] libata: a... |
789 |
ap->pflags &= ~ATA_PFLAG_LOADING; |
1cdaf534f [PATCH] libata: i... |
790 |
else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG) |
ad72cf988 libata: take adva... |
791 |
schedule_delayed_work(&ap->hotplug_task, 0); |
1cdaf534f [PATCH] libata: i... |
792 793 |
if (ap->pflags & ATA_PFLAG_RECOVERED) |
a9a79dfec ata: Convert ata_... |
794 795 |
ata_port_info(ap, "EH complete "); |
580b21023 [PATCH] libata-hp... |
796 |
|
b51e9e5db [PATCH] libata: a... |
797 |
ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED); |
ad9e27624 [PATCH] libata-eh... |
798 |
|
c6cf9e99d [PATCH] libata: i... |
799 |
/* tell wait_eh that we're done */ |
b51e9e5db [PATCH] libata: a... |
800 |
ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS; |
c6cf9e99d [PATCH] libata: i... |
801 |
wake_up_all(&ap->eh_wait_q); |
e30349d27 [PATCH] libata: r... |
802 |
spin_unlock_irqrestore(ap->lock, flags); |
ece1d6361 [PATCH] libata: s... |
803 |
} |
0e0b494ca libata: separate ... |
804 |
EXPORT_SYMBOL_GPL(ata_scsi_port_error_handler); |
ece1d6361 [PATCH] libata: s... |
805 806 |
/** |
c6cf9e99d [PATCH] libata: i... |
807 808 809 810 811 812 813 814 815 816 817 818 819 820 |
* 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... |
821 |
spin_lock_irqsave(ap->lock, flags); |
c6cf9e99d [PATCH] libata: i... |
822 |
|
b51e9e5db [PATCH] libata: a... |
823 |
while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) { |
c6cf9e99d [PATCH] libata: i... |
824 |
prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE); |
ba6a13083 [libata] Add host... |
825 |
spin_unlock_irqrestore(ap->lock, flags); |
c6cf9e99d [PATCH] libata: i... |
826 |
schedule(); |
ba6a13083 [libata] Add host... |
827 |
spin_lock_irqsave(ap->lock, flags); |
c6cf9e99d [PATCH] libata: i... |
828 |
} |
0a1b622ef [PATCH] libata: a... |
829 |
finish_wait(&ap->eh_wait_q, &wait); |
c6cf9e99d [PATCH] libata: i... |
830 |
|
ba6a13083 [libata] Add host... |
831 |
spin_unlock_irqrestore(ap->lock, flags); |
c6cf9e99d [PATCH] libata: i... |
832 833 |
/* make sure SCSI EH is complete */ |
cca3974e4 libata: Grand ren... |
834 |
if (scsi_host_in_recovery(ap->scsi_host)) { |
97750cebb libata: add @ap t... |
835 |
ata_msleep(ap, 10); |
c6cf9e99d [PATCH] libata: i... |
836 837 838 |
goto retry; } } |
81c757bc6 [SCSI] libsas: ex... |
839 |
EXPORT_SYMBOL_GPL(ata_port_wait_eh); |
c6cf9e99d [PATCH] libata: i... |
840 |
|
5ddf24c5e libata: implement... |
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 |
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... |
885 |
ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL); |
5ddf24c5e libata: implement... |
886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 |
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... |
925 926 |
ap->fastdrain_timer.expires = ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL); |
5ddf24c5e libata: implement... |
927 928 |
add_timer(&ap->fastdrain_timer); } |
f686bcb80 [PATCH] libata-eh... |
929 930 931 932 933 934 935 936 |
/** * 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... |
937 |
* spin_lock_irqsave(host lock) |
f686bcb80 [PATCH] libata-eh... |
938 939 940 941 |
*/ void ata_qc_schedule_eh(struct ata_queued_cmd *qc) { struct ata_port *ap = qc->ap; |
fa41efdae libata: fix locki... |
942 943 |
struct request_queue *q = qc->scsicmd->device->request_queue; unsigned long flags; |
f686bcb80 [PATCH] libata-eh... |
944 945 946 947 |
WARN_ON(!ap->ops->error_handler); qc->flags |= ATA_QCFLAG_FAILED; |
5ddf24c5e libata: implement... |
948 |
ata_eh_set_pending(ap, 1); |
f686bcb80 [PATCH] libata-eh... |
949 950 951 952 953 954 |
/* 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... |
955 |
spin_lock_irqsave(q->queue_lock, flags); |
242f9dcb8 block: unify requ... |
956 |
blk_abort_request(qc->scsicmd->request); |
fa41efdae libata: fix locki... |
957 |
spin_unlock_irqrestore(q->queue_lock, flags); |
f686bcb80 [PATCH] libata-eh... |
958 |
} |
7b70fc039 [PATCH] libata-eh... |
959 |
/** |
e4a9c3732 [SCSI] libata, li... |
960 961 |
* ata_std_sched_eh - non-libsas ata_ports issue eh with this common routine * @ap: ATA port to schedule EH for |
7b70fc039 [PATCH] libata-eh... |
962 |
* |
e4a9c3732 [SCSI] libata, li... |
963 |
* LOCKING: inherited from ata_port_schedule_eh |
cca3974e4 libata: Grand ren... |
964 |
* spin_lock_irqsave(host lock) |
7b70fc039 [PATCH] libata-eh... |
965 |
*/ |
e4a9c3732 [SCSI] libata, li... |
966 |
void ata_std_sched_eh(struct ata_port *ap) |
7b70fc039 [PATCH] libata-eh... |
967 968 |
{ WARN_ON(!ap->ops->error_handler); |
f4d6d0046 libata: ignore EH... |
969 970 |
if (ap->pflags & ATA_PFLAG_INITIALIZING) return; |
5ddf24c5e libata: implement... |
971 |
ata_eh_set_pending(ap, 1); |
cca3974e4 libata: Grand ren... |
972 |
scsi_schedule_eh(ap->scsi_host); |
7b70fc039 [PATCH] libata-eh... |
973 974 975 976 |
DPRINTK("port EH scheduled "); } |
e4a9c3732 [SCSI] libata, li... |
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 |
EXPORT_SYMBOL_GPL(ata_std_sched_eh); /** * ata_std_end_eh - non-libsas ata_ports complete eh with this common routine * @ap: ATA port to end EH for * * In the libata object model there is a 1:1 mapping of ata_port to * shost, so host fields can be directly manipulated under ap->lock, in * the libsas case we need to hold a lock at the ha->level to coordinate * these events. * * LOCKING: * spin_lock_irqsave(host lock) */ void ata_std_end_eh(struct ata_port *ap) { struct Scsi_Host *host = ap->scsi_host; host->host_eh_scheduled = 0; } EXPORT_SYMBOL(ata_std_end_eh); /** * 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: * spin_lock_irqsave(host lock) */ void ata_port_schedule_eh(struct ata_port *ap) { /* see: ata_std_sched_eh, unless you know better */ ap->ops->sched_eh(ap); } |
7b70fc039 [PATCH] libata-eh... |
1015 |
|
dbd826168 libata-link: impl... |
1016 |
static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link) |
7b70fc039 [PATCH] libata-eh... |
1017 1018 1019 1020 |
{ int tag, nr_aborted = 0; WARN_ON(!ap->ops->error_handler); |
5ddf24c5e libata: implement... |
1021 1022 |
/* we're gonna abort all commands, no need for fast drain */ ata_eh_set_pending(ap, 0); |
7b70fc039 [PATCH] libata-eh... |
1023 1024 |
for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag); |
dbd826168 libata-link: impl... |
1025 |
if (qc && (!link || qc->dev->link == link)) { |
7b70fc039 [PATCH] libata-eh... |
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 |
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... |
1037 |
/** |
dbd826168 libata-link: impl... |
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 |
* 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... |
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 |
* __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... |
1087 |
* spin_lock_irqsave(host lock) |
e31804994 [PATCH] libata-eh... |
1088 1089 1090 1091 1092 1093 1094 |
*/ 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... |
1095 |
ap->pflags |= ATA_PFLAG_FROZEN; |
e31804994 [PATCH] libata-eh... |
1096 |
|
44877b4e2 libata: s/ap->id/... |
1097 1098 |
DPRINTK("ata%u port frozen ", ap->print_id); |
e31804994 [PATCH] libata-eh... |
1099 1100 1101 1102 1103 1104 |
} /** * ata_port_freeze - abort & freeze port * @ap: ATA port to freeze * |
54c38444f [libata] EH: free... |
1105 1106 1107 |
* 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... |
1108 1109 |
* * LOCKING: |
cca3974e4 libata: Grand ren... |
1110 |
* spin_lock_irqsave(host lock) |
e31804994 [PATCH] libata-eh... |
1111 1112 1113 1114 1115 1116 1117 1118 1119 |
* * 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... |
1120 |
__ata_port_freeze(ap); |
54c38444f [libata] EH: free... |
1121 |
nr_aborted = ata_port_abort(ap); |
e31804994 [PATCH] libata-eh... |
1122 1123 1124 1125 1126 |
return nr_aborted; } /** |
7d77b2470 libata-pmp-prep: ... |
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 |
* 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... |
1150 |
if (!sata_pmp_attached(ap) || rc) { |
7d77b2470 libata-pmp-prep: ... |
1151 |
/* PMP is not attached or SNTF is not available */ |
071f44b1d libata: implement... |
1152 |
if (!sata_pmp_attached(ap)) { |
7d77b2470 libata-pmp-prep: ... |
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 |
/* 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... |
1177 |
ata_for_each_link(link, ap, EDGE) { |
7d77b2470 libata-pmp-prep: ... |
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 |
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... |
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 |
* 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... |
1213 |
spin_lock_irqsave(ap->lock, flags); |
e31804994 [PATCH] libata-eh... |
1214 |
__ata_port_freeze(ap); |
ba6a13083 [libata] Add host... |
1215 |
spin_unlock_irqrestore(ap->lock, flags); |
e31804994 [PATCH] libata-eh... |
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 |
} /** * 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... |
1233 |
spin_lock_irqsave(ap->lock, flags); |
e31804994 [PATCH] libata-eh... |
1234 |
|
b51e9e5db [PATCH] libata: a... |
1235 |
ap->pflags &= ~ATA_PFLAG_FROZEN; |
e31804994 [PATCH] libata-eh... |
1236 1237 1238 |
if (ap->ops->thaw) ap->ops->thaw(ap); |
ba6a13083 [libata] Add host... |
1239 |
spin_unlock_irqrestore(ap->lock, flags); |
e31804994 [PATCH] libata-eh... |
1240 |
|
44877b4e2 libata: s/ap->id/... |
1241 1242 |
DPRINTK("ata%u port thawed ", ap->print_id); |
e31804994 [PATCH] libata-eh... |
1243 |
} |
ece1d6361 [PATCH] libata: s... |
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 |
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... |
1254 |
spin_lock_irqsave(ap->lock, flags); |
ece1d6361 [PATCH] libata: s... |
1255 1256 1257 |
qc->scsidone = ata_eh_scsidone; __ata_qc_complete(qc); WARN_ON(ata_tag_valid(qc->tag)); |
ba6a13083 [libata] Add host... |
1258 |
spin_unlock_irqrestore(ap->lock, flags); |
ece1d6361 [PATCH] libata: s... |
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 |
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. |
f13e22016 libata: make ata_... |
1285 |
* scmd->allowed is incremented for commands which get retried |
ece1d6361 [PATCH] libata: s... |
1286 1287 1288 1289 1290 |
* 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; |
f13e22016 libata: make ata_... |
1291 1292 |
if (!qc->err_mask) scmd->allowed++; |
ece1d6361 [PATCH] libata: s... |
1293 1294 |
__ata_eh_qc_complete(qc); } |
022bdb075 [PATCH] libata-eh... |
1295 1296 |
/** |
678afac67 libata: move ata_... |
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 |
* 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)) |
a9a79dfec ata: Convert ata_... |
1311 1312 |
ata_dev_warn(dev, "disabled "); |
678afac67 libata: move ata_... |
1313 1314 1315 |
ata_acpi_on_disable(dev); ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET); dev->class++; |
99cf610aa libata: clear dev... |
1316 1317 1318 1319 1320 |
/* 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_... |
1321 1322 1323 |
} /** |
0ea035a3d [PATCH] libata-hp... |
1324 1325 1326 1327 1328 1329 1330 1331 |
* ata_eh_detach_dev - detach ATA device * @dev: ATA device to detach * * Detach @dev. * * LOCKING: * None. */ |
fb7fd6145 libata-pmp-prep: ... |
1332 |
void ata_eh_detach_dev(struct ata_device *dev) |
0ea035a3d [PATCH] libata-hp... |
1333 |
{ |
f58229f80 libata-link: impl... |
1334 1335 |
struct ata_link *link = dev->link; struct ata_port *ap = link->ap; |
90484ebfc libata: clear sav... |
1336 |
struct ata_eh_context *ehc = &link->eh_context; |
0ea035a3d [PATCH] libata-hp... |
1337 1338 1339 |
unsigned long flags; ata_dev_disable(dev); |
ba6a13083 [libata] Add host... |
1340 |
spin_lock_irqsave(ap->lock, flags); |
0ea035a3d [PATCH] libata-hp... |
1341 1342 1343 1344 1345 |
dev->flags &= ~ATA_DFLAG_DETACH; if (ata_scsi_offline_dev(dev)) { dev->flags |= ATA_DFLAG_DETACHED; |
b51e9e5db [PATCH] libata: a... |
1346 |
ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG; |
0ea035a3d [PATCH] libata-hp... |
1347 |
} |
90484ebfc libata: clear sav... |
1348 |
/* clear per-dev EH info */ |
f58229f80 libata-link: impl... |
1349 1350 |
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... |
1351 1352 |
ehc->saved_xfer_mode[dev->devno] = 0; ehc->saved_ncq_enabled &= ~(1 << dev->devno); |
beb07c1a5 [PATCH] libata: c... |
1353 |
|
ba6a13083 [libata] Add host... |
1354 |
spin_unlock_irqrestore(ap->lock, flags); |
0ea035a3d [PATCH] libata-hp... |
1355 1356 1357 |
} /** |
022bdb075 [PATCH] libata-eh... |
1358 |
* ata_eh_about_to_do - about to perform eh_action |
955e57dfd libata-link: link... |
1359 |
* @link: target ATA link |
47005f255 [PATCH] libata: i... |
1360 |
* @dev: target ATA dev for per-dev action (can be NULL) |
022bdb075 [PATCH] libata-eh... |
1361 1362 1363 |
* @action: action about to be performed * * Called just before performing EH actions to clear related bits |
955e57dfd libata-link: link... |
1364 1365 |
* in @link->eh_info such that eh actions are not unnecessarily * repeated. |
022bdb075 [PATCH] libata-eh... |
1366 1367 1368 1369 |
* * LOCKING: * None. */ |
fb7fd6145 libata-pmp-prep: ... |
1370 1371 |
void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev, unsigned int action) |
022bdb075 [PATCH] libata-eh... |
1372 |
{ |
955e57dfd libata-link: link... |
1373 1374 1375 |
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... |
1376 |
unsigned long flags; |
ba6a13083 [libata] Add host... |
1377 |
spin_lock_irqsave(ap->lock, flags); |
1cdaf534f [PATCH] libata: i... |
1378 |
|
955e57dfd libata-link: link... |
1379 |
ata_eh_clear_action(link, dev, ehi, action); |
1cdaf534f [PATCH] libata: i... |
1380 |
|
a568d1d2e libata-eh: fix sl... |
1381 1382 1383 1384 |
/* 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... |
1385 |
ap->pflags |= ATA_PFLAG_RECOVERED; |
ba6a13083 [libata] Add host... |
1386 |
spin_unlock_irqrestore(ap->lock, flags); |
022bdb075 [PATCH] libata-eh... |
1387 1388 1389 |
} /** |
47005f255 [PATCH] libata: i... |
1390 |
* ata_eh_done - EH action complete |
955e57dfd libata-link: link... |
1391 |
* @ap: target ATA port |
47005f255 [PATCH] libata: i... |
1392 1393 1394 1395 |
* @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... |
1396 |
* in @link->eh_context. |
47005f255 [PATCH] libata: i... |
1397 1398 1399 1400 |
* * LOCKING: * None. */ |
fb7fd6145 libata-pmp-prep: ... |
1401 1402 |
void ata_eh_done(struct ata_link *link, struct ata_device *dev, unsigned int action) |
47005f255 [PATCH] libata: i... |
1403 |
{ |
955e57dfd libata-link: link... |
1404 |
struct ata_eh_context *ehc = &link->eh_context; |
9af5c9c97 libata-link: intr... |
1405 |
|
955e57dfd libata-link: link... |
1406 |
ata_eh_clear_action(link, dev, &ehc->i, action); |
47005f255 [PATCH] libata: i... |
1407 1408 1409 |
} /** |
022bdb075 [PATCH] libata-eh... |
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 |
* 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... |
1423 |
static const char *ata_err_string(unsigned int err_mask) |
022bdb075 [PATCH] libata-eh... |
1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 |
{ 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... |
1445 1446 |
* ata_read_log_page - read a specific log page * @dev: target device |
65fe1f0f6 ahci: implement a... |
1447 |
* @log: log to read |
e8ee84518 [PATCH] libata-nc... |
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 |
* @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. */ |
65fe1f0f6 ahci: implement a... |
1460 1461 |
unsigned int ata_read_log_page(struct ata_device *dev, u8 log, u8 page, void *buf, unsigned int sectors) |
e8ee84518 [PATCH] libata-nc... |
1462 |
{ |
ea013a9b2 libata-eh.c: Intr... |
1463 |
unsigned long ap_flags = dev->link->ap->flags; |
e8ee84518 [PATCH] libata-nc... |
1464 1465 |
struct ata_taskfile tf; unsigned int err_mask; |
5d3abf8ff libata: Fall back... |
1466 |
bool dma = false; |
e8ee84518 [PATCH] libata-nc... |
1467 |
|
65fe1f0f6 ahci: implement a... |
1468 1469 |
DPRINTK("read log page - log 0x%x, page 0x%x ", log, page); |
e8ee84518 [PATCH] libata-nc... |
1470 |
|
ea013a9b2 libata-eh.c: Intr... |
1471 1472 1473 1474 1475 1476 |
/* * Return error without actually issuing the command on controllers * which e.g. lockup on a read log page. */ if (ap_flags & ATA_FLAG_NO_LOG_PAGE) return AC_ERR_DEV; |
5d3abf8ff libata: Fall back... |
1477 |
retry: |
e8ee84518 [PATCH] libata-nc... |
1478 |
ata_tf_init(dev, &tf); |
5d3abf8ff libata: Fall back... |
1479 1480 |
if (dev->dma_mode && ata_id_has_read_log_dma_ext(dev->id) && !(dev->horkage & ATA_HORKAGE_NO_NCQ_LOG)) { |
9faa64385 libata: use READ_... |
1481 1482 |
tf.command = ATA_CMD_READ_LOG_DMA_EXT; tf.protocol = ATA_PROT_DMA; |
5d3abf8ff libata: Fall back... |
1483 |
dma = true; |
9faa64385 libata: use READ_... |
1484 1485 1486 |
} else { tf.command = ATA_CMD_READ_LOG_EXT; tf.protocol = ATA_PROT_PIO; |
eab6ee1ce libata: Fix regre... |
1487 |
dma = false; |
9faa64385 libata: use READ_... |
1488 |
} |
65fe1f0f6 ahci: implement a... |
1489 1490 |
tf.lbal = log; tf.lbam = page; |
e8ee84518 [PATCH] libata-nc... |
1491 1492 1493 |
tf.nsect = sectors; tf.hob_nsect = sectors >> 8; tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE; |
e8ee84518 [PATCH] libata-nc... |
1494 1495 |
err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE, |
2b789108f libata: add @time... |
1496 |
buf, sectors * ATA_SECT_SIZE, 0); |
e8ee84518 [PATCH] libata-nc... |
1497 |
|
5d3abf8ff libata: Fall back... |
1498 1499 1500 1501 1502 1503 |
if (err_mask && dma) { dev->horkage |= ATA_HORKAGE_NO_NCQ_LOG; ata_dev_warn(dev, "READ LOG DMA EXT failed, trying unqueued "); goto retry; } |
e8ee84518 [PATCH] libata-nc... |
1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 |
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... |
1527 |
u8 *buf = dev->link->ap->sector_buf; |
e8ee84518 [PATCH] libata-nc... |
1528 1529 1530 |
unsigned int err_mask; u8 csum; int i; |
65fe1f0f6 ahci: implement a... |
1531 |
err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, 0, buf, 1); |
e8ee84518 [PATCH] libata-nc... |
1532 1533 1534 1535 1536 1537 1538 |
if (err_mask) return -EIO; csum = 0; for (i = 0; i < ATA_SECT_SIZE; i++) csum += buf[i]; if (csum) |
a9a79dfec ata: Convert ata_... |
1539 1540 1541 |
ata_dev_warn(dev, "invalid checksum 0x%x on log page 10h ", csum); |
e8ee84518 [PATCH] libata-nc... |
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 |
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]; |
5b01e4b9e libata: Implement... |
1559 1560 |
if (ata_id_has_ncq_autosense(dev->id)) tf->auxiliary = buf[14] << 16 | buf[15] << 8 | buf[16]; |
e8ee84518 [PATCH] libata-nc... |
1561 1562 1563 1564 1565 |
return 0; } /** |
11fc33da8 libata-eh: clear ... |
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 |
* 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. */ |
3dc67440d libata: check zer... |
1578 |
unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key) |
11fc33da8 libata-eh: clear ... |
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 |
{ 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; } /** |
e87fd28cf libata: Implement... |
1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 |
* ata_eh_request_sense - perform REQUEST_SENSE_DATA_EXT * @dev: device to perform REQUEST_SENSE_SENSE_DATA_EXT to * @cmd: scsi command for which the sense code should be set * * Perform REQUEST_SENSE_DATA_EXT after the device reported CHECK * SENSE. This function is an EH helper. * * LOCKING: * Kernel thread context (may sleep). */ static void ata_eh_request_sense(struct ata_queued_cmd *qc, struct scsi_cmnd *cmd) { struct ata_device *dev = qc->dev; struct ata_taskfile tf; unsigned int err_mask; if (qc->ap->pflags & ATA_PFLAG_FROZEN) { ata_dev_warn(dev, "sense data available but port frozen "); return; } |
d238ffd59 libata: do not at... |
1619 |
if (!cmd || qc->flags & ATA_QCFLAG_SENSE_VALID) |
e87fd28cf libata: Implement... |
1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 |
return; if (!ata_id_sense_reporting_enabled(dev->id)) { ata_dev_warn(qc->dev, "sense data reporting disabled "); return; } DPRINTK("ATA request sense "); ata_tf_init(dev, &tf); tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; tf.flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48; tf.command = ATA_CMD_REQ_SENSE_DATA; tf.protocol = ATA_PROT_NODATA; err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); /* Ignore err_mask; ATA_ERR might be set */ if (tf.command & ATA_SENSE) { |
06dbde5f3 libata: Implement... |
1640 |
ata_scsi_set_sense(dev, cmd, tf.lbah, tf.lbam, tf.lbal); |
e87fd28cf libata: Implement... |
1641 1642 1643 1644 1645 1646 1647 1648 1649 |
qc->flags |= ATA_QCFLAG_SENSE_VALID; } else { ata_dev_warn(dev, "request sense failed stat %02x emask %x ", tf.command, err_mask); } } /** |
022bdb075 [PATCH] libata-eh... |
1650 1651 1652 |
* 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... |
1653 |
* @dfl_sense_key: default sense key to use |
022bdb075 [PATCH] libata-eh... |
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 |
* * 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 */ |
3dc67440d libata: check zer... |
1664 |
unsigned int atapi_eh_request_sense(struct ata_device *dev, |
3eabddb8e libata-eh: update... |
1665 |
u8 *sense_buf, u8 dfl_sense_key) |
022bdb075 [PATCH] libata-eh... |
1666 |
{ |
3eabddb8e libata-eh: update... |
1667 1668 |
u8 cdb[ATAPI_CDB_LEN] = { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 }; |
9af5c9c97 libata-link: intr... |
1669 |
struct ata_port *ap = dev->link->ap; |
022bdb075 [PATCH] libata-eh... |
1670 |
struct ata_taskfile tf; |
022bdb075 [PATCH] libata-eh... |
1671 1672 1673 |
DPRINTK("ATAPI request sense "); |
022bdb075 [PATCH] libata-eh... |
1674 |
memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE); |
56287768e libata: Clear tf ... |
1675 1676 1677 |
/* initialize sense_buf with the error register, * for the case where they are -not- overwritten */ |
022bdb075 [PATCH] libata-eh... |
1678 |
sense_buf[0] = 0x70; |
3eabddb8e libata-eh: update... |
1679 |
sense_buf[2] = dfl_sense_key; |
56287768e libata: Clear tf ... |
1680 |
|
a617c09f6 libata: Trim trai... |
1681 |
/* some devices time out if garbage left in tf */ |
56287768e libata: Clear tf ... |
1682 |
ata_tf_init(dev, &tf); |
022bdb075 [PATCH] libata-eh... |
1683 |
|
022bdb075 [PATCH] libata-eh... |
1684 1685 1686 1687 1688 |
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... |
1689 |
tf.protocol = ATAPI_PROT_DMA; |
022bdb075 [PATCH] libata-eh... |
1690 1691 |
tf.feature |= ATAPI_PKT_DMA; } else { |
0dc36888d libata: rename AT... |
1692 |
tf.protocol = ATAPI_PROT_PIO; |
f2dfc1a12 libata: update at... |
1693 1694 |
tf.lbam = SCSI_SENSE_BUFFERSIZE; tf.lbah = 0; |
022bdb075 [PATCH] libata-eh... |
1695 1696 1697 |
} return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE, |
2b789108f libata: add @time... |
1698 |
sense_buf, SCSI_SENSE_BUFFERSIZE, 0); |
022bdb075 [PATCH] libata-eh... |
1699 1700 1701 1702 |
} /** * ata_eh_analyze_serror - analyze SError for a failed port |
0260731f0 libata-link: link... |
1703 |
* @link: ATA link to analyze SError for |
022bdb075 [PATCH] libata-eh... |
1704 1705 1706 1707 1708 1709 1710 |
* * Analyze SError if available and further determine cause of * failure. * * LOCKING: * None. */ |
0260731f0 libata-link: link... |
1711 |
static void ata_eh_analyze_serror(struct ata_link *link) |
022bdb075 [PATCH] libata-eh... |
1712 |
{ |
0260731f0 libata-link: link... |
1713 |
struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
1714 1715 |
u32 serror = ehc->i.serror; unsigned int err_mask = 0, action = 0; |
f9df58cb2 libata-pmp-prep: ... |
1716 |
u32 hotplug_mask; |
022bdb075 [PATCH] libata-eh... |
1717 |
|
e0614db2a libata: ignore re... |
1718 |
if (serror & (SERR_PERSISTENT | SERR_DATA)) { |
022bdb075 [PATCH] libata-eh... |
1719 |
err_mask |= AC_ERR_ATA_BUS; |
cf4806265 libata: prefer ha... |
1720 |
action |= ATA_EH_RESET; |
022bdb075 [PATCH] libata-eh... |
1721 1722 1723 |
} if (serror & SERR_PROTOCOL) { err_mask |= AC_ERR_HSM; |
cf4806265 libata: prefer ha... |
1724 |
action |= ATA_EH_RESET; |
022bdb075 [PATCH] libata-eh... |
1725 1726 1727 |
} if (serror & SERR_INTERNAL) { err_mask |= AC_ERR_SYSTEM; |
cf4806265 libata: prefer ha... |
1728 |
action |= ATA_EH_RESET; |
022bdb075 [PATCH] libata-eh... |
1729 |
} |
f9df58cb2 libata-pmp-prep: ... |
1730 1731 1732 1733 1734 1735 |
/* 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. */ |
eb0e85e36 libata: fix hotpl... |
1736 |
if (link->lpm_policy > ATA_LPM_MAX_POWER) |
6b7ae9545 libata: reimpleme... |
1737 1738 |
hotplug_mask = 0; /* hotplug doesn't work w/ LPM */ else if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link)) |
f9df58cb2 libata-pmp-prep: ... |
1739 1740 1741 1742 1743 |
hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG; else hotplug_mask = SERR_PHYRDY_CHG; if (serror & hotplug_mask) |
084fe639b [PATCH] libata-hp... |
1744 |
ata_ehi_hotplugged(&ehc->i); |
022bdb075 [PATCH] libata-eh... |
1745 1746 1747 1748 1749 1750 |
ehc->i.err_mask |= err_mask; ehc->i.action |= action; } /** |
e8ee84518 [PATCH] libata-nc... |
1751 |
* ata_eh_analyze_ncq_error - analyze NCQ error |
0260731f0 libata-link: link... |
1752 |
* @link: ATA link to analyze NCQ error for |
e8ee84518 [PATCH] libata-nc... |
1753 1754 1755 1756 1757 1758 1759 1760 1761 |
* * 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... |
1762 |
void ata_eh_analyze_ncq_error(struct ata_link *link) |
e8ee84518 [PATCH] libata-nc... |
1763 |
{ |
0260731f0 libata-link: link... |
1764 1765 1766 |
struct ata_port *ap = link->ap; struct ata_eh_context *ehc = &link->eh_context; struct ata_device *dev = link->device; |
e8ee84518 [PATCH] libata-nc... |
1767 1768 1769 1770 1771 |
struct ata_queued_cmd *qc; struct ata_taskfile tf; int tag, rc; /* if frozen, we can't do much */ |
b51e9e5db [PATCH] libata: a... |
1772 |
if (ap->pflags & ATA_PFLAG_FROZEN) |
e8ee84518 [PATCH] libata-nc... |
1773 1774 1775 |
return; /* is it NCQ device error? */ |
0260731f0 libata-link: link... |
1776 |
if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV)) |
e8ee84518 [PATCH] libata-nc... |
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 |
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... |
1791 |
memset(&tf, 0, sizeof(tf)); |
e8ee84518 [PATCH] libata-nc... |
1792 1793 |
rc = ata_eh_read_log_10h(dev, &tag, &tf); if (rc) { |
a9a79dfec ata: Convert ata_... |
1794 1795 1796 |
ata_link_err(link, "failed to read log page 10h (errno=%d) ", rc); |
e8ee84518 [PATCH] libata-nc... |
1797 1798 |
return; } |
0260731f0 libata-link: link... |
1799 |
if (!(link->sactive & (1 << tag))) { |
a9a79dfec ata: Convert ata_... |
1800 1801 1802 |
ata_link_err(link, "log page 10h reported inactive tag %d ", tag); |
e8ee84518 [PATCH] libata-nc... |
1803 1804 1805 1806 1807 1808 |
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 ... |
1809 |
qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48; |
5335b7290 libata: implement... |
1810 |
qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ; |
d238ffd59 libata: do not at... |
1811 |
if ((qc->result_tf.command & ATA_SENSE) || qc->result_tf.auxiliary) { |
5b01e4b9e libata: Implement... |
1812 1813 1814 1815 1816 |
char sense_key, asc, ascq; sense_key = (qc->result_tf.auxiliary >> 16) & 0xff; asc = (qc->result_tf.auxiliary >> 8) & 0xff; ascq = qc->result_tf.auxiliary & 0xff; |
06dbde5f3 libata: Implement... |
1817 |
ata_scsi_set_sense(dev, qc->scsicmd, sense_key, asc, ascq); |
492bf6210 libata-eh: Set 'i... |
1818 1819 |
ata_scsi_set_sense_information(dev, qc->scsicmd, &qc->result_tf); |
5b01e4b9e libata: Implement... |
1820 1821 |
qc->flags |= ATA_QCFLAG_SENSE_VALID; } |
e8ee84518 [PATCH] libata-nc... |
1822 1823 1824 1825 |
ehc->i.err_mask &= ~AC_ERR_DEV; } /** |
022bdb075 [PATCH] libata-eh... |
1826 1827 1828 1829 1830 1831 |
* 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 |
25985edce Fix common misspe... |
1832 |
* available. |
022bdb075 [PATCH] libata-eh... |
1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 |
* * 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... |
1848 |
return ATA_EH_RESET; |
022bdb075 [PATCH] libata-eh... |
1849 |
} |
e87fd28cf libata: Implement... |
1850 |
if (stat & (ATA_ERR | ATA_DF)) { |
a51d644af libata: improve A... |
1851 |
qc->err_mask |= AC_ERR_DEV; |
e87fd28cf libata: Implement... |
1852 1853 1854 1855 1856 1857 1858 |
/* * Sense data reporting does not work if the * device fault bit is set. */ if (stat & ATA_DF) stat &= ~ATA_SENSE; } else { |
022bdb075 [PATCH] libata-eh... |
1859 |
return 0; |
e87fd28cf libata: Implement... |
1860 |
} |
022bdb075 [PATCH] libata-eh... |
1861 1862 1863 |
switch (qc->dev->class) { case ATA_DEV_ATA: |
9162c6579 libata: Implement... |
1864 |
case ATA_DEV_ZAC: |
e87fd28cf libata: Implement... |
1865 1866 |
if (stat & ATA_SENSE) ata_eh_request_sense(qc, qc->scsicmd); |
022bdb075 [PATCH] libata-eh... |
1867 1868 |
if (err & ATA_ICRC) qc->err_mask |= AC_ERR_ATA_BUS; |
eec7e1c16 libata: EH should... |
1869 |
if (err & (ATA_UNC | ATA_AMNF)) |
022bdb075 [PATCH] libata-eh... |
1870 1871 1872 1873 1874 1875 |
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... |
1876 |
if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) { |
3eabddb8e libata-eh: update... |
1877 1878 1879 |
tmp = atapi_eh_request_sense(qc->dev, qc->scsicmd->sense_buffer, qc->result_tf.feature >> 4); |
3852e3738 libata: evaluate ... |
1880 |
if (!tmp) |
a569a30d3 [PATCH] libata: d... |
1881 |
qc->flags |= ATA_QCFLAG_SENSE_VALID; |
3852e3738 libata: evaluate ... |
1882 |
else |
a569a30d3 [PATCH] libata: d... |
1883 1884 |
qc->err_mask |= tmp; } |
022bdb075 [PATCH] libata-eh... |
1885 |
} |
3852e3738 libata: evaluate ... |
1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 |
if (qc->flags & ATA_QCFLAG_SENSE_VALID) { int ret = scsi_check_sense(qc->scsicmd); /* * SUCCESS here means that the sense code could * evaluated and should be passed to the upper layers * for correct evaluation. * FAILED means the sense code could not interpreted * and the device would need to be reset. * NEEDS_RETRY and ADD_TO_MLQUEUE means that the * command would need to be retried. */ if (ret == NEEDS_RETRY || ret == ADD_TO_MLQUEUE) { qc->flags |= ATA_QCFLAG_RETRY; qc->err_mask |= AC_ERR_OTHER; } else if (ret != SUCCESS) { qc->err_mask |= AC_ERR_HSM; } } |
022bdb075 [PATCH] libata-eh... |
1904 |
if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS)) |
cf4806265 libata: prefer ha... |
1905 |
action |= ATA_EH_RESET; |
022bdb075 [PATCH] libata-eh... |
1906 1907 1908 |
return action; } |
76326ac1a libata: implement... |
1909 1910 |
static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask, int *xfer_ok) |
022bdb075 [PATCH] libata-eh... |
1911 |
{ |
76326ac1a libata: implement... |
1912 1913 1914 1915 1916 1917 |
int base = 0; if (!(eflags & ATA_EFLAG_DUBIOUS_XFER)) *xfer_ok = 1; if (!*xfer_ok) |
75f9cafc2 libata: fix off-b... |
1918 |
base = ATA_ECAT_DUBIOUS_NONE; |
76326ac1a libata: implement... |
1919 |
|
7d47e8d4d libata: put some ... |
1920 |
if (err_mask & AC_ERR_ATA_BUS) |
76326ac1a libata: implement... |
1921 |
return base + ATA_ECAT_ATA_BUS; |
022bdb075 [PATCH] libata-eh... |
1922 |
|
7d47e8d4d libata: put some ... |
1923 |
if (err_mask & AC_ERR_TIMEOUT) |
76326ac1a libata: implement... |
1924 |
return base + ATA_ECAT_TOUT_HSM; |
7d47e8d4d libata: put some ... |
1925 |
|
3884f7b0a libata: clean up ... |
1926 |
if (eflags & ATA_EFLAG_IS_IO) { |
7d47e8d4d libata: put some ... |
1927 |
if (err_mask & AC_ERR_HSM) |
76326ac1a libata: implement... |
1928 |
return base + ATA_ECAT_TOUT_HSM; |
7d47e8d4d libata: put some ... |
1929 1930 |
if ((err_mask & (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV) |
76326ac1a libata: implement... |
1931 |
return base + ATA_ECAT_UNK_DEV; |
022bdb075 [PATCH] libata-eh... |
1932 1933 1934 1935 |
} return 0; } |
7d47e8d4d libata: put some ... |
1936 |
struct speed_down_verdict_arg { |
022bdb075 [PATCH] libata-eh... |
1937 |
u64 since; |
76326ac1a libata: implement... |
1938 |
int xfer_ok; |
3884f7b0a libata: clean up ... |
1939 |
int nr_errors[ATA_ECAT_NR]; |
022bdb075 [PATCH] libata-eh... |
1940 |
}; |
7d47e8d4d libata: put some ... |
1941 |
static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg) |
022bdb075 [PATCH] libata-eh... |
1942 |
{ |
7d47e8d4d libata: put some ... |
1943 |
struct speed_down_verdict_arg *arg = void_arg; |
76326ac1a libata: implement... |
1944 |
int cat; |
022bdb075 [PATCH] libata-eh... |
1945 |
|
d9027470b [libata] Add ATA ... |
1946 |
if ((ent->eflags & ATA_EFLAG_OLD_ER) || (ent->timestamp < arg->since)) |
022bdb075 [PATCH] libata-eh... |
1947 |
return -1; |
76326ac1a libata: implement... |
1948 1949 |
cat = ata_eh_categorize_error(ent->eflags, ent->err_mask, &arg->xfer_ok); |
7d47e8d4d libata: put some ... |
1950 |
arg->nr_errors[cat]++; |
76326ac1a libata: implement... |
1951 |
|
022bdb075 [PATCH] libata-eh... |
1952 1953 1954 1955 |
return 0; } /** |
7d47e8d4d libata: put some ... |
1956 |
* ata_eh_speed_down_verdict - Determine speed down verdict |
022bdb075 [PATCH] libata-eh... |
1957 1958 1959 |
* @dev: Device of interest * * This function examines error ring of @dev and determines |
7d47e8d4d libata: put some ... |
1960 1961 |
* whether NCQ needs to be turned off, transfer speed should be * stepped down, or falling back to PIO is necessary. |
022bdb075 [PATCH] libata-eh... |
1962 |
* |
3884f7b0a libata: clean up ... |
1963 1964 1965 1966 1967 1968 1969 |
* 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... |
1970 1971 1972 |
* ECAT_DUBIOUS_* : Identical to above three but occurred while * data transfer hasn't been verified. * |
3884f7b0a libata: clean up ... |
1973 1974 1975 |
* Verdicts are * * NCQ_OFF : Turn off NCQ. |
022bdb075 [PATCH] libata-eh... |
1976 |
* |
3884f7b0a libata: clean up ... |
1977 1978 |
* SPEED_DOWN : Speed down transfer speed but don't fall back * to PIO. |
7d47e8d4d libata: put some ... |
1979 |
* |
3884f7b0a libata: clean up ... |
1980 |
* FALLBACK_TO_PIO : Fall back to PIO. |
022bdb075 [PATCH] libata-eh... |
1981 |
* |
3884f7b0a libata: clean up ... |
1982 |
* Even if multiple verdicts are returned, only one action is |
76326ac1a libata: implement... |
1983 1984 1985 1986 1987 1988 1989 |
* 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 ... |
1990 |
* |
76326ac1a libata: implement... |
1991 1992 1993 1994 1995 1996 1997 |
* 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 |
25985edce Fix common misspe... |
1998 |
* occurred during last 5 mins, FALLBACK_TO_PIO |
7d47e8d4d libata: put some ... |
1999 |
* |
76326ac1a libata: implement... |
2000 |
* 4. If more than 3 TOUT_HSM or UNK_DEV errors occurred |
3884f7b0a libata: clean up ... |
2001 2002 |
* during last 10 mins, NCQ_OFF. * |
76326ac1a libata: implement... |
2003 |
* 5. If more than 3 ATA_BUS or TOUT_HSM errors, or more than 6 |
3884f7b0a libata: clean up ... |
2004 |
* UNK_DEV errors occurred during last 10 mins, SPEED_DOWN. |
7d47e8d4d libata: put some ... |
2005 |
* |
022bdb075 [PATCH] libata-eh... |
2006 2007 2008 2009 |
* LOCKING: * Inherited from caller. * * RETURNS: |
7d47e8d4d libata: put some ... |
2010 |
* OR of ATA_EH_SPDN_* flags. |
022bdb075 [PATCH] libata-eh... |
2011 |
*/ |
7d47e8d4d libata: put some ... |
2012 |
static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev) |
022bdb075 [PATCH] libata-eh... |
2013 |
{ |
7d47e8d4d libata: put some ... |
2014 2015 2016 2017 |
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... |
2018 |
|
3884f7b0a libata: clean up ... |
2019 |
/* scan past 5 mins of error history */ |
7d47e8d4d libata: put some ... |
2020 |
memset(&arg, 0, sizeof(arg)); |
3884f7b0a libata: clean up ... |
2021 |
arg.since = j64 - min(j64, j5mins); |
7d47e8d4d libata: put some ... |
2022 |
ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg); |
022bdb075 [PATCH] libata-eh... |
2023 |
|
76326ac1a libata: implement... |
2024 2025 2026 2027 2028 2029 2030 2031 |
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 ... |
2032 2033 |
if (arg.nr_errors[ATA_ECAT_ATA_BUS] + arg.nr_errors[ATA_ECAT_TOUT_HSM] + |
663f99b86 libata: adjust sp... |
2034 |
arg.nr_errors[ATA_ECAT_UNK_DEV] > 6) |
3884f7b0a libata: clean up ... |
2035 |
verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO; |
022bdb075 [PATCH] libata-eh... |
2036 |
|
3884f7b0a libata: clean up ... |
2037 |
/* scan past 10 mins of error history */ |
022bdb075 [PATCH] libata-eh... |
2038 |
memset(&arg, 0, sizeof(arg)); |
3884f7b0a libata: clean up ... |
2039 |
arg.since = j64 - min(j64, j10mins); |
7d47e8d4d libata: put some ... |
2040 |
ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg); |
022bdb075 [PATCH] libata-eh... |
2041 |
|
3884f7b0a libata: clean up ... |
2042 2043 2044 2045 2046 2047 |
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... |
2048 |
arg.nr_errors[ATA_ECAT_UNK_DEV] > 6) |
3884f7b0a libata: clean up ... |
2049 |
verdict |= ATA_EH_SPDN_SPEED_DOWN; |
022bdb075 [PATCH] libata-eh... |
2050 |
|
7d47e8d4d libata: put some ... |
2051 |
return verdict; |
022bdb075 [PATCH] libata-eh... |
2052 2053 2054 2055 2056 |
} /** * ata_eh_speed_down - record error and speed down if necessary * @dev: Failed device |
3884f7b0a libata: clean up ... |
2057 |
* @eflags: mask of ATA_EFLAG_* flags |
022bdb075 [PATCH] libata-eh... |
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 |
* @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 ... |
2069 |
* Determined recovery action. |
022bdb075 [PATCH] libata-eh... |
2070 |
*/ |
3884f7b0a libata: clean up ... |
2071 2072 |
static unsigned int ata_eh_speed_down(struct ata_device *dev, unsigned int eflags, unsigned int err_mask) |
022bdb075 [PATCH] libata-eh... |
2073 |
{ |
b1c72916a libata: implement... |
2074 |
struct ata_link *link = ata_dev_phys_link(dev); |
76326ac1a libata: implement... |
2075 |
int xfer_ok = 0; |
7d47e8d4d libata: put some ... |
2076 2077 2078 2079 |
unsigned int verdict; unsigned int action = 0; /* don't bother if Cat-0 error */ |
76326ac1a libata: implement... |
2080 |
if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0) |
022bdb075 [PATCH] libata-eh... |
2081 2082 2083 |
return 0; /* record error and determine whether speed down is necessary */ |
3884f7b0a libata: clean up ... |
2084 |
ata_ering_record(&dev->ering, eflags, err_mask); |
7d47e8d4d libata: put some ... |
2085 |
verdict = ata_eh_speed_down_verdict(dev); |
022bdb075 [PATCH] libata-eh... |
2086 |
|
7d47e8d4d libata: put some ... |
2087 2088 2089 2090 2091 |
/* 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; |
a9a79dfec ata: Convert ata_... |
2092 2093 |
ata_dev_warn(dev, "NCQ disabled due to excessive errors "); |
7d47e8d4d libata: put some ... |
2094 2095 |
goto done; } |
022bdb075 [PATCH] libata-eh... |
2096 |
|
7d47e8d4d libata: put some ... |
2097 2098 2099 |
/* speed down? */ if (verdict & ATA_EH_SPDN_SPEED_DOWN) { /* speed down SATA link speed if possible */ |
a07d499b4 libata: add @spd_... |
2100 |
if (sata_down_spd_limit(link, 0) == 0) { |
cf4806265 libata: prefer ha... |
2101 |
action |= ATA_EH_RESET; |
7d47e8d4d libata: put some ... |
2102 2103 |
goto done; } |
022bdb075 [PATCH] libata-eh... |
2104 |
|
7d47e8d4d libata: put some ... |
2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 |
/* 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... |
2121 |
action |= ATA_EH_RESET; |
7d47e8d4d libata: put some ... |
2122 2123 2124 2125 2126 2127 |
goto done; } } } /* Fall back to PIO? Slowing down to PIO is meaningless for |
663f99b86 libata: adjust sp... |
2128 |
* SATA ATA devices. Consider it only for PATA and SATAPI. |
7d47e8d4d libata: put some ... |
2129 2130 |
*/ if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) && |
663f99b86 libata: adjust sp... |
2131 |
(link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) && |
7d47e8d4d libata: put some ... |
2132 2133 2134 |
(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... |
2135 |
action |= ATA_EH_RESET; |
7d47e8d4d libata: put some ... |
2136 2137 2138 |
goto done; } } |
022bdb075 [PATCH] libata-eh... |
2139 |
|
022bdb075 [PATCH] libata-eh... |
2140 |
return 0; |
7d47e8d4d libata: put some ... |
2141 2142 |
done: /* device has been slowed down, blow error history */ |
76326ac1a libata: implement... |
2143 2144 |
if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS)) ata_ering_clear(&dev->ering); |
7d47e8d4d libata: put some ... |
2145 |
return action; |
022bdb075 [PATCH] libata-eh... |
2146 2147 2148 |
} /** |
8d899e70c libata-eh don't w... |
2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 |
* ata_eh_worth_retry - analyze error and decide whether to retry * @qc: qc to possibly retry * * Look at the cause of the error and decide if a retry * might be useful or not. We don't want to retry media errors * because the drive itself has probably already taken 10-30 seconds * doing its own internal retries before reporting the failure. */ static inline int ata_eh_worth_retry(struct ata_queued_cmd *qc) { |
1eaca39a8 [libata] ahci: Fi... |
2159 |
if (qc->err_mask & AC_ERR_MEDIA) |
8d899e70c libata-eh don't w... |
2160 2161 2162 2163 2164 2165 2166 2167 2168 |
return 0; /* don't retry media errors */ if (qc->flags & ATA_QCFLAG_IO) return 1; /* otherwise retry anything from fs stack */ if (qc->err_mask & AC_ERR_INVALID) return 0; /* don't retry these */ return qc->err_mask != AC_ERR_DEV; /* retry if not dev error */ } /** |
9b1e2658f libata-link: upda... |
2169 2170 |
* ata_eh_link_autopsy - analyze error and determine recovery action * @link: host link to perform autopsy on |
022bdb075 [PATCH] libata-eh... |
2171 |
* |
0260731f0 libata-link: link... |
2172 2173 2174 |
* 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... |
2175 2176 2177 2178 |
* * LOCKING: * Kernel thread context (may sleep). */ |
9b1e2658f libata-link: upda... |
2179 |
static void ata_eh_link_autopsy(struct ata_link *link) |
022bdb075 [PATCH] libata-eh... |
2180 |
{ |
0260731f0 libata-link: link... |
2181 |
struct ata_port *ap = link->ap; |
936fd7328 libata-link: link... |
2182 |
struct ata_eh_context *ehc = &link->eh_context; |
dfcc173d7 libata: consider ... |
2183 |
struct ata_device *dev; |
3884f7b0a libata: clean up ... |
2184 2185 |
unsigned int all_err_mask = 0, eflags = 0; int tag; |
022bdb075 [PATCH] libata-eh... |
2186 2187 2188 2189 2190 |
u32 serror; int rc; DPRINTK("ENTER "); |
1cdaf534f [PATCH] libata: i... |
2191 2192 |
if (ehc->i.flags & ATA_EHI_NO_AUTOPSY) return; |
022bdb075 [PATCH] libata-eh... |
2193 |
/* obtain and analyze SError */ |
936fd7328 libata-link: link... |
2194 |
rc = sata_scr_read(link, SCR_ERROR, &serror); |
022bdb075 [PATCH] libata-eh... |
2195 2196 |
if (rc == 0) { ehc->i.serror |= serror; |
0260731f0 libata-link: link... |
2197 |
ata_eh_analyze_serror(link); |
4e57c517b libata: schedule ... |
2198 |
} else if (rc != -EOPNOTSUPP) { |
cf4806265 libata: prefer ha... |
2199 |
/* SError read failed, force reset and probing */ |
b558edddb libata: kill ata_... |
2200 |
ehc->i.probe_mask |= ATA_ALL_DEVICES; |
cf4806265 libata: prefer ha... |
2201 |
ehc->i.action |= ATA_EH_RESET; |
4e57c517b libata: schedule ... |
2202 2203 |
ehc->i.err_mask |= AC_ERR_OTHER; } |
022bdb075 [PATCH] libata-eh... |
2204 |
|
e8ee84518 [PATCH] libata-nc... |
2205 |
/* analyze NCQ failure */ |
0260731f0 libata-link: link... |
2206 |
ata_eh_analyze_ncq_error(link); |
e8ee84518 [PATCH] libata-nc... |
2207 |
|
022bdb075 [PATCH] libata-eh... |
2208 2209 2210 2211 2212 2213 2214 2215 |
/* 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... |
2216 2217 |
if (!(qc->flags & ATA_QCFLAG_FAILED) || ata_dev_phys_link(qc->dev) != link) |
022bdb075 [PATCH] libata-eh... |
2218 2219 2220 2221 |
continue; /* inherit upper level err_mask */ qc->err_mask |= ehc->i.err_mask; |
022bdb075 [PATCH] libata-eh... |
2222 |
/* analyze TF */ |
4528e4da7 [PATCH] libata: f... |
2223 |
ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf); |
022bdb075 [PATCH] libata-eh... |
2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 |
/* 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... |
2235 |
if (qc->flags & ATA_QCFLAG_SENSE_VALID) |
022bdb075 [PATCH] libata-eh... |
2236 |
qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER); |
022bdb075 [PATCH] libata-eh... |
2237 |
|
03faab782 libata: implement... |
2238 |
/* determine whether the command is worth retrying */ |
8d899e70c libata-eh don't w... |
2239 |
if (ata_eh_worth_retry(qc)) |
03faab782 libata: implement... |
2240 |
qc->flags |= ATA_QCFLAG_RETRY; |
022bdb075 [PATCH] libata-eh... |
2241 |
/* accumulate error info */ |
4528e4da7 [PATCH] libata: f... |
2242 |
ehc->i.dev = qc->dev; |
022bdb075 [PATCH] libata-eh... |
2243 2244 |
all_err_mask |= qc->err_mask; if (qc->flags & ATA_QCFLAG_IO) |
3884f7b0a libata: clean up ... |
2245 |
eflags |= ATA_EFLAG_IS_IO; |
255c03d15 libata: Add trace... |
2246 |
trace_ata_eh_link_autopsy_qc(qc); |
022bdb075 [PATCH] libata-eh... |
2247 |
} |
a20f33ffd [PATCH] libata: e... |
2248 |
/* enforce default EH actions */ |
b51e9e5db [PATCH] libata: a... |
2249 |
if (ap->pflags & ATA_PFLAG_FROZEN || |
a20f33ffd [PATCH] libata: e... |
2250 |
all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT)) |
cf4806265 libata: prefer ha... |
2251 |
ehc->i.action |= ATA_EH_RESET; |
3884f7b0a libata: clean up ... |
2252 2253 |
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... |
2254 |
ehc->i.action |= ATA_EH_REVALIDATE; |
022bdb075 [PATCH] libata-eh... |
2255 |
|
dfcc173d7 libata: consider ... |
2256 2257 2258 |
/* If we have offending qcs and the associated failed device, * perform per-dev EH action only on the offending device. */ |
4528e4da7 [PATCH] libata: f... |
2259 |
if (ehc->i.dev) { |
4528e4da7 [PATCH] libata: f... |
2260 2261 2262 |
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... |
2263 |
} |
2695e3661 libata-pmp: propa... |
2264 2265 2266 2267 2268 |
/* 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 ... |
2269 |
dev = ehc->i.dev; |
2695e3661 libata-pmp: propa... |
2270 2271 2272 |
if (!dev && ((ata_link_max_devices(link) == 1 && ata_dev_enabled(link->device)))) dev = link->device; |
dfcc173d7 libata: consider ... |
2273 |
|
76326ac1a libata: implement... |
2274 2275 2276 |
if (dev) { if (dev->flags & ATA_DFLAG_DUBIOUS_XFER) eflags |= ATA_EFLAG_DUBIOUS_XFER; |
3884f7b0a libata: clean up ... |
2277 |
ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask); |
76326ac1a libata: implement... |
2278 |
} |
255c03d15 libata: Add trace... |
2279 |
trace_ata_eh_link_autopsy(dev, ehc->i.action, all_err_mask); |
022bdb075 [PATCH] libata-eh... |
2280 2281 2282 2283 2284 |
DPRINTK("EXIT "); } /** |
9b1e2658f libata-link: upda... |
2285 2286 2287 2288 2289 2290 2291 2292 2293 |
* 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: ... |
2294 |
void ata_eh_autopsy(struct ata_port *ap) |
9b1e2658f libata-link: upda... |
2295 2296 |
{ struct ata_link *link; |
1eca4365b libata: beef up i... |
2297 |
ata_for_each_link(link, ap, EDGE) |
9b1e2658f libata-link: upda... |
2298 |
ata_eh_link_autopsy(link); |
2695e3661 libata-pmp: propa... |
2299 |
|
b1c72916a libata: implement... |
2300 2301 2302 2303 2304 2305 2306 |
/* 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 ... |
2307 2308 2309 2310 |
/* 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... |
2311 |
ata_eh_link_autopsy(ap->slave_link); |
848e4c68c libata: transfer ... |
2312 |
/* transfer actions from slave to master and clear slave */ |
b1c72916a libata: implement... |
2313 2314 2315 2316 2317 2318 |
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... |
2319 2320 2321 |
/* Autopsy of fanout ports can affect host link autopsy. * Perform host link autopsy last. */ |
071f44b1d libata: implement... |
2322 |
if (sata_pmp_attached(ap)) |
2695e3661 libata-pmp: propa... |
2323 |
ata_eh_link_autopsy(&ap->link); |
9b1e2658f libata-link: upda... |
2324 2325 2326 |
} /** |
6521148c6 libata: add comma... |
2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 |
* 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" }, |
825e2d878 libata: whitespac... |
2345 2346 2347 2348 2349 |
{ 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" }, |
3915c3b5b libata: Add some ... |
2350 |
{ ATA_CMD_DOWNLOAD_MICRO_DMA, "DOWNLOAD MICROCODE DMA" }, |
6521148c6 libata: add comma... |
2351 |
{ ATA_CMD_NOP, "NOP" }, |
825e2d878 libata: whitespac... |
2352 2353 2354 2355 2356 2357 2358 2359 2360 |
{ 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" }, |
6521148c6 libata: add comma... |
2361 |
{ ATA_CMD_READ_STREAM_DMA_EXT, "READ STREAM DMA EXT" }, |
825e2d878 libata: whitespac... |
2362 2363 2364 2365 |
{ 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" }, |
6521148c6 libata: add comma... |
2366 2367 2368 2369 2370 |
{ 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" }, |
3915c3b5b libata: Add some ... |
2371 2372 |
{ ATA_CMD_FPDMA_SEND, "SEND FPDMA QUEUED" }, { ATA_CMD_FPDMA_RECV, "RECEIVE FPDMA QUEUED" }, |
6521148c6 libata: add comma... |
2373 2374 2375 2376 2377 2378 2379 2380 |
{ 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" }, |
825e2d878 libata: whitespac... |
2381 |
{ ATA_CMD_WRITE_MULTI_FUA_EXT, "WRITE MULTIPLE FUA EXT" }, |
6521148c6 libata: add comma... |
2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 |
{ 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" }, |
825e2d878 libata: whitespac... |
2398 |
{ ATA_CMD_WRITE_LOG_DMA_EXT, "WRITE LOG DMA EXT" }, |
3915c3b5b libata: Add some ... |
2399 |
{ ATA_CMD_TRUSTED_NONDATA, "TRUSTED NON-DATA" }, |
6521148c6 libata: add comma... |
2400 |
{ ATA_CMD_TRUSTED_RCV, "TRUSTED RECEIVE" }, |
825e2d878 libata: whitespac... |
2401 |
{ ATA_CMD_TRUSTED_RCV_DMA, "TRUSTED RECEIVE DMA" }, |
6521148c6 libata: add comma... |
2402 |
{ ATA_CMD_TRUSTED_SND, "TRUSTED SEND" }, |
825e2d878 libata: whitespac... |
2403 |
{ ATA_CMD_TRUSTED_SND_DMA, "TRUSTED SEND DMA" }, |
6521148c6 libata: add comma... |
2404 |
{ ATA_CMD_PMP_READ, "READ BUFFER" }, |
3915c3b5b libata: Add some ... |
2405 |
{ ATA_CMD_PMP_READ_DMA, "READ BUFFER DMA" }, |
6521148c6 libata: add comma... |
2406 |
{ ATA_CMD_PMP_WRITE, "WRITE BUFFER" }, |
3915c3b5b libata: Add some ... |
2407 |
{ ATA_CMD_PMP_WRITE_DMA, "WRITE BUFFER DMA" }, |
6521148c6 libata: add comma... |
2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 |
{ 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_... |
2419 |
{ ATA_CMD_DSM, "DATA SET MANAGEMENT" }, |
825e2d878 libata: whitespac... |
2420 2421 |
{ ATA_CMD_CHK_MED_CRD_TYP, "CHECK MEDIA CARD TYPE" }, { ATA_CMD_CFA_REQ_EXT_ERR, "CFA REQUEST EXTENDED ERROR" }, |
6521148c6 libata: add comma... |
2422 2423 2424 |
{ 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" }, |
825e2d878 libata: whitespac... |
2425 |
{ ATA_CMD_CFA_WRITE_MULT_NE, "CFA WRITE MULTIPLE WITHOUT ERASE" }, |
3915c3b5b libata: Add some ... |
2426 2427 |
{ ATA_CMD_REQ_SENSE_DATA, "REQUEST SENSE DATA EXT" }, { ATA_CMD_SANITIZE_DEVICE, "SANITIZE DEVICE" }, |
28a3fc229 libata: implement... |
2428 |
{ ATA_CMD_ZAC_MGMT_IN, "ZAC MANAGEMENT IN" }, |
27708a957 libata: Implement... |
2429 |
{ ATA_CMD_ZAC_MGMT_OUT, "ZAC MANAGEMENT OUT" }, |
6521148c6 libata: add comma... |
2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 |
{ 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; } |
36aae28e3 libata: export at... |
2446 |
EXPORT_SYMBOL_GPL(ata_get_cmd_descript); |
6521148c6 libata: add comma... |
2447 2448 |
/** |
9b1e2658f libata-link: upda... |
2449 |
* ata_eh_link_report - report error handling to user |
0260731f0 libata-link: link... |
2450 |
* @link: ATA link EH is going on |
022bdb075 [PATCH] libata-eh... |
2451 2452 2453 2454 2455 2456 |
* * Report EH to user. * * LOCKING: * None. */ |
9b1e2658f libata-link: upda... |
2457 |
static void ata_eh_link_report(struct ata_link *link) |
022bdb075 [PATCH] libata-eh... |
2458 |
{ |
0260731f0 libata-link: link... |
2459 2460 |
struct ata_port *ap = link->ap; struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
2461 |
const char *frozen, *desc; |
462098b09 ata: libata-eh: R... |
2462 |
char tries_buf[6] = ""; |
022bdb075 [PATCH] libata-eh... |
2463 |
int tag, nr_failed = 0; |
94ff3d540 libata: skip supp... |
2464 2465 |
if (ehc->i.flags & ATA_EHI_QUIET) return; |
022bdb075 [PATCH] libata-eh... |
2466 2467 2468 2469 2470 2471 |
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... |
2472 2473 |
if (!(qc->flags & ATA_QCFLAG_FAILED) || ata_dev_phys_link(qc->dev) != link || |
e027bd36c libata: implement... |
2474 2475 |
((qc->flags & ATA_QCFLAG_QUIET) && qc->err_mask == AC_ERR_DEV)) |
022bdb075 [PATCH] libata-eh... |
2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 |
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... |
2487 |
if (ap->pflags & ATA_PFLAG_FROZEN) |
022bdb075 [PATCH] libata-eh... |
2488 |
frozen = " frozen"; |
a1e10f7e6 libata: move EH r... |
2489 |
if (ap->eh_tries < ATA_EH_MAX_TRIES) |
462098b09 ata: libata-eh: R... |
2490 |
snprintf(tries_buf, sizeof(tries_buf), " t%d", |
a1e10f7e6 libata: move EH r... |
2491 |
ap->eh_tries); |
022bdb075 [PATCH] libata-eh... |
2492 |
if (ehc->i.dev) { |
a9a79dfec ata: Convert ata_... |
2493 2494 2495 2496 2497 |
ata_dev_err(ehc->i.dev, "exception Emask 0x%x " "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... |
2498 |
if (desc) |
a9a79dfec ata: Convert ata_... |
2499 2500 |
ata_dev_err(ehc->i.dev, "%s ", desc); |
022bdb075 [PATCH] libata-eh... |
2501 |
} else { |
a9a79dfec ata: Convert ata_... |
2502 2503 2504 2505 2506 |
ata_link_err(link, "exception Emask 0x%x " "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... |
2507 |
if (desc) |
a9a79dfec ata: Convert ata_... |
2508 2509 |
ata_link_err(link, "%s ", desc); |
022bdb075 [PATCH] libata-eh... |
2510 |
} |
6521148c6 libata: add comma... |
2511 |
#ifdef CONFIG_ATA_VERBOSE_ERROR |
1333e1943 libata: add human... |
2512 |
if (ehc->i.serror) |
a9a79dfec ata: Convert ata_... |
2513 |
ata_link_err(link, |
1333e1943 libata: add human... |
2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 |
"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... |
2532 |
ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : ""); |
6521148c6 libata: add comma... |
2533 |
#endif |
1333e1943 libata: add human... |
2534 |
|
022bdb075 [PATCH] libata-eh... |
2535 2536 |
for (tag = 0; tag < ATA_MAX_QUEUE; tag++) { struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag); |
8a9375817 [PATCH] libata: i... |
2537 |
struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf; |
abb6a8897 libata: report pr... |
2538 2539 |
char data_buf[20] = ""; char cdb_buf[70] = ""; |
022bdb075 [PATCH] libata-eh... |
2540 |
|
0260731f0 libata-link: link... |
2541 |
if (!(qc->flags & ATA_QCFLAG_FAILED) || |
b1c72916a libata: implement... |
2542 |
ata_dev_phys_link(qc->dev) != link || !qc->err_mask) |
022bdb075 [PATCH] libata-eh... |
2543 |
continue; |
abb6a8897 libata: report pr... |
2544 2545 2546 2547 2548 2549 2550 |
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[] = { |
5b51ba617 libata-eh: decode... |
2551 2552 |
[ATA_PROT_UNKNOWN] = "unknown", [ATA_PROT_NODATA] = "nodata", |
abb6a8897 libata: report pr... |
2553 2554 |
[ATA_PROT_PIO] = "pio", [ATA_PROT_DMA] = "dma", |
5b844b63d ata: Handle ATA N... |
2555 2556 |
[ATA_PROT_NCQ] = "ncq dma", [ATA_PROT_NCQ_NODATA] = "ncq nodata", |
5b51ba617 libata-eh: decode... |
2557 |
[ATAPI_PROT_NODATA] = "nodata", |
0dc36888d libata: rename AT... |
2558 2559 |
[ATAPI_PROT_PIO] = "pio", [ATAPI_PROT_DMA] = "dma", |
abb6a8897 libata: report pr... |
2560 2561 2562 2563 2564 2565 |
}; 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... |
2566 |
if (ata_is_atapi(qc->tf.protocol)) { |
a13b0c9d0 libata: fixup oop... |
2567 2568 |
const u8 *cdb = qc->cdb; size_t cdb_len = qc->dev->cdb_len; |
cbba5b0ee libata: use __scs... |
2569 2570 2571 2572 2573 2574 |
if (qc->scsicmd) { cdb = qc->scsicmd->cmnd; cdb_len = qc->scsicmd->cmd_len; } __scsi_format_command(cdb_buf, sizeof(cdb_buf), cdb, cdb_len); |
6521148c6 libata: add comma... |
2575 2576 2577 |
} else { const char *descr = ata_get_cmd_descript(cmd->command); if (descr) |
a9a79dfec ata: Convert ata_... |
2578 2579 2580 |
ata_dev_err(qc->dev, "failed command: %s ", descr); |
6521148c6 libata: add comma... |
2581 |
} |
abb6a8897 libata: report pr... |
2582 |
|
a9a79dfec ata: Convert ata_... |
2583 |
ata_dev_err(qc->dev, |
8a9375817 [PATCH] libata: i... |
2584 |
"cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x " |
abb6a8897 libata: report pr... |
2585 2586 |
"tag %d%s %s" |
8a9375817 [PATCH] libata: i... |
2587 |
"res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x " |
5335b7290 libata: implement... |
2588 2589 |
"Emask 0x%x (%s)%s ", |
8a9375817 [PATCH] libata: i... |
2590 2591 2592 2593 |
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... |
2594 |
cmd->device, qc->tag, data_buf, cdb_buf, |
8a9375817 [PATCH] libata: i... |
2595 2596 2597 2598 |
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... |
2599 2600 |
res->device, qc->err_mask, ata_err_string(qc->err_mask), qc->err_mask & AC_ERR_NCQ ? " <F>" : ""); |
1333e1943 libata: add human... |
2601 |
|
6521148c6 libata: add comma... |
2602 |
#ifdef CONFIG_ATA_VERBOSE_ERROR |
1333e1943 libata: add human... |
2603 |
if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ | |
e87fd28cf libata: Implement... |
2604 |
ATA_SENSE | ATA_ERR)) { |
1333e1943 libata: add human... |
2605 |
if (res->command & ATA_BUSY) |
a9a79dfec ata: Convert ata_... |
2606 2607 |
ata_dev_err(qc->dev, "status: { Busy } "); |
1333e1943 libata: add human... |
2608 |
else |
e87fd28cf libata: Implement... |
2609 2610 |
ata_dev_err(qc->dev, "status: { %s%s%s%s%s} ", |
1333e1943 libata: add human... |
2611 2612 2613 |
res->command & ATA_DRDY ? "DRDY " : "", res->command & ATA_DF ? "DF " : "", res->command & ATA_DRQ ? "DRQ " : "", |
e87fd28cf libata: Implement... |
2614 |
res->command & ATA_SENSE ? "SENSE " : "", |
2dcb407e6 [libata] checkpat... |
2615 |
res->command & ATA_ERR ? "ERR " : ""); |
1333e1943 libata: add human... |
2616 2617 2618 |
} if (cmd->command != ATA_CMD_PACKET && |
eec7e1c16 libata: EH should... |
2619 2620 2621 2622 |
(res->feature & (ATA_ICRC | ATA_UNC | ATA_AMNF | ATA_IDNF | ATA_ABORTED))) ata_dev_err(qc->dev, "error: { %s%s%s%s%s} ", |
1333e1943 libata: add human... |
2623 2624 |
res->feature & ATA_ICRC ? "ICRC " : "", res->feature & ATA_UNC ? "UNC " : "", |
eec7e1c16 libata: EH should... |
2625 |
res->feature & ATA_AMNF ? "AMNF " : "", |
1333e1943 libata: add human... |
2626 |
res->feature & ATA_IDNF ? "IDNF " : "", |
2dcb407e6 [libata] checkpat... |
2627 |
res->feature & ATA_ABORTED ? "ABRT " : ""); |
6521148c6 libata: add comma... |
2628 |
#endif |
022bdb075 [PATCH] libata-eh... |
2629 2630 |
} } |
9b1e2658f libata-link: upda... |
2631 2632 2633 2634 2635 2636 2637 2638 2639 |
/** * 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: ... |
2640 |
void ata_eh_report(struct ata_port *ap) |
9b1e2658f libata-link: upda... |
2641 2642 |
{ struct ata_link *link; |
1eca4365b libata: beef up i... |
2643 |
ata_for_each_link(link, ap, HOST_FIRST) |
9b1e2658f libata-link: upda... |
2644 2645 |
ata_eh_link_report(link); } |
cc0680a58 libata-link: link... |
2646 |
static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset, |
b1c72916a libata: implement... |
2647 2648 |
unsigned int *classes, unsigned long deadline, bool clear_classes) |
d87fa38e7 [PATCH] libata-hp... |
2649 |
{ |
f58229f80 libata-link: impl... |
2650 |
struct ata_device *dev; |
d87fa38e7 [PATCH] libata-hp... |
2651 |
|
b1c72916a libata: implement... |
2652 |
if (clear_classes) |
1eca4365b libata: beef up i... |
2653 |
ata_for_each_dev(dev, link, ALL) |
b1c72916a libata: implement... |
2654 |
classes[dev->devno] = ATA_DEV_UNKNOWN; |
d87fa38e7 [PATCH] libata-hp... |
2655 |
|
f046519fc libata: kill hotp... |
2656 |
return reset(link, classes, deadline); |
d87fa38e7 [PATCH] libata-hp... |
2657 |
} |
e8411fbad libata-eh: ata_eh... |
2658 |
static int ata_eh_followup_srst_needed(struct ata_link *link, int rc) |
664faf09a [PATCH] libata-hp... |
2659 |
{ |
45db2f6c9 libata: move link... |
2660 |
if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link)) |
ae791c056 libata-pmp-prep: ... |
2661 |
return 0; |
5dbfc9cb5 libata: always do... |
2662 2663 |
if (rc == -EAGAIN) return 1; |
071f44b1d libata: implement... |
2664 |
if (sata_pmp_supported(link->ap) && ata_is_host_link(link)) |
3495de733 libata-pmp: updat... |
2665 |
return 1; |
664faf09a [PATCH] libata-hp... |
2666 2667 |
return 0; } |
fb7fd6145 libata-pmp-prep: ... |
2668 2669 2670 |
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... |
2671 |
{ |
afaa5c373 libata: implement... |
2672 |
struct ata_port *ap = link->ap; |
b1c72916a libata: implement... |
2673 |
struct ata_link *slave = ap->slave_link; |
936fd7328 libata-link: link... |
2674 |
struct ata_eh_context *ehc = &link->eh_context; |
705d20141 libata: add missi... |
2675 |
struct ata_eh_context *sehc = slave ? &slave->eh_context : NULL; |
664faf09a [PATCH] libata-hp... |
2676 |
unsigned int *classes = ehc->classes; |
416dc9ed2 libata: cosmetic ... |
2677 |
unsigned int lflags = link->flags; |
1cdaf534f [PATCH] libata: i... |
2678 |
int verbose = !(ehc->i.flags & ATA_EHI_QUIET); |
d8af0eb60 libata: use ULONG... |
2679 |
int max_tries = 0, try = 0; |
b1c72916a libata: implement... |
2680 |
struct ata_link *failed_link; |
f58229f80 libata-link: impl... |
2681 |
struct ata_device *dev; |
416dc9ed2 libata: cosmetic ... |
2682 |
unsigned long deadline, now; |
022bdb075 [PATCH] libata-eh... |
2683 |
ata_reset_fn_t reset; |
afaa5c373 libata: implement... |
2684 |
unsigned long flags; |
416dc9ed2 libata: cosmetic ... |
2685 |
u32 sstatus; |
b1c72916a libata: implement... |
2686 |
int nr_unknown, rc; |
022bdb075 [PATCH] libata-eh... |
2687 |
|
932648b00 libata: reorganiz... |
2688 2689 2690 |
/* * Prepare to reset */ |
d8af0eb60 libata: use ULONG... |
2691 2692 |
while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX) max_tries++; |
ca6d43b05 [SCSI] libata: re... |
2693 2694 |
if (link->flags & ATA_LFLAG_RST_ONCE) max_tries = 1; |
05944bdf6 libata: implement... |
2695 2696 2697 2698 |
if (link->flags & ATA_LFLAG_NO_HRST) hardreset = NULL; if (link->flags & ATA_LFLAG_NO_SRST) softreset = NULL; |
d8af0eb60 libata: use ULONG... |
2699 |
|
25985edce Fix common misspe... |
2700 |
/* make sure each reset attempt is at least COOL_DOWN apart */ |
19b723218 libata: fix last_... |
2701 2702 2703 2704 2705 2706 2707 2708 |
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... |
2709 |
|
afaa5c373 libata: implement... |
2710 2711 2712 |
spin_lock_irqsave(ap->lock, flags); ap->pflags |= ATA_PFLAG_RESETTING; spin_unlock_irqrestore(ap->lock, flags); |
cf4806265 libata: prefer ha... |
2713 |
ata_eh_about_to_do(link, NULL, ATA_EH_RESET); |
13abf50df [PATCH] libata: i... |
2714 |
|
1eca4365b libata: beef up i... |
2715 |
ata_for_each_dev(dev, link, ALL) { |
cdeab1140 libata: relocate ... |
2716 2717 2718 2719 2720 2721 2722 2723 |
/* 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; |
5416912af libata: set dma_m... |
2724 |
dev->dma_mode = 0xff; |
cdeab1140 libata: relocate ... |
2725 2726 2727 2728 2729 2730 2731 2732 2733 |
/* 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... |
2734 |
/* prefer hardreset */ |
932648b00 libata: reorganiz... |
2735 |
reset = NULL; |
cf4806265 libata: prefer ha... |
2736 2737 2738 |
ehc->i.action &= ~ATA_EH_RESET; if (hardreset) { reset = hardreset; |
a674050e0 libata: fix EH ac... |
2739 |
ehc->i.action |= ATA_EH_HARDRESET; |
4f7faa3f2 libata: make EH f... |
2740 |
} else if (softreset) { |
cf4806265 libata: prefer ha... |
2741 |
reset = softreset; |
a674050e0 libata: fix EH ac... |
2742 |
ehc->i.action |= ATA_EH_SOFTRESET; |
cf4806265 libata: prefer ha... |
2743 |
} |
f5914a461 [PATCH] libata-hp... |
2744 2745 |
if (prereset) { |
b1c72916a libata: implement... |
2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 |
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... |
2769 |
if (rc) { |
c961922b7 [PATCH] libata-eh... |
2770 |
if (rc == -ENOENT) { |
a9a79dfec ata: Convert ata_... |
2771 2772 |
ata_link_dbg(link, "port disabled--ignoring "); |
cf4806265 libata: prefer ha... |
2773 |
ehc->i.action &= ~ATA_EH_RESET; |
4aa9ab67f libata: don't whi... |
2774 |
|
1eca4365b libata: beef up i... |
2775 |
ata_for_each_dev(dev, link, ALL) |
f58229f80 libata-link: impl... |
2776 |
classes[dev->devno] = ATA_DEV_NONE; |
4aa9ab67f libata: don't whi... |
2777 2778 |
rc = 0; |
c961922b7 [PATCH] libata-eh... |
2779 |
} else |
a9a79dfec ata: Convert ata_... |
2780 2781 2782 2783 |
ata_link_err(link, "prereset failed (errno=%d) ", rc); |
fccb6ea5c libata: clear HOT... |
2784 |
goto out; |
f5914a461 [PATCH] libata-hp... |
2785 |
} |
f5914a461 [PATCH] libata-hp... |
2786 |
|
932648b00 libata: reorganiz... |
2787 |
/* prereset() might have cleared ATA_EH_RESET. If so, |
d6515e6ff libata: make sure... |
2788 |
* bang classes, thaw and return. |
932648b00 libata: reorganiz... |
2789 2790 |
*/ if (reset && !(ehc->i.action & ATA_EH_RESET)) { |
1eca4365b libata: beef up i... |
2791 |
ata_for_each_dev(dev, link, ALL) |
932648b00 libata: reorganiz... |
2792 |
classes[dev->devno] = ATA_DEV_NONE; |
d6515e6ff libata: make sure... |
2793 2794 2795 |
if ((ap->pflags & ATA_PFLAG_FROZEN) && ata_is_host_link(link)) ata_eh_thaw_port(ap); |
932648b00 libata: reorganiz... |
2796 2797 2798 |
rc = 0; goto out; } |
f5914a461 [PATCH] libata-hp... |
2799 |
} |
022bdb075 [PATCH] libata-eh... |
2800 |
retry: |
932648b00 libata: reorganiz... |
2801 2802 2803 |
/* * Perform reset */ |
dc98c32cb libata: move rese... |
2804 2805 |
if (ata_is_host_link(link)) ata_eh_freeze_port(ap); |
341c2c958 libata: consisten... |
2806 |
deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]); |
31daabda1 libata: reimpleme... |
2807 |
|
932648b00 libata: reorganiz... |
2808 2809 |
if (reset) { if (verbose) |
a9a79dfec ata: Convert ata_... |
2810 2811 2812 |
ata_link_info(link, "%s resetting link ", reset == softreset ? "soft" : "hard"); |
932648b00 libata: reorganiz... |
2813 2814 |
/* mark that this EH session started with reset */ |
19b723218 libata: fix last_... |
2815 |
ehc->last_reset = jiffies; |
932648b00 libata: reorganiz... |
2816 2817 2818 2819 |
if (reset == hardreset) ehc->i.flags |= ATA_EHI_DID_HARDRESET; else ehc->i.flags |= ATA_EHI_DID_SOFTRESET; |
022bdb075 [PATCH] libata-eh... |
2820 |
|
b1c72916a libata: implement... |
2821 2822 2823 |
rc = ata_do_reset(link, reset, classes, deadline, true); if (rc && rc != -EAGAIN) { failed_link = link; |
5dbfc9cb5 libata: always do... |
2824 |
goto fail; |
b1c72916a libata: implement... |
2825 2826 2827 2828 2829 2830 2831 |
} /* hardreset slave link if existent */ if (slave && reset == hardreset) { int tmp; if (verbose) |
a9a79dfec ata: Convert ata_... |
2832 2833 |
ata_link_info(slave, "hard resetting link "); |
b1c72916a libata: implement... |
2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 |
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... |
2849 |
|
b1c72916a libata: implement... |
2850 |
/* perform follow-up SRST if necessary */ |
932648b00 libata: reorganiz... |
2851 |
if (reset == hardreset && |
e8411fbad libata-eh: ata_eh... |
2852 |
ata_eh_followup_srst_needed(link, rc)) { |
932648b00 libata: reorganiz... |
2853 |
reset = softreset; |
022bdb075 [PATCH] libata-eh... |
2854 |
|
932648b00 libata: reorganiz... |
2855 |
if (!reset) { |
a9a79dfec ata: Convert ata_... |
2856 2857 2858 |
ata_link_err(link, "follow-up softreset required but no softreset available "); |
b1c72916a libata: implement... |
2859 |
failed_link = link; |
932648b00 libata: reorganiz... |
2860 2861 2862 |
rc = -EINVAL; goto fail; } |
664faf09a [PATCH] libata-hp... |
2863 |
|
932648b00 libata: reorganiz... |
2864 |
ata_eh_about_to_do(link, NULL, ATA_EH_RESET); |
b1c72916a libata: implement... |
2865 |
rc = ata_do_reset(link, reset, classes, deadline, true); |
fe2c4d018 libata: fix follo... |
2866 2867 2868 2869 |
if (rc) { failed_link = link; goto fail; } |
664faf09a [PATCH] libata-hp... |
2870 |
} |
932648b00 libata: reorganiz... |
2871 2872 |
} else { if (verbose) |
a9a79dfec ata: Convert ata_... |
2873 2874 2875 |
ata_link_info(link, "no reset method available, skipping reset "); |
932648b00 libata: reorganiz... |
2876 2877 |
if (!(lflags & ATA_LFLAG_ASSUME_CLASS)) lflags |= ATA_LFLAG_ASSUME_ATA; |
664faf09a [PATCH] libata-hp... |
2878 |
} |
932648b00 libata: reorganiz... |
2879 2880 2881 |
/* * Post-reset processing */ |
1eca4365b libata: beef up i... |
2882 |
ata_for_each_dev(dev, link, ALL) { |
416dc9ed2 libata: cosmetic ... |
2883 2884 2885 2886 2887 2888 |
/* 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... |
2889 |
|
3b761d3d4 libata: fix incor... |
2890 2891 2892 2893 2894 2895 2896 2897 |
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... |
2898 |
} |
416dc9ed2 libata: cosmetic ... |
2899 2900 2901 |
/* record current link speed */ if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0) link->sata_spd = (sstatus >> 4) & 0xf; |
b1c72916a libata: implement... |
2902 2903 |
if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0) slave->sata_spd = (sstatus >> 4) & 0xf; |
008a78961 libata: improve S... |
2904 |
|
dc98c32cb libata: move rese... |
2905 2906 2907 |
/* thaw the port */ if (ata_is_host_link(link)) ata_eh_thaw_port(ap); |
f046519fc libata: kill hotp... |
2908 2909 2910 2911 2912 2913 2914 |
/* 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... |
2915 |
if (postreset) { |
416dc9ed2 libata: cosmetic ... |
2916 |
postreset(link, classes); |
b1c72916a libata: implement... |
2917 2918 2919 |
if (slave) postreset(slave, classes); } |
20952b699 [PATCH] libata: s... |
2920 |
|
1e641060c libata: clear eh_... |
2921 |
/* |
8c56cacc7 libata: fix unexp... |
2922 2923 2924 2925 2926 |
* Some controllers can't be frozen very well and may set spurious * error conditions during reset. Clear accumulated error * information and re-thaw the port if frozen. As reset is the * final recovery action and we cross check link onlineness against * device classification later, no hotplug event is lost by this. |
1e641060c libata: clear eh_... |
2927 |
*/ |
f046519fc libata: kill hotp... |
2928 |
spin_lock_irqsave(link->ap->lock, flags); |
1e641060c libata: clear eh_... |
2929 |
memset(&link->eh_info, 0, sizeof(link->eh_info)); |
b1c72916a libata: implement... |
2930 |
if (slave) |
1e641060c libata: clear eh_... |
2931 2932 |
memset(&slave->eh_info, 0, sizeof(link->eh_info)); ap->pflags &= ~ATA_PFLAG_EH_PENDING; |
f046519fc libata: kill hotp... |
2933 |
spin_unlock_irqrestore(link->ap->lock, flags); |
8c56cacc7 libata: fix unexp... |
2934 2935 |
if (ap->pflags & ATA_PFLAG_FROZEN) ata_eh_thaw_port(ap); |
3b761d3d4 libata: fix incor... |
2936 2937 |
/* * Make sure onlineness and classification result correspond. |
f046519fc libata: kill hotp... |
2938 2939 2940 |
* 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... |
2941 2942 |
* link on/offlineness and classification result, those * conditions can be reliably detected and retried. |
f046519fc libata: kill hotp... |
2943 |
*/ |
b1c72916a libata: implement... |
2944 |
nr_unknown = 0; |
1eca4365b libata: beef up i... |
2945 |
ata_for_each_dev(dev, link, ALL) { |
3b761d3d4 libata: fix incor... |
2946 2947 |
if (ata_phys_link_online(ata_dev_phys_link(dev))) { if (classes[dev->devno] == ATA_DEV_UNKNOWN) { |
a9a79dfec ata: Convert ata_... |
2948 2949 |
ata_dev_dbg(dev, "link online but device misclassified "); |
3b761d3d4 libata: fix incor... |
2950 |
classes[dev->devno] = ATA_DEV_NONE; |
b1c72916a libata: implement... |
2951 |
nr_unknown++; |
3b761d3d4 libata: fix incor... |
2952 2953 2954 |
} } else if (ata_phys_link_offline(ata_dev_phys_link(dev))) { if (ata_class_enabled(classes[dev->devno])) |
a9a79dfec ata: Convert ata_... |
2955 2956 2957 2958 |
ata_dev_dbg(dev, "link offline, clearing class %d to NONE ", classes[dev->devno]); |
3b761d3d4 libata: fix incor... |
2959 2960 |
classes[dev->devno] = ATA_DEV_NONE; } else if (classes[dev->devno] == ATA_DEV_UNKNOWN) { |
a9a79dfec ata: Convert ata_... |
2961 2962 2963 |
ata_dev_dbg(dev, "link status unknown, clearing UNKNOWN to NONE "); |
3b761d3d4 libata: fix incor... |
2964 |
classes[dev->devno] = ATA_DEV_NONE; |
b1c72916a libata: implement... |
2965 |
} |
f046519fc libata: kill hotp... |
2966 |
} |
b1c72916a libata: implement... |
2967 |
if (classify && nr_unknown) { |
f046519fc libata: kill hotp... |
2968 |
if (try < max_tries) { |
a9a79dfec ata: Convert ata_... |
2969 2970 2971 2972 |
ata_link_warn(link, "link online but %d devices misclassified, retrying ", nr_unknown); |
b1c72916a libata: implement... |
2973 |
failed_link = link; |
f046519fc libata: kill hotp... |
2974 2975 2976 |
rc = -EAGAIN; goto fail; } |
a9a79dfec ata: Convert ata_... |
2977 2978 2979 2980 |
ata_link_warn(link, "link online but %d devices misclassified, " "device detection might fail ", nr_unknown); |
f046519fc libata: kill hotp... |
2981 |
} |
416dc9ed2 libata: cosmetic ... |
2982 |
/* reset successful, schedule revalidation */ |
cf4806265 libata: prefer ha... |
2983 |
ata_eh_done(link, NULL, ATA_EH_RESET); |
b1c72916a libata: implement... |
2984 2985 |
if (slave) ata_eh_done(slave, NULL, ATA_EH_RESET); |
6b7ae9545 libata: reimpleme... |
2986 |
ehc->last_reset = jiffies; /* update to completion time */ |
416dc9ed2 libata: cosmetic ... |
2987 |
ehc->i.action |= ATA_EH_REVALIDATE; |
6b7ae9545 libata: reimpleme... |
2988 |
link->lpm_policy = ATA_LPM_UNKNOWN; /* reset LPM state */ |
ae791c056 libata-pmp-prep: ... |
2989 |
|
416dc9ed2 libata: cosmetic ... |
2990 |
rc = 0; |
fccb6ea5c libata: clear HOT... |
2991 2992 2993 |
out: /* clear hotplug flag */ ehc->i.flags &= ~ATA_EHI_HOTPLUGGED; |
b1c72916a libata: implement... |
2994 2995 |
if (slave) sehc->i.flags &= ~ATA_EHI_HOTPLUGGED; |
afaa5c373 libata: implement... |
2996 2997 2998 2999 |
spin_lock_irqsave(ap->lock, flags); ap->pflags &= ~ATA_PFLAG_RESETTING; spin_unlock_irqrestore(ap->lock, flags); |
022bdb075 [PATCH] libata-eh... |
3000 |
return rc; |
416dc9ed2 libata: cosmetic ... |
3001 3002 |
fail: |
5958e3025 libata: move PMP ... |
3003 3004 3005 3006 |
/* 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; |
7a46c0780 [libata] Issue SR... |
3007 |
if (try >= max_tries) { |
8ea7645c5 libata: leave por... |
3008 3009 3010 3011 3012 3013 3014 3015 |
/* * Thaw host port even if reset failed, so that the port * can be retried on the next phy event. This risks * repeated EH runs but seems to be a better tradeoff than * shutting down a port after a botched hotplug attempt. */ if (ata_is_host_link(link)) ata_eh_thaw_port(ap); |
416dc9ed2 libata: cosmetic ... |
3016 |
goto out; |
8ea7645c5 libata: leave por... |
3017 |
} |
416dc9ed2 libata: cosmetic ... |
3018 3019 3020 3021 |
now = jiffies; if (time_before(now, deadline)) { unsigned long delta = deadline - now; |
a9a79dfec ata: Convert ata_... |
3022 |
ata_link_warn(failed_link, |
0a2c0f561 libata: improve E... |
3023 3024 3025 |
"reset failed (errno=%d), retrying in %u secs ", rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000)); |
416dc9ed2 libata: cosmetic ... |
3026 |
|
c0c362b60 libata: implement... |
3027 |
ata_eh_release(ap); |
416dc9ed2 libata: cosmetic ... |
3028 3029 |
while (delta) delta = schedule_timeout_uninterruptible(delta); |
c0c362b60 libata: implement... |
3030 |
ata_eh_acquire(ap); |
416dc9ed2 libata: cosmetic ... |
3031 |
} |
7a46c0780 [libata] Issue SR... |
3032 3033 3034 3035 3036 3037 3038 3039 3040 |
/* * While disks spinup behind PMP, some controllers fail sending SRST. * They need to be reset - as well as the PMP - before retrying. */ if (rc == -ERESTART) { if (ata_is_host_link(link)) ata_eh_thaw_port(ap); goto out; } |
b1c72916a libata: implement... |
3041 |
if (try == max_tries - 1) { |
a07d499b4 libata: add @spd_... |
3042 |
sata_down_spd_limit(link, 0); |
b1c72916a libata: implement... |
3043 |
if (slave) |
a07d499b4 libata: add @spd_... |
3044 |
sata_down_spd_limit(slave, 0); |
b1c72916a libata: implement... |
3045 |
} else if (rc == -EPIPE) |
a07d499b4 libata: add @spd_... |
3046 |
sata_down_spd_limit(failed_link, 0); |
b1c72916a libata: implement... |
3047 |
|
416dc9ed2 libata: cosmetic ... |
3048 3049 3050 |
if (hardreset) reset = hardreset; goto retry; |
022bdb075 [PATCH] libata-eh... |
3051 |
} |
45fabbb77 libata: Implement... |
3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 |
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 |
16735d022 tree-wide: use re... |
3071 |
* through reinit_completion() (see below) or complete_all() |
45fabbb77 libata: Implement... |
3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 |
* (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); |
16735d022 tree-wide: use re... |
3085 |
reinit_completion(&ap->park_req_pending); |
1eca4365b libata: beef up i... |
3086 3087 |
ata_for_each_link(link, ap, EDGE) { ata_for_each_dev(dev, link, ALL) { |
45fabbb77 libata: Implement... |
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 |
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; |
bd18bc04c ata: fixup ATA_PR... |
3118 |
tf.protocol = ATA_PROT_NODATA; |
45fabbb77 libata: Implement... |
3119 3120 |
err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0); if (park && (err_mask || tf.lbal != 0xc4)) { |
a9a79dfec ata: Convert ata_... |
3121 3122 |
ata_dev_err(dev, "head unload failed! "); |
45fabbb77 libata: Implement... |
3123 3124 3125 |
ehc->unloaded_mask &= ~(1 << dev->devno); } } |
0260731f0 libata-link: link... |
3126 |
static int ata_eh_revalidate_and_attach(struct ata_link *link, |
084fe639b [PATCH] libata-hp... |
3127 |
struct ata_device **r_failed_dev) |
022bdb075 [PATCH] libata-eh... |
3128 |
{ |
0260731f0 libata-link: link... |
3129 3130 |
struct ata_port *ap = link->ap; struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
3131 |
struct ata_device *dev; |
8c3c52a8f libata: IDENTIFY ... |
3132 |
unsigned int new_mask = 0; |
084fe639b [PATCH] libata-hp... |
3133 |
unsigned long flags; |
f58229f80 libata-link: impl... |
3134 |
int rc = 0; |
022bdb075 [PATCH] libata-eh... |
3135 3136 3137 |
DPRINTK("ENTER "); |
8c3c52a8f libata: IDENTIFY ... |
3138 3139 3140 3141 |
/* 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... |
3142 |
ata_for_each_dev(dev, link, ALL_REVERSE) { |
f58229f80 libata-link: impl... |
3143 3144 |
unsigned int action = ata_eh_dev_action(dev); unsigned int readid_flags = 0; |
022bdb075 [PATCH] libata-eh... |
3145 |
|
bff046476 [PATCH] libata: c... |
3146 3147 |
if (ehc->i.flags & ATA_EHI_DID_RESET) readid_flags |= ATA_READID_POSTRESET; |
9666f4009 libata: reimpleme... |
3148 |
if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) { |
633273a3e libata-pmp: hook ... |
3149 |
WARN_ON(dev->class == ATA_DEV_PMP); |
b1c72916a libata: implement... |
3150 |
if (ata_phys_link_offline(ata_dev_phys_link(dev))) { |
022bdb075 [PATCH] libata-eh... |
3151 |
rc = -EIO; |
8c3c52a8f libata: IDENTIFY ... |
3152 |
goto err; |
022bdb075 [PATCH] libata-eh... |
3153 |
} |
0260731f0 libata-link: link... |
3154 |
ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE); |
422c9daa8 libata-pmp-prep: ... |
3155 3156 |
rc = ata_dev_revalidate(dev, ehc->classes[dev->devno], readid_flags); |
022bdb075 [PATCH] libata-eh... |
3157 |
if (rc) |
8c3c52a8f libata: IDENTIFY ... |
3158 |
goto err; |
022bdb075 [PATCH] libata-eh... |
3159 |
|
0260731f0 libata-link: link... |
3160 |
ata_eh_done(link, dev, ATA_EH_REVALIDATE); |
47005f255 [PATCH] libata: i... |
3161 |
|
baa1e78a8 [PATCH] libata: i... |
3162 3163 3164 3165 |
/* Configuration may have changed, reconfigure * transfer mode. */ ehc->i.flags |= ATA_EHI_SETMODE; |
3057ac3c1 [PATCH] Snoop SET... |
3166 |
/* schedule the scsi_rescan_device() here */ |
ad72cf988 libata: take adva... |
3167 |
schedule_work(&(ap->scsi_rescan_task)); |
084fe639b [PATCH] libata-hp... |
3168 3169 3170 |
} else if (dev->class == ATA_DEV_UNKNOWN && ehc->tries[dev->devno] && ata_class_enabled(ehc->classes[dev->devno])) { |
842faa6c1 libata: fix attac... |
3171 3172 3173 3174 3175 3176 |
/* 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... |
3177 |
dev->class = ehc->classes[dev->devno]; |
633273a3e libata-pmp: hook ... |
3178 3179 3180 3181 3182 |
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... |
3183 3184 3185 3186 |
/* read_id might have changed class, store and reset */ ehc->classes[dev->devno] = dev->class; dev->class = ATA_DEV_UNKNOWN; |
8c3c52a8f libata: IDENTIFY ... |
3187 3188 |
switch (rc) { case 0: |
99cf610aa libata: clear dev... |
3189 3190 |
/* clear error info accumulated during probe */ ata_ering_clear(&dev->ering); |
f58229f80 libata-link: impl... |
3191 |
new_mask |= 1 << dev->devno; |
8c3c52a8f libata: IDENTIFY ... |
3192 3193 |
break; case -ENOENT: |
55a8e2c83 [PATCH] libata: i... |
3194 3195 |
/* IDENTIFY was issued to non-existent * device. No need to reset. Just |
842faa6c1 libata: fix attac... |
3196 |
* thaw and ignore the device. |
55a8e2c83 [PATCH] libata: i... |
3197 3198 |
*/ ata_eh_thaw_port(ap); |
084fe639b [PATCH] libata-hp... |
3199 |
break; |
8c3c52a8f libata: IDENTIFY ... |
3200 |
default: |
8c3c52a8f libata: IDENTIFY ... |
3201 |
goto err; |
084fe639b [PATCH] libata-hp... |
3202 |
} |
8c3c52a8f libata: IDENTIFY ... |
3203 3204 |
} } |
084fe639b [PATCH] libata-hp... |
3205 |
|
c1c4e8d55 libata: add missi... |
3206 |
/* PDIAG- should have been released, ask cable type if post-reset */ |
332673257 libata: implement... |
3207 3208 3209 3210 3211 |
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... |
3212 |
|
8c3c52a8f libata: IDENTIFY ... |
3213 3214 3215 |
/* Configure new devices forward such that user doesn't see * device detection messages backwards. */ |
1eca4365b libata: beef up i... |
3216 |
ata_for_each_dev(dev, link, ALL) { |
4f7c28749 libata: fix PMP i... |
3217 |
if (!(new_mask & (1 << dev->devno))) |
8c3c52a8f libata: IDENTIFY ... |
3218 |
continue; |
842faa6c1 libata: fix attac... |
3219 |
dev->class = ehc->classes[dev->devno]; |
4f7c28749 libata: fix PMP i... |
3220 3221 |
if (dev->class == ATA_DEV_PMP) continue; |
8c3c52a8f libata: IDENTIFY ... |
3222 3223 3224 |
ehc->i.flags |= ATA_EHI_PRINTINFO; rc = ata_dev_configure(dev); ehc->i.flags &= ~ATA_EHI_PRINTINFO; |
842faa6c1 libata: fix attac... |
3225 3226 |
if (rc) { dev->class = ATA_DEV_UNKNOWN; |
8c3c52a8f libata: IDENTIFY ... |
3227 |
goto err; |
842faa6c1 libata: fix attac... |
3228 |
} |
8c3c52a8f libata: IDENTIFY ... |
3229 3230 3231 3232 3233 3234 3235 |
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... |
3236 |
} |
8c3c52a8f libata: IDENTIFY ... |
3237 |
return 0; |
022bdb075 [PATCH] libata-eh... |
3238 |
|
8c3c52a8f libata: IDENTIFY ... |
3239 3240 3241 3242 |
err: *r_failed_dev = dev; DPRINTK("EXIT rc=%d ", rc); |
022bdb075 [PATCH] libata-eh... |
3243 3244 |
return rc; } |
6f1d1e3a0 libata: move ata_... |
3245 3246 3247 |
/** * ata_set_mode - Program timings and issue SET FEATURES - XFER * @link: link on which timings will be programmed |
98a1708de trivial: fix typo... |
3248 |
* @r_failed_dev: out parameter for failed device |
6f1d1e3a0 libata: move ata_... |
3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 |
* * 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... |
3263 3264 |
struct ata_device *dev; int rc; |
6f1d1e3a0 libata: move ata_... |
3265 |
|
76326ac1a libata: implement... |
3266 |
/* if data transfer is verified, clear DUBIOUS_XFER on ering top */ |
1eca4365b libata: beef up i... |
3267 |
ata_for_each_dev(dev, link, ENABLED) { |
76326ac1a libata: implement... |
3268 3269 3270 3271 3272 3273 3274 3275 |
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_... |
3276 3277 |
/* has private set_mode? */ if (ap->ops->set_mode) |
00115e0f5 libata: implement... |
3278 3279 3280 3281 3282 |
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... |
3283 |
ata_for_each_dev(dev, link, ENABLED) { |
00115e0f5 libata: implement... |
3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 |
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_... |
3294 |
} |
11fc33da8 libata-eh: clear ... |
3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 |
/** * 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... |
3314 |
u8 *sense_buffer = dev->link->ap->sector_buf; |
11fc33da8 libata-eh: clear ... |
3315 3316 3317 3318 3319 |
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) { |
a9a79dfec ata: Convert ata_... |
3320 3321 3322 3323 |
ata_dev_warn(dev, "TEST_UNIT_READY failed (err_mask=0x%x) ", err_mask); |
11fc33da8 libata-eh: clear ... |
3324 3325 3326 3327 3328 3329 3330 3331 |
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) { |
a9a79dfec ata: Convert ata_... |
3332 |
ata_dev_warn(dev, "failed to clear " |
11fc33da8 libata-eh: clear ... |
3333 3334 3335 3336 3337 |
"UNIT ATTENTION (err_mask=0x%x) ", err_mask); return -EIO; } } |
a9a79dfec ata: Convert ata_... |
3338 3339 3340 |
ata_dev_warn(dev, "UNIT ATTENTION persists after %d tries ", ATA_EH_UA_TRIES); |
11fc33da8 libata-eh: clear ... |
3341 3342 3343 |
return 0; } |
6013efd88 libata: retry fai... |
3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 |
/** * 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; |
a9a79dfec ata: Convert ata_... |
3389 3390 |
ata_dev_warn(dev, "retrying FLUSH 0x%x Emask 0x%x ", |
6013efd88 libata: retry fai... |
3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 |
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 { |
a9a79dfec ata: Convert ata_... |
3405 3406 |
ata_dev_warn(dev, "FLUSH failed Emask 0x%x ", |
6013efd88 libata: retry fai... |
3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 |
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; } |
6b7ae9545 libata: reimpleme... |
3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 |
/** * ata_eh_set_lpm - configure SATA interface power management * @link: link to configure power management * @policy: the link power management policy * @r_failed_dev: out parameter for failed device * * Enable SATA Interface power management. This will enable * Device Interface Power Management (DIPM) for min_power * policy, and then call driver specific callbacks for * enabling Host Initiated Power management. * * LOCKING: * EH context. * * RETURNS: * 0 on success, -errno on failure. */ static int ata_eh_set_lpm(struct ata_link *link, enum ata_lpm_policy policy, struct ata_device **r_failed_dev) { |
6c8ea89ce libata: implement... |
3440 |
struct ata_port *ap = ata_is_host_link(link) ? link->ap : NULL; |
6b7ae9545 libata: reimpleme... |
3441 3442 |
struct ata_eh_context *ehc = &link->eh_context; struct ata_device *dev, *link_dev = NULL, *lpm_dev = NULL; |
e5005b15c libata: issue DIP... |
3443 |
enum ata_lpm_policy old_policy = link->lpm_policy; |
5f6f12ccf libata: fix oops ... |
3444 |
bool no_dipm = link->ap->flags & ATA_FLAG_NO_DIPM; |
6b7ae9545 libata: reimpleme... |
3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 |
unsigned int hints = ATA_LPM_EMPTY | ATA_LPM_HIPM; unsigned int err_mask; int rc; /* if the link or host doesn't do LPM, noop */ if ((link->flags & ATA_LFLAG_NO_LPM) || (ap && !ap->ops->set_lpm)) return 0; /* * DIPM is enabled only for MIN_POWER as some devices * misbehave when the host NACKs transition to SLUMBER. Order * device and link configurations such that the host always * allows DIPM requests. */ ata_for_each_dev(dev, link, ENABLED) { bool hipm = ata_id_has_hipm(dev->id); |
ae01b2493 libata: Implement... |
3461 |
bool dipm = ata_id_has_dipm(dev->id) && !no_dipm; |
6b7ae9545 libata: reimpleme... |
3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 |
/* find the first enabled and LPM enabled devices */ if (!link_dev) link_dev = dev; if (!lpm_dev && (hipm || dipm)) lpm_dev = dev; hints &= ~ATA_LPM_EMPTY; if (!hipm) hints &= ~ATA_LPM_HIPM; /* disable DIPM before changing link config */ if (policy != ATA_LPM_MIN_POWER && dipm) { err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_DISABLE, SATA_DIPM); if (err_mask && err_mask != AC_ERR_DEV) { |
a9a79dfec ata: Convert ata_... |
3479 3480 3481 3482 |
ata_dev_warn(dev, "failed to disable DIPM, Emask 0x%x ", err_mask); |
6b7ae9545 libata: reimpleme... |
3483 3484 3485 3486 3487 |
rc = -EIO; goto fail; } } } |
6c8ea89ce libata: implement... |
3488 3489 3490 3491 3492 3493 |
if (ap) { rc = ap->ops->set_lpm(link, policy, hints); if (!rc && ap->slave_link) rc = ap->ops->set_lpm(ap->slave_link, policy, hints); } else rc = sata_pmp_set_lpm(link, policy, hints); |
6b7ae9545 libata: reimpleme... |
3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 |
/* * Attribute link config failure to the first (LPM) enabled * device on the link. */ if (rc) { if (rc == -EOPNOTSUPP) { link->flags |= ATA_LFLAG_NO_LPM; return 0; } dev = lpm_dev ? lpm_dev : link_dev; goto fail; } |
e5005b15c libata: issue DIP... |
3507 3508 3509 3510 3511 3512 3513 |
/* * Low level driver acked the transition. Issue DIPM command * with the new policy set. */ link->lpm_policy = policy; if (ap && ap->slave_link) ap->slave_link->lpm_policy = policy; |
6b7ae9545 libata: reimpleme... |
3514 3515 |
/* host config updated, enable DIPM if transitioning to MIN_POWER */ ata_for_each_dev(dev, link, ENABLED) { |
ae01b2493 libata: Implement... |
3516 3517 |
if (policy == ATA_LPM_MIN_POWER && !no_dipm && ata_id_has_dipm(dev->id)) { |
6b7ae9545 libata: reimpleme... |
3518 3519 3520 |
err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE, SATA_DIPM); if (err_mask && err_mask != AC_ERR_DEV) { |
a9a79dfec ata: Convert ata_... |
3521 |
ata_dev_warn(dev, |
6b7ae9545 libata: reimpleme... |
3522 3523 3524 3525 3526 3527 3528 3529 |
"failed to enable DIPM, Emask 0x%x ", err_mask); rc = -EIO; goto fail; } } } |
09c5b4803 libata: Ignore sp... |
3530 3531 |
link->last_lpm_change = jiffies; link->flags |= ATA_LFLAG_CHANGED; |
6b7ae9545 libata: reimpleme... |
3532 3533 3534 |
return 0; fail: |
e5005b15c libata: issue DIP... |
3535 3536 3537 3538 |
/* restore the old policy */ link->lpm_policy = old_policy; if (ap && ap->slave_link) ap->slave_link->lpm_policy = old_policy; |
6b7ae9545 libata: reimpleme... |
3539 3540 |
/* if no device or only one more chance is left, disable LPM */ if (!dev || ehc->tries[dev->devno] <= 2) { |
a9a79dfec ata: Convert ata_... |
3541 3542 |
ata_link_warn(link, "disabling LPM on the link "); |
6b7ae9545 libata: reimpleme... |
3543 3544 3545 3546 3547 3548 |
link->flags |= ATA_LFLAG_NO_LPM; } if (r_failed_dev) *r_failed_dev = dev; return rc; } |
8a745f1f3 libata: Power off... |
3549 |
int ata_link_nr_enabled(struct ata_link *link) |
022bdb075 [PATCH] libata-eh... |
3550 |
{ |
f58229f80 libata-link: impl... |
3551 3552 |
struct ata_device *dev; int cnt = 0; |
022bdb075 [PATCH] libata-eh... |
3553 |
|
1eca4365b libata: beef up i... |
3554 3555 |
ata_for_each_dev(dev, link, ENABLED) cnt++; |
022bdb075 [PATCH] libata-eh... |
3556 3557 |
return cnt; } |
0260731f0 libata-link: link... |
3558 |
static int ata_link_nr_vacant(struct ata_link *link) |
084fe639b [PATCH] libata-hp... |
3559 |
{ |
f58229f80 libata-link: impl... |
3560 3561 |
struct ata_device *dev; int cnt = 0; |
084fe639b [PATCH] libata-hp... |
3562 |
|
1eca4365b libata: beef up i... |
3563 |
ata_for_each_dev(dev, link, ALL) |
f58229f80 libata-link: impl... |
3564 |
if (dev->class == ATA_DEV_UNKNOWN) |
084fe639b [PATCH] libata-hp... |
3565 3566 3567 |
cnt++; return cnt; } |
0260731f0 libata-link: link... |
3568 |
static int ata_eh_skip_recovery(struct ata_link *link) |
084fe639b [PATCH] libata-hp... |
3569 |
{ |
672b2d65b libata: kill ATA_... |
3570 |
struct ata_port *ap = link->ap; |
0260731f0 libata-link: link... |
3571 |
struct ata_eh_context *ehc = &link->eh_context; |
f58229f80 libata-link: impl... |
3572 |
struct ata_device *dev; |
084fe639b [PATCH] libata-hp... |
3573 |
|
f9df58cb2 libata-pmp-prep: ... |
3574 3575 3576 |
/* skip disabled links */ if (link->flags & ATA_LFLAG_DISABLED) return 1; |
e2f3d75fc libata: skip EH a... |
3577 3578 3579 |
/* skip if explicitly requested */ if (ehc->i.flags & ATA_EHI_NO_RECOVERY) return 1; |
672b2d65b libata: kill ATA_... |
3580 3581 3582 3583 3584 3585 3586 |
/* 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... |
3587 3588 3589 |
return 0; /* skip if class codes for all vacant slots are ATA_DEV_NONE */ |
1eca4365b libata: beef up i... |
3590 |
ata_for_each_dev(dev, link, ALL) { |
084fe639b [PATCH] libata-hp... |
3591 3592 3593 3594 3595 3596 3597 |
if (dev->class == ATA_DEV_UNKNOWN && ehc->classes[dev->devno] != ATA_DEV_NONE) return 0; } return 1; } |
c2c7a89c5 libata: improve p... |
3598 3599 3600 3601 3602 |
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; |
6868225e3 libata: skip old ... |
3603 3604 |
if ((ent->eflags & ATA_EFLAG_OLD_ER) || (ent->timestamp < now - min(now, interval))) |
c2c7a89c5 libata: improve p... |
3605 3606 3607 3608 3609 |
return -1; (*trials)++; return 0; } |
02c05a27e libata: factor ou... |
3610 3611 3612 |
static int ata_eh_schedule_probe(struct ata_device *dev) { struct ata_eh_context *ehc = &dev->link->eh_context; |
c2c7a89c5 libata: improve p... |
3613 3614 |
struct ata_link *link = ata_dev_phys_link(dev); int trials = 0; |
02c05a27e libata: factor ou... |
3615 3616 3617 3618 3619 3620 3621 3622 |
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... |
3623 |
ehc->i.action |= ATA_EH_RESET; |
00115e0f5 libata: implement... |
3624 3625 |
ehc->saved_xfer_mode[dev->devno] = 0; ehc->saved_ncq_enabled &= ~(1 << dev->devno); |
02c05a27e libata: factor ou... |
3626 |
|
6b7ae9545 libata: reimpleme... |
3627 |
/* the link maybe in a deep sleep, wake it up */ |
6c8ea89ce libata: implement... |
3628 3629 3630 3631 3632 3633 3634 3635 |
if (link->lpm_policy > ATA_LPM_MAX_POWER) { if (ata_is_host_link(link)) link->ap->ops->set_lpm(link, ATA_LPM_MAX_POWER, ATA_LPM_EMPTY); else sata_pmp_set_lpm(link, ATA_LPM_MAX_POWER, ATA_LPM_EMPTY); } |
6b7ae9545 libata: reimpleme... |
3636 |
|
c2c7a89c5 libata: improve p... |
3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 |
/* 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... |
3655 3656 |
return 1; } |
9b1e2658f libata-link: upda... |
3657 |
static int ata_eh_handle_dev_fail(struct ata_device *dev, int err) |
fee7ca72d libata-link: sepa... |
3658 |
{ |
9af5c9c97 libata-link: intr... |
3659 |
struct ata_eh_context *ehc = &dev->link->eh_context; |
fee7ca72d libata-link: sepa... |
3660 |
|
cf9a590a9 libata: add no pe... |
3661 3662 3663 3664 3665 |
/* -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... |
3666 3667 3668 3669 3670 3671 3672 3673 3674 |
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... |
3675 |
if (ehc->tries[dev->devno] == 1) { |
fee7ca72d libata-link: sepa... |
3676 3677 3678 |
/* This is the last chance, better to slow * down than lose it. */ |
a07d499b4 libata: add @spd_... |
3679 |
sata_down_spd_limit(ata_dev_phys_link(dev), 0); |
d89293abd libata: fix EH de... |
3680 3681 |
if (dev->pio_mode > XFER_PIO_0) ata_down_xfermask_limit(dev, ATA_DNXFER_PIO); |
fee7ca72d libata-link: sepa... |
3682 3683 3684 3685 3686 3687 3688 3689 |
} } 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... |
3690 |
if (ata_phys_link_offline(ata_dev_phys_link(dev))) |
fee7ca72d libata-link: sepa... |
3691 |
ata_eh_detach_dev(dev); |
02c05a27e libata: factor ou... |
3692 |
/* schedule probe if necessary */ |
87fbc5a06 libata: improve E... |
3693 |
if (ata_eh_schedule_probe(dev)) { |
fee7ca72d libata-link: sepa... |
3694 |
ehc->tries[dev->devno] = ATA_EH_DEV_TRIES; |
87fbc5a06 libata: improve E... |
3695 3696 3697 |
memset(ehc->cmd_timeout_idx[dev->devno], 0, sizeof(ehc->cmd_timeout_idx[dev->devno])); } |
9b1e2658f libata-link: upda... |
3698 3699 |
return 1; |
fee7ca72d libata-link: sepa... |
3700 |
} else { |
cf4806265 libata: prefer ha... |
3701 |
ehc->i.action |= ATA_EH_RESET; |
9b1e2658f libata-link: upda... |
3702 |
return 0; |
fee7ca72d libata-link: sepa... |
3703 3704 |
} } |
022bdb075 [PATCH] libata-eh... |
3705 3706 3707 |
/** * ata_eh_recover - recover host port after error * @ap: host port to recover |
f5914a461 [PATCH] libata-hp... |
3708 |
* @prereset: prereset method (can be NULL) |
022bdb075 [PATCH] libata-eh... |
3709 3710 3711 |
* @softreset: softreset method (can be NULL) * @hardreset: hardreset method (can be NULL) * @postreset: postreset method (can be NULL) |
9b1e2658f libata-link: upda... |
3712 |
* @r_failed_link: out parameter for failed link |
022bdb075 [PATCH] libata-eh... |
3713 3714 3715 |
* * 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... |
3716 3717 3718 |
* 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... |
3719 |
* devices, detach goners and greet newcomers. |
022bdb075 [PATCH] libata-eh... |
3720 3721 3722 3723 3724 3725 3726 |
* * LOCKING: * Kernel thread context (may sleep). * * RETURNS: * 0 on success, -errno on failure. */ |
fb7fd6145 libata-pmp-prep: ... |
3727 3728 3729 3730 |
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... |
3731 |
{ |
9b1e2658f libata-link: upda... |
3732 |
struct ata_link *link; |
022bdb075 [PATCH] libata-eh... |
3733 |
struct ata_device *dev; |
6b7ae9545 libata: reimpleme... |
3734 |
int rc, nr_fails; |
45fabbb77 libata: Implement... |
3735 |
unsigned long flags, deadline; |
022bdb075 [PATCH] libata-eh... |
3736 3737 3738 3739 3740 |
DPRINTK("ENTER "); /* prep for recovery */ |
1eca4365b libata: beef up i... |
3741 |
ata_for_each_link(link, ap, EDGE) { |
9b1e2658f libata-link: upda... |
3742 |
struct ata_eh_context *ehc = &link->eh_context; |
084fe639b [PATCH] libata-hp... |
3743 |
|
f9df58cb2 libata-pmp-prep: ... |
3744 3745 3746 3747 3748 3749 3750 3751 |
/* 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... |
3752 |
ata_for_each_dev(dev, link, ALL) { |
fd995f703 libata-pmp-prep: ... |
3753 3754 3755 3756 |
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... |
3757 |
|
9b1e2658f libata-link: upda... |
3758 3759 3760 3761 3762 3763 3764 3765 |
/* 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... |
3766 3767 3768 |
/* schedule probe if necessary */ if (!ata_dev_enabled(dev)) ata_eh_schedule_probe(dev); |
084fe639b [PATCH] libata-hp... |
3769 |
} |
022bdb075 [PATCH] libata-eh... |
3770 3771 3772 |
} retry: |
022bdb075 [PATCH] libata-eh... |
3773 |
rc = 0; |
aeb2ecd60 [PATCH] libata: f... |
3774 |
/* if UNLOADING, finish immediately */ |
b51e9e5db [PATCH] libata: a... |
3775 |
if (ap->pflags & ATA_PFLAG_UNLOADING) |
aeb2ecd60 [PATCH] libata: f... |
3776 |
goto out; |
9b1e2658f libata-link: upda... |
3777 |
/* prep for EH */ |
1eca4365b libata: beef up i... |
3778 |
ata_for_each_link(link, ap, EDGE) { |
9b1e2658f libata-link: upda... |
3779 |
struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
3780 |
|
9b1e2658f libata-link: upda... |
3781 3782 3783 |
/* skip EH if possible. */ if (ata_eh_skip_recovery(link)) ehc->i.action = 0; |
1eca4365b libata: beef up i... |
3784 |
ata_for_each_dev(dev, link, ALL) |
9b1e2658f libata-link: upda... |
3785 3786 |
ehc->classes[dev->devno] = ATA_DEV_UNKNOWN; } |
084fe639b [PATCH] libata-hp... |
3787 |
|
022bdb075 [PATCH] libata-eh... |
3788 |
/* reset */ |
1eca4365b libata: beef up i... |
3789 |
ata_for_each_link(link, ap, EDGE) { |
dc98c32cb libata: move rese... |
3790 |
struct ata_eh_context *ehc = &link->eh_context; |
9b1e2658f libata-link: upda... |
3791 |
|
dc98c32cb libata: move rese... |
3792 3793 |
if (!(ehc->i.action & ATA_EH_RESET)) continue; |
9b1e2658f libata-link: upda... |
3794 |
|
dc98c32cb libata: move rese... |
3795 3796 3797 |
rc = ata_eh_reset(link, ata_link_nr_vacant(link), prereset, softreset, hardreset, postreset); if (rc) { |
a9a79dfec ata: Convert ata_... |
3798 3799 |
ata_link_err(link, "reset failed, giving up "); |
dc98c32cb libata: move rese... |
3800 |
goto out; |
022bdb075 [PATCH] libata-eh... |
3801 |
} |
022bdb075 [PATCH] libata-eh... |
3802 |
} |
45fabbb77 libata: Implement... |
3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 |
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... |
3813 3814 |
ata_for_each_link(link, ap, EDGE) { ata_for_each_dev(dev, link, ALL) { |
45fabbb77 libata: Implement... |
3815 3816 |
struct ata_eh_context *ehc = &link->eh_context; unsigned long tmp; |
9162c6579 libata: Implement... |
3817 3818 |
if (dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC) |
45fabbb77 libata: Implement... |
3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 |
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; |
c0c362b60 libata: implement... |
3838 |
ata_eh_release(ap); |
45fabbb77 libata: Implement... |
3839 3840 |
deadline = wait_for_completion_timeout(&ap->park_req_pending, deadline - now); |
c0c362b60 libata: implement... |
3841 |
ata_eh_acquire(ap); |
45fabbb77 libata: Implement... |
3842 |
} while (deadline); |
1eca4365b libata: beef up i... |
3843 3844 |
ata_for_each_link(link, ap, EDGE) { ata_for_each_dev(dev, link, ALL) { |
45fabbb77 libata: Implement... |
3845 3846 3847 3848 3849 3850 3851 3852 |
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... |
3853 |
/* the rest */ |
6b7ae9545 libata: reimpleme... |
3854 3855 |
nr_fails = 0; ata_for_each_link(link, ap, PMP_FIRST) { |
9b1e2658f libata-link: upda... |
3856 |
struct ata_eh_context *ehc = &link->eh_context; |
022bdb075 [PATCH] libata-eh... |
3857 |
|
6b7ae9545 libata: reimpleme... |
3858 3859 |
if (sata_pmp_attached(ap) && ata_is_host_link(link)) goto config_lpm; |
9b1e2658f libata-link: upda... |
3860 3861 |
/* revalidate existing devices and attach new ones */ rc = ata_eh_revalidate_and_attach(link, &dev); |
4ae72a1e4 libata: improve p... |
3862 |
if (rc) |
6b7ae9545 libata: reimpleme... |
3863 |
goto rest_fail; |
022bdb075 [PATCH] libata-eh... |
3864 |
|
633273a3e libata-pmp: hook ... |
3865 3866 3867 3868 3869 |
/* 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... |
3870 3871 3872 3873 |
/* configure transfer mode if necessary */ if (ehc->i.flags & ATA_EHI_SETMODE) { rc = ata_set_mode(link, &dev); if (rc) |
6b7ae9545 libata: reimpleme... |
3874 |
goto rest_fail; |
9b1e2658f libata-link: upda... |
3875 3876 |
ehc->i.flags &= ~ATA_EHI_SETMODE; } |
11fc33da8 libata-eh: clear ... |
3877 3878 3879 3880 |
/* 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... |
3881 |
ata_for_each_dev(dev, link, ALL) { |
11fc33da8 libata-eh: clear ... |
3882 3883 3884 3885 |
if (dev->class != ATA_DEV_ATAPI) continue; rc = atapi_eh_clear_ua(dev); if (rc) |
6b7ae9545 libata: reimpleme... |
3886 |
goto rest_fail; |
213342053 libata: handle po... |
3887 3888 |
if (zpodd_dev_enabled(dev)) zpodd_post_poweron(dev); |
11fc33da8 libata-eh: clear ... |
3889 3890 |
} } |
6013efd88 libata: retry fai... |
3891 3892 |
/* retry flush if necessary */ ata_for_each_dev(dev, link, ALL) { |
9162c6579 libata: Implement... |
3893 3894 |
if (dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC) |
6013efd88 libata: retry fai... |
3895 3896 3897 |
continue; rc = ata_eh_maybe_retry_flush(dev); if (rc) |
6b7ae9545 libata: reimpleme... |
3898 |
goto rest_fail; |
6013efd88 libata: retry fai... |
3899 |
} |
6b7ae9545 libata: reimpleme... |
3900 |
config_lpm: |
11fc33da8 libata-eh: clear ... |
3901 |
/* configure link power saving */ |
6b7ae9545 libata: reimpleme... |
3902 3903 3904 3905 3906 |
if (link->lpm_policy != ap->target_lpm_policy) { rc = ata_eh_set_lpm(link, ap->target_lpm_policy, &dev); if (rc) goto rest_fail; } |
ca77329fb [libata] Link pow... |
3907 |
|
9b1e2658f libata-link: upda... |
3908 3909 3910 |
/* this link is okay now */ ehc->i.flags = 0; continue; |
022bdb075 [PATCH] libata-eh... |
3911 |
|
6b7ae9545 libata: reimpleme... |
3912 3913 3914 3915 |
rest_fail: nr_fails++; if (dev) ata_eh_handle_dev_fail(dev, rc); |
022bdb075 [PATCH] libata-eh... |
3916 |
|
b06ce3e51 libata: use ata_e... |
3917 3918 3919 3920 |
if (ap->pflags & ATA_PFLAG_FROZEN) { /* PMP reset requires working host port. * Can't retry if it's frozen. */ |
071f44b1d libata: implement... |
3921 |
if (sata_pmp_attached(ap)) |
b06ce3e51 libata: use ata_e... |
3922 |
goto out; |
9b1e2658f libata-link: upda... |
3923 |
break; |
b06ce3e51 libata: use ata_e... |
3924 |
} |
022bdb075 [PATCH] libata-eh... |
3925 |
} |
6b7ae9545 libata: reimpleme... |
3926 |
if (nr_fails) |
9b1e2658f libata-link: upda... |
3927 |
goto retry; |
022bdb075 [PATCH] libata-eh... |
3928 |
|
9b1e2658f libata-link: upda... |
3929 3930 3931 |
out: if (rc && r_failed_link) *r_failed_link = link; |
022bdb075 [PATCH] libata-eh... |
3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 |
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: ... |
3947 |
void ata_eh_finish(struct ata_port *ap) |
022bdb075 [PATCH] libata-eh... |
3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 |
{ 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... |
3963 |
if (qc->flags & ATA_QCFLAG_RETRY) |
022bdb075 [PATCH] libata-eh... |
3964 |
ata_eh_qc_retry(qc); |
03faab782 libata: implement... |
3965 3966 |
else ata_eh_qc_complete(qc); |
022bdb075 [PATCH] libata-eh... |
3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 |
} 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: ... |
3977 3978 3979 3980 |
/* make sure nr_active_links is zero after EH */ WARN_ON(ap->nr_active_links); ap->nr_active_links = 0; |
022bdb075 [PATCH] libata-eh... |
3981 3982 3983 3984 3985 |
} /** * ata_do_eh - do standard error handling * @ap: host port to handle error for |
a1efdaba2 libata: make rese... |
3986 |
* |
f5914a461 [PATCH] libata-hp... |
3987 |
* @prereset: prereset method (can be NULL) |
022bdb075 [PATCH] libata-eh... |
3988 3989 3990 3991 3992 3993 3994 3995 3996 |
* @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... |
3997 3998 3999 |
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... |
4000 |
{ |
9b1e2658f libata-link: upda... |
4001 4002 4003 4004 4005 4006 4007 4008 4009 |
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... |
4010 |
ata_for_each_dev(dev, &ap->link, ALL) |
9b1e2658f libata-link: upda... |
4011 4012 |
ata_dev_disable(dev); } |
022bdb075 [PATCH] libata-eh... |
4013 4014 |
ata_eh_finish(ap); } |
500530f65 [PATCH] libata: r... |
4015 |
|
a1efdaba2 libata: make rese... |
4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 |
/** * 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... |
4029 |
/* ignore built-in hardreset if SCR access is not available */ |
fe06e5f9b libata-sff: separ... |
4030 |
if (hardreset == sata_std_hardreset && !sata_scr_valid(&ap->link)) |
a1efdaba2 libata: make rese... |
4031 4032 4033 4034 |
hardreset = NULL; ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset); } |
6ffa01d88 libata: add CONFI... |
4035 |
#ifdef CONFIG_PM |
500530f65 [PATCH] libata: r... |
4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 |
/** * 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; |
3dc67440d libata: check zer... |
4049 |
struct ata_device *dev; |
500530f65 [PATCH] libata: r... |
4050 4051 4052 4053 |
/* are we suspending? */ spin_lock_irqsave(ap->lock, flags); if (!(ap->pflags & ATA_PFLAG_PM_PENDING) || |
a7ff60dbe [libata] pm: diff... |
4054 |
ap->pm_mesg.event & PM_EVENT_RESUME) { |
500530f65 [PATCH] libata: r... |
4055 4056 4057 4058 4059 4060 |
spin_unlock_irqrestore(ap->lock, flags); return; } spin_unlock_irqrestore(ap->lock, flags); WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED); |
3dc67440d libata: check zer... |
4061 4062 4063 |
/* * If we have a ZPODD attached, check its zero * power ready status before the port is frozen. |
a7ff60dbe [libata] pm: diff... |
4064 |
* Only needed for runtime suspend. |
3dc67440d libata: check zer... |
4065 |
*/ |
a7ff60dbe [libata] pm: diff... |
4066 4067 4068 4069 4070 |
if (PMSG_IS_AUTO(ap->pm_mesg)) { ata_for_each_dev(dev, &ap->link, ENABLED) { if (zpodd_dev_enabled(dev)) zpodd_on_suspend(dev); } |
3dc67440d libata: check zer... |
4071 |
} |
64578a3de libata-acpi: impl... |
4072 4073 4074 4075 |
/* tell ACPI we're suspending */ rc = ata_acpi_on_suspend(ap); if (rc) goto out; |
500530f65 [PATCH] libata: r... |
4076 4077 4078 4079 4080 |
/* suspend */ ata_eh_freeze_port(ap); if (ap->ops->port_suspend) rc = ap->ops->port_suspend(ap, ap->pm_mesg); |
a7ff60dbe [libata] pm: diff... |
4081 |
ata_acpi_set_state(ap, ap->pm_mesg); |
64578a3de libata-acpi: impl... |
4082 |
out: |
bc6e7c4b0 libata, libsas: k... |
4083 |
/* update the flags */ |
500530f65 [PATCH] libata: r... |
4084 4085 4086 4087 4088 |
spin_lock_irqsave(ap->lock, flags); ap->pflags &= ~ATA_PFLAG_PM_PENDING; if (rc == 0) ap->pflags |= ATA_PFLAG_SUSPENDED; |
64578a3de libata-acpi: impl... |
4089 |
else if (ap->pflags & ATA_PFLAG_FROZEN) |
500530f65 [PATCH] libata: r... |
4090 |
ata_port_schedule_eh(ap); |
500530f65 [PATCH] libata: r... |
4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 |
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... |
4102 4103 4104 4105 4106 |
* LOCKING: * Kernel thread context (may sleep). */ static void ata_eh_handle_port_resume(struct ata_port *ap) { |
6f9c1ea2c libata: clear eri... |
4107 4108 |
struct ata_link *link; struct ata_device *dev; |
500530f65 [PATCH] libata: r... |
4109 |
unsigned long flags; |
9666f4009 libata: reimpleme... |
4110 |
int rc = 0; |
500530f65 [PATCH] libata: r... |
4111 4112 4113 4114 |
/* are we resuming? */ spin_lock_irqsave(ap->lock, flags); if (!(ap->pflags & ATA_PFLAG_PM_PENDING) || |
a7ff60dbe [libata] pm: diff... |
4115 |
!(ap->pm_mesg.event & PM_EVENT_RESUME)) { |
500530f65 [PATCH] libata: r... |
4116 4117 4118 4119 |
spin_unlock_irqrestore(ap->lock, flags); return; } spin_unlock_irqrestore(ap->lock, flags); |
9666f4009 libata: reimpleme... |
4120 |
WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED)); |
500530f65 [PATCH] libata: r... |
4121 |
|
6f9c1ea2c libata: clear eri... |
4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 |
/* * 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); |
a7ff60dbe [libata] pm: diff... |
4132 |
ata_acpi_set_state(ap, ap->pm_mesg); |
bd3adca52 libata-acpi: add ... |
4133 |
|
500530f65 [PATCH] libata: r... |
4134 4135 |
if (ap->ops->port_resume) rc = ap->ops->port_resume(ap); |
6746544c3 libata: reimpleme... |
4136 4137 |
/* tell ACPI that we're resuming */ ata_acpi_on_resume(ap); |
bc6e7c4b0 libata, libsas: k... |
4138 |
/* update the flags */ |
500530f65 [PATCH] libata: r... |
4139 4140 |
spin_lock_irqsave(ap->lock, flags); ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED); |
500530f65 [PATCH] libata: r... |
4141 4142 |
spin_unlock_irqrestore(ap->lock, flags); } |
6ffa01d88 libata: add CONFI... |
4143 |
#endif /* CONFIG_PM */ |