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