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