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