linux/drivers/ata/libata-core.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  libata-core.c - helper library for ATA
   4 *
   5 *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
   6 *  Copyright 2003-2004 Jeff Garzik
   7 *
   8 *  libata documentation is available via 'make {ps|pdf}docs',
   9 *  as Documentation/driver-api/libata.rst
  10 *
  11 *  Hardware documentation available from http://www.t13.org/ and
  12 *  http://www.sata-io.org/
  13 *
  14 *  Standards documents from:
  15 *      http://www.t13.org (ATA standards, PCI DMA IDE spec)
  16 *      http://www.t10.org (SCSI MMC - for ATAPI MMC)
  17 *      http://www.sata-io.org (SATA)
  18 *      http://www.compactflash.org (CF)
  19 *      http://www.qic.org (QIC157 - Tape and DSC)
  20 *      http://www.ce-ata.org (CE-ATA: not supported)
  21 *
  22 * libata is essentially a library of internal helper functions for
  23 * low-level ATA host controller drivers.  As such, the API/ABI is
  24 * likely to change as new drivers are added and updated.
  25 * Do not depend on ABI/API stability.
  26 */
  27
  28#include <linux/kernel.h>
  29#include <linux/module.h>
  30#include <linux/pci.h>
  31#include <linux/init.h>
  32#include <linux/list.h>
  33#include <linux/mm.h>
  34#include <linux/spinlock.h>
  35#include <linux/blkdev.h>
  36#include <linux/delay.h>
  37#include <linux/timer.h>
  38#include <linux/time.h>
  39#include <linux/interrupt.h>
  40#include <linux/completion.h>
  41#include <linux/suspend.h>
  42#include <linux/workqueue.h>
  43#include <linux/scatterlist.h>
  44#include <linux/io.h>
  45#include <linux/log2.h>
  46#include <linux/slab.h>
  47#include <linux/glob.h>
  48#include <scsi/scsi.h>
  49#include <scsi/scsi_cmnd.h>
  50#include <scsi/scsi_host.h>
  51#include <linux/libata.h>
  52#include <asm/byteorder.h>
  53#include <asm/unaligned.h>
  54#include <linux/cdrom.h>
  55#include <linux/ratelimit.h>
  56#include <linux/leds.h>
  57#include <linux/pm_runtime.h>
  58#include <linux/platform_device.h>
  59#include <asm/setup.h>
  60
  61#define CREATE_TRACE_POINTS
  62#include <trace/events/libata.h>
  63
  64#include "libata.h"
  65#include "libata-transport.h"
  66
  67const struct ata_port_operations ata_base_port_ops = {
  68        .prereset               = ata_std_prereset,
  69        .postreset              = ata_std_postreset,
  70        .error_handler          = ata_std_error_handler,
  71        .sched_eh               = ata_std_sched_eh,
  72        .end_eh                 = ata_std_end_eh,
  73};
  74
  75const struct ata_port_operations sata_port_ops = {
  76        .inherits               = &ata_base_port_ops,
  77
  78        .qc_defer               = ata_std_qc_defer,
  79        .hardreset              = sata_std_hardreset,
  80};
  81EXPORT_SYMBOL_GPL(sata_port_ops);
  82
  83static unsigned int ata_dev_init_params(struct ata_device *dev,
  84                                        u16 heads, u16 sectors);
  85static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
  86static void ata_dev_xfermask(struct ata_device *dev);
  87static unsigned long ata_dev_blacklisted(const struct ata_device *dev);
  88
  89atomic_t ata_print_id = ATOMIC_INIT(0);
  90
  91#ifdef CONFIG_ATA_FORCE
  92struct ata_force_param {
  93        const char      *name;
  94        u8              cbl;
  95        u8              spd_limit;
  96        unsigned long   xfer_mask;
  97        unsigned int    horkage_on;
  98        unsigned int    horkage_off;
  99        u16             lflags;
 100};
 101
 102struct ata_force_ent {
 103        int                     port;
 104        int                     device;
 105        struct ata_force_param  param;
 106};
 107
 108static struct ata_force_ent *ata_force_tbl;
 109static int ata_force_tbl_size;
 110
 111static char ata_force_param_buf[COMMAND_LINE_SIZE] __initdata;
 112/* param_buf is thrown away after initialization, disallow read */
 113module_param_string(force, ata_force_param_buf, sizeof(ata_force_param_buf), 0);
 114MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link speed and transfer mode (see Documentation/admin-guide/kernel-parameters.rst for details)");
 115#endif
 116
 117static int atapi_enabled = 1;
 118module_param(atapi_enabled, int, 0444);
 119MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on [default])");
 120
 121static int atapi_dmadir = 0;
 122module_param(atapi_dmadir, int, 0444);
 123MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off [default], 1=on)");
 124
 125int atapi_passthru16 = 1;
 126module_param(atapi_passthru16, int, 0444);
 127MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices (0=off, 1=on [default])");
 128
 129int libata_fua = 0;
 130module_param_named(fua, libata_fua, int, 0444);
 131MODULE_PARM_DESC(fua, "FUA support (0=off [default], 1=on)");
 132
 133static int ata_ignore_hpa;
 134module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
 135MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)");
 136
 137static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA;
 138module_param_named(dma, libata_dma_mask, int, 0444);
 139MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)");
 140
 141static int ata_probe_timeout;
 142module_param(ata_probe_timeout, int, 0444);
 143MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");
 144
 145int libata_noacpi = 0;
 146module_param_named(noacpi, libata_noacpi, int, 0444);
 147MODULE_PARM_DESC(noacpi, "Disable the use of ACPI in probe/suspend/resume (0=off [default], 1=on)");
 148
 149int libata_allow_tpm = 0;
 150module_param_named(allow_tpm, libata_allow_tpm, int, 0444);
 151MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands (0=off [default], 1=on)");
 152
 153static int atapi_an;
 154module_param(atapi_an, int, 0444);
 155MODULE_PARM_DESC(atapi_an, "Enable ATAPI AN media presence notification (0=0ff [default], 1=on)");
 156
 157MODULE_AUTHOR("Jeff Garzik");
 158MODULE_DESCRIPTION("Library module for ATA devices");
 159MODULE_LICENSE("GPL");
 160MODULE_VERSION(DRV_VERSION);
 161
 162
 163static bool ata_sstatus_online(u32 sstatus)
 164{
 165        return (sstatus & 0xf) == 0x3;
 166}
 167
 168/**
 169 *      ata_link_next - link iteration helper
 170 *      @link: the previous link, NULL to start
 171 *      @ap: ATA port containing links to iterate
 172 *      @mode: iteration mode, one of ATA_LITER_*
 173 *
 174 *      LOCKING:
 175 *      Host lock or EH context.
 176 *
 177 *      RETURNS:
 178 *      Pointer to the next link.
 179 */
 180struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap,
 181                               enum ata_link_iter_mode mode)
 182{
 183        BUG_ON(mode != ATA_LITER_EDGE &&
 184               mode != ATA_LITER_PMP_FIRST && mode != ATA_LITER_HOST_FIRST);
 185
 186        /* NULL link indicates start of iteration */
 187        if (!link)
 188                switch (mode) {
 189                case ATA_LITER_EDGE:
 190                case ATA_LITER_PMP_FIRST:
 191                        if (sata_pmp_attached(ap))
 192                                return ap->pmp_link;
 193                        fallthrough;
 194                case ATA_LITER_HOST_FIRST:
 195                        return &ap->link;
 196                }
 197
 198        /* we just iterated over the host link, what's next? */
 199        if (link == &ap->link)
 200                switch (mode) {
 201                case ATA_LITER_HOST_FIRST:
 202                        if (sata_pmp_attached(ap))
 203                                return ap->pmp_link;
 204                        fallthrough;
 205                case ATA_LITER_PMP_FIRST:
 206                        if (unlikely(ap->slave_link))
 207                                return ap->slave_link;
 208                        fallthrough;
 209                case ATA_LITER_EDGE:
 210                        return NULL;
 211                }
 212
 213        /* slave_link excludes PMP */
 214        if (unlikely(link == ap->slave_link))
 215                return NULL;
 216
 217        /* we were over a PMP link */
 218        if (++link < ap->pmp_link + ap->nr_pmp_links)
 219                return link;
 220
 221        if (mode == ATA_LITER_PMP_FIRST)
 222                return &ap->link;
 223
 224        return NULL;
 225}
 226EXPORT_SYMBOL_GPL(ata_link_next);
 227
 228/**
 229 *      ata_dev_next - device iteration helper
 230 *      @dev: the previous device, NULL to start
 231 *      @link: ATA link containing devices to iterate
 232 *      @mode: iteration mode, one of ATA_DITER_*
 233 *
 234 *      LOCKING:
 235 *      Host lock or EH context.
 236 *
 237 *      RETURNS:
 238 *      Pointer to the next device.
 239 */
 240struct ata_device *ata_dev_next(struct ata_device *dev, struct ata_link *link,
 241                                enum ata_dev_iter_mode mode)
 242{
 243        BUG_ON(mode != ATA_DITER_ENABLED && mode != ATA_DITER_ENABLED_REVERSE &&
 244               mode != ATA_DITER_ALL && mode != ATA_DITER_ALL_REVERSE);
 245
 246        /* NULL dev indicates start of iteration */
 247        if (!dev)
 248                switch (mode) {
 249                case ATA_DITER_ENABLED:
 250                case ATA_DITER_ALL:
 251                        dev = link->device;
 252                        goto check;
 253                case ATA_DITER_ENABLED_REVERSE:
 254                case ATA_DITER_ALL_REVERSE:
 255                        dev = link->device + ata_link_max_devices(link) - 1;
 256                        goto check;
 257                }
 258
 259 next:
 260        /* move to the next one */
 261        switch (mode) {
 262        case ATA_DITER_ENABLED:
 263        case ATA_DITER_ALL:
 264                if (++dev < link->device + ata_link_max_devices(link))
 265                        goto check;
 266                return NULL;
 267        case ATA_DITER_ENABLED_REVERSE:
 268        case ATA_DITER_ALL_REVERSE:
 269                if (--dev >= link->device)
 270                        goto check;
 271                return NULL;
 272        }
 273
 274 check:
 275        if ((mode == ATA_DITER_ENABLED || mode == ATA_DITER_ENABLED_REVERSE) &&
 276            !ata_dev_enabled(dev))
 277                goto next;
 278        return dev;
 279}
 280EXPORT_SYMBOL_GPL(ata_dev_next);
 281
 282/**
 283 *      ata_dev_phys_link - find physical link for a device
 284 *      @dev: ATA device to look up physical link for
 285 *
 286 *      Look up physical link which @dev is attached to.  Note that
 287 *      this is different from @dev->link only when @dev is on slave
 288 *      link.  For all other cases, it's the same as @dev->link.
 289 *
 290 *      LOCKING:
 291 *      Don't care.
 292 *
 293 *      RETURNS:
 294 *      Pointer to the found physical link.
 295 */
 296struct ata_link *ata_dev_phys_link(struct ata_device *dev)
 297{
 298        struct ata_port *ap = dev->link->ap;
 299
 300        if (!ap->slave_link)
 301                return dev->link;
 302        if (!dev->devno)
 303                return &ap->link;
 304        return ap->slave_link;
 305}
 306
 307#ifdef CONFIG_ATA_FORCE
 308/**
 309 *      ata_force_cbl - force cable type according to libata.force
 310 *      @ap: ATA port of interest
 311 *
 312 *      Force cable type according to libata.force and whine about it.
 313 *      The last entry which has matching port number is used, so it
 314 *      can be specified as part of device force parameters.  For
 315 *      example, both "a:40c,1.00:udma4" and "1.00:40c,udma4" have the
 316 *      same effect.
 317 *
 318 *      LOCKING:
 319 *      EH context.
 320 */
 321void ata_force_cbl(struct ata_port *ap)
 322{
 323        int i;
 324
 325        for (i = ata_force_tbl_size - 1; i >= 0; i--) {
 326                const struct ata_force_ent *fe = &ata_force_tbl[i];
 327
 328                if (fe->port != -1 && fe->port != ap->print_id)
 329                        continue;
 330
 331                if (fe->param.cbl == ATA_CBL_NONE)
 332                        continue;
 333
 334                ap->cbl = fe->param.cbl;
 335                ata_port_notice(ap, "FORCE: cable set to %s\n", fe->param.name);
 336                return;
 337        }
 338}
 339
 340/**
 341 *      ata_force_link_limits - force link limits according to libata.force
 342 *      @link: ATA link of interest
 343 *
 344 *      Force link flags and SATA spd limit according to libata.force
 345 *      and whine about it.  When only the port part is specified
 346 *      (e.g. 1:), the limit applies to all links connected to both
 347 *      the host link and all fan-out ports connected via PMP.  If the
 348 *      device part is specified as 0 (e.g. 1.00:), it specifies the
 349 *      first fan-out link not the host link.  Device number 15 always
 350 *      points to the host link whether PMP is attached or not.  If the
 351 *      controller has slave link, device number 16 points to it.
 352 *
 353 *      LOCKING:
 354 *      EH context.
 355 */
 356static void ata_force_link_limits(struct ata_link *link)
 357{
 358        bool did_spd = false;
 359        int linkno = link->pmp;
 360        int i;
 361
 362        if (ata_is_host_link(link))
 363                linkno += 15;
 364
 365        for (i = ata_force_tbl_size - 1; i >= 0; i--) {
 366                const struct ata_force_ent *fe = &ata_force_tbl[i];
 367
 368                if (fe->port != -1 && fe->port != link->ap->print_id)
 369                        continue;
 370
 371                if (fe->device != -1 && fe->device != linkno)
 372                        continue;
 373
 374                /* only honor the first spd limit */
 375                if (!did_spd && fe->param.spd_limit) {
 376                        link->hw_sata_spd_limit = (1 << fe->param.spd_limit) - 1;
 377                        ata_link_notice(link, "FORCE: PHY spd limit set to %s\n",
 378                                        fe->param.name);
 379                        did_spd = true;
 380                }
 381
 382                /* let lflags stack */
 383                if (fe->param.lflags) {
 384                        link->flags |= fe->param.lflags;
 385                        ata_link_notice(link,
 386                                        "FORCE: link flag 0x%x forced -> 0x%x\n",
 387                                        fe->param.lflags, link->flags);
 388                }
 389        }
 390}
 391
 392/**
 393 *      ata_force_xfermask - force xfermask according to libata.force
 394 *      @dev: ATA device of interest
 395 *
 396 *      Force xfer_mask according to libata.force and whine about it.
 397 *      For consistency with link selection, device number 15 selects
 398 *      the first device connected to the host link.
 399 *
 400 *      LOCKING:
 401 *      EH context.
 402 */
 403static void ata_force_xfermask(struct ata_device *dev)
 404{
 405        int devno = dev->link->pmp + dev->devno;
 406        int alt_devno = devno;
 407        int i;
 408
 409        /* allow n.15/16 for devices attached to host port */
 410        if (ata_is_host_link(dev->link))
 411                alt_devno += 15;
 412
 413        for (i = ata_force_tbl_size - 1; i >= 0; i--) {
 414                const struct ata_force_ent *fe = &ata_force_tbl[i];
 415                unsigned long pio_mask, mwdma_mask, udma_mask;
 416
 417                if (fe->port != -1 && fe->port != dev->link->ap->print_id)
 418                        continue;
 419
 420                if (fe->device != -1 && fe->device != devno &&
 421                    fe->device != alt_devno)
 422                        continue;
 423
 424                if (!fe->param.xfer_mask)
 425                        continue;
 426
 427                ata_unpack_xfermask(fe->param.xfer_mask,
 428                                    &pio_mask, &mwdma_mask, &udma_mask);
 429                if (udma_mask)
 430                        dev->udma_mask = udma_mask;
 431                else if (mwdma_mask) {
 432                        dev->udma_mask = 0;
 433                        dev->mwdma_mask = mwdma_mask;
 434                } else {
 435                        dev->udma_mask = 0;
 436                        dev->mwdma_mask = 0;
 437                        dev->pio_mask = pio_mask;
 438                }
 439
 440                ata_dev_notice(dev, "FORCE: xfer_mask set to %s\n",
 441                               fe->param.name);
 442                return;
 443        }
 444}
 445
 446/**
 447 *      ata_force_horkage - force horkage according to libata.force
 448 *      @dev: ATA device of interest
 449 *
 450 *      Force horkage according to libata.force and whine about it.
 451 *      For consistency with link selection, device number 15 selects
 452 *      the first device connected to the host link.
 453 *
 454 *      LOCKING:
 455 *      EH context.
 456 */
 457static void ata_force_horkage(struct ata_device *dev)
 458{
 459        int devno = dev->link->pmp + dev->devno;
 460        int alt_devno = devno;
 461        int i;
 462
 463        /* allow n.15/16 for devices attached to host port */
 464        if (ata_is_host_link(dev->link))
 465                alt_devno += 15;
 466
 467        for (i = 0; i < ata_force_tbl_size; i++) {
 468                const struct ata_force_ent *fe = &ata_force_tbl[i];
 469
 470                if (fe->port != -1 && fe->port != dev->link->ap->print_id)
 471                        continue;
 472
 473                if (fe->device != -1 && fe->device != devno &&
 474                    fe->device != alt_devno)
 475                        continue;
 476
 477                if (!(~dev->horkage & fe->param.horkage_on) &&
 478                    !(dev->horkage & fe->param.horkage_off))
 479                        continue;
 480
 481                dev->horkage |= fe->param.horkage_on;
 482                dev->horkage &= ~fe->param.horkage_off;
 483
 484                ata_dev_notice(dev, "FORCE: horkage modified (%s)\n",
 485                               fe->param.name);
 486        }
 487}
 488#else
 489static inline void ata_force_link_limits(struct ata_link *link) { }
 490static inline void ata_force_xfermask(struct ata_device *dev) { }
 491static inline void ata_force_horkage(struct ata_device *dev) { }
 492#endif
 493
 494/**
 495 *      atapi_cmd_type - Determine ATAPI command type from SCSI opcode
 496 *      @opcode: SCSI opcode
 497 *
 498 *      Determine ATAPI command type from @opcode.
 499 *
 500 *      LOCKING:
 501 *      None.
 502 *
 503 *      RETURNS:
 504 *      ATAPI_{READ|WRITE|READ_CD|PASS_THRU|MISC}
 505 */
 506int atapi_cmd_type(u8 opcode)
 507{
 508        switch (opcode) {
 509        case GPCMD_READ_10:
 510        case GPCMD_READ_12:
 511                return ATAPI_READ;
 512
 513        case GPCMD_WRITE_10:
 514        case GPCMD_WRITE_12:
 515        case GPCMD_WRITE_AND_VERIFY_10:
 516                return ATAPI_WRITE;
 517
 518        case GPCMD_READ_CD:
 519        case GPCMD_READ_CD_MSF:
 520                return ATAPI_READ_CD;
 521
 522        case ATA_16:
 523        case ATA_12:
 524                if (atapi_passthru16)
 525                        return ATAPI_PASS_THRU;
 526                fallthrough;
 527        default:
 528                return ATAPI_MISC;
 529        }
 530}
 531EXPORT_SYMBOL_GPL(atapi_cmd_type);
 532
 533static const u8 ata_rw_cmds[] = {
 534        /* pio multi */
 535        ATA_CMD_READ_MULTI,
 536        ATA_CMD_WRITE_MULTI,
 537        ATA_CMD_READ_MULTI_EXT,
 538        ATA_CMD_WRITE_MULTI_EXT,
 539        0,
 540        0,
 541        0,
 542        ATA_CMD_WRITE_MULTI_FUA_EXT,
 543        /* pio */
 544        ATA_CMD_PIO_READ,
 545        ATA_CMD_PIO_WRITE,
 546        ATA_CMD_PIO_READ_EXT,
 547        ATA_CMD_PIO_WRITE_EXT,
 548        0,
 549        0,
 550        0,
 551        0,
 552        /* dma */
 553        ATA_CMD_READ,
 554        ATA_CMD_WRITE,
 555        ATA_CMD_READ_EXT,
 556        ATA_CMD_WRITE_EXT,
 557        0,
 558        0,
 559        0,
 560        ATA_CMD_WRITE_FUA_EXT
 561};
 562
 563/**
 564 *      ata_rwcmd_protocol - set taskfile r/w commands and protocol
 565 *      @tf: command to examine and configure
 566 *      @dev: device tf belongs to
 567 *
 568 *      Examine the device configuration and tf->flags to calculate
 569 *      the proper read/write commands and protocol to use.
 570 *
 571 *      LOCKING:
 572 *      caller.
 573 */
 574static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev)
 575{
 576        u8 cmd;
 577
 578        int index, fua, lba48, write;
 579
 580        fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
 581        lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
 582        write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
 583
 584        if (dev->flags & ATA_DFLAG_PIO) {
 585                tf->protocol = ATA_PROT_PIO;
 586                index = dev->multi_count ? 0 : 8;
 587        } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
 588                /* Unable to use DMA due to host limitation */
 589                tf->protocol = ATA_PROT_PIO;
 590                index = dev->multi_count ? 0 : 8;
 591        } else {
 592                tf->protocol = ATA_PROT_DMA;
 593                index = 16;
 594        }
 595
 596        cmd = ata_rw_cmds[index + fua + lba48 + write];
 597        if (cmd) {
 598                tf->command = cmd;
 599                return 0;
 600        }
 601        return -1;
 602}
 603
 604/**
 605 *      ata_tf_read_block - Read block address from ATA taskfile
 606 *      @tf: ATA taskfile of interest
 607 *      @dev: ATA device @tf belongs to
 608 *
 609 *      LOCKING:
 610 *      None.
 611 *
 612 *      Read block address from @tf.  This function can handle all
 613 *      three address formats - LBA, LBA48 and CHS.  tf->protocol and
 614 *      flags select the address format to use.
 615 *
 616 *      RETURNS:
 617 *      Block address read from @tf.
 618 */
 619u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev)
 620{
 621        u64 block = 0;
 622
 623        if (tf->flags & ATA_TFLAG_LBA) {
 624                if (tf->flags & ATA_TFLAG_LBA48) {
 625                        block |= (u64)tf->hob_lbah << 40;
 626                        block |= (u64)tf->hob_lbam << 32;
 627                        block |= (u64)tf->hob_lbal << 24;
 628                } else
 629                        block |= (tf->device & 0xf) << 24;
 630
 631                block |= tf->lbah << 16;
 632                block |= tf->lbam << 8;
 633                block |= tf->lbal;
 634        } else {
 635                u32 cyl, head, sect;
 636
 637                cyl = tf->lbam | (tf->lbah << 8);
 638                head = tf->device & 0xf;
 639                sect = tf->lbal;
 640
 641                if (!sect) {
 642                        ata_dev_warn(dev,
 643                                     "device reported invalid CHS sector 0\n");
 644                        return U64_MAX;
 645                }
 646
 647                block = (cyl * dev->heads + head) * dev->sectors + sect - 1;
 648        }
 649
 650        return block;
 651}
 652
 653/**
 654 *      ata_build_rw_tf - Build ATA taskfile for given read/write request
 655 *      @tf: Target ATA taskfile
 656 *      @dev: ATA device @tf belongs to
 657 *      @block: Block address
 658 *      @n_block: Number of blocks
 659 *      @tf_flags: RW/FUA etc...
 660 *      @tag: tag
 661 *      @class: IO priority class
 662 *
 663 *      LOCKING:
 664 *      None.
 665 *
 666 *      Build ATA taskfile @tf for read/write request described by
 667 *      @block, @n_block, @tf_flags and @tag on @dev.
 668 *
 669 *      RETURNS:
 670 *
 671 *      0 on success, -ERANGE if the request is too large for @dev,
 672 *      -EINVAL if the request is invalid.
 673 */
 674int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev,
 675                    u64 block, u32 n_block, unsigned int tf_flags,
 676                    unsigned int tag, int class)
 677{
 678        tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
 679        tf->flags |= tf_flags;
 680
 681        if (ata_ncq_enabled(dev) && !ata_tag_internal(tag)) {
 682                /* yay, NCQ */
 683                if (!lba_48_ok(block, n_block))
 684                        return -ERANGE;
 685
 686                tf->protocol = ATA_PROT_NCQ;
 687                tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
 688
 689                if (tf->flags & ATA_TFLAG_WRITE)
 690                        tf->command = ATA_CMD_FPDMA_WRITE;
 691                else
 692                        tf->command = ATA_CMD_FPDMA_READ;
 693
 694                tf->nsect = tag << 3;
 695                tf->hob_feature = (n_block >> 8) & 0xff;
 696                tf->feature = n_block & 0xff;
 697
 698                tf->hob_lbah = (block >> 40) & 0xff;
 699                tf->hob_lbam = (block >> 32) & 0xff;
 700                tf->hob_lbal = (block >> 24) & 0xff;
 701                tf->lbah = (block >> 16) & 0xff;
 702                tf->lbam = (block >> 8) & 0xff;
 703                tf->lbal = block & 0xff;
 704
 705                tf->device = ATA_LBA;
 706                if (tf->flags & ATA_TFLAG_FUA)
 707                        tf->device |= 1 << 7;
 708
 709                if (dev->flags & ATA_DFLAG_NCQ_PRIO) {
 710                        if (class == IOPRIO_CLASS_RT)
 711                                tf->hob_nsect |= ATA_PRIO_HIGH <<
 712                                                 ATA_SHIFT_PRIO;
 713                }
 714        } else if (dev->flags & ATA_DFLAG_LBA) {
 715                tf->flags |= ATA_TFLAG_LBA;
 716
 717                if (lba_28_ok(block, n_block)) {
 718                        /* use LBA28 */
 719                        tf->device |= (block >> 24) & 0xf;
 720                } else if (lba_48_ok(block, n_block)) {
 721                        if (!(dev->flags & ATA_DFLAG_LBA48))
 722                                return -ERANGE;
 723
 724                        /* use LBA48 */
 725                        tf->flags |= ATA_TFLAG_LBA48;
 726
 727                        tf->hob_nsect = (n_block >> 8) & 0xff;
 728
 729                        tf->hob_lbah = (block >> 40) & 0xff;
 730                        tf->hob_lbam = (block >> 32) & 0xff;
 731                        tf->hob_lbal = (block >> 24) & 0xff;
 732                } else
 733                        /* request too large even for LBA48 */
 734                        return -ERANGE;
 735
 736                if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
 737                        return -EINVAL;
 738
 739                tf->nsect = n_block & 0xff;
 740
 741                tf->lbah = (block >> 16) & 0xff;
 742                tf->lbam = (block >> 8) & 0xff;
 743                tf->lbal = block & 0xff;
 744
 745                tf->device |= ATA_LBA;
 746        } else {
 747                /* CHS */
 748                u32 sect, head, cyl, track;
 749
 750                /* The request -may- be too large for CHS addressing. */
 751                if (!lba_28_ok(block, n_block))
 752                        return -ERANGE;
 753
 754                if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
 755                        return -EINVAL;
 756
 757                /* Convert LBA to CHS */
 758                track = (u32)block / dev->sectors;
 759                cyl   = track / dev->heads;
 760                head  = track % dev->heads;
 761                sect  = (u32)block % dev->sectors + 1;
 762
 763                DPRINTK("block %u track %u cyl %u head %u sect %u\n",
 764                        (u32)block, track, cyl, head, sect);
 765
 766                /* Check whether the converted CHS can fit.
 767                   Cylinder: 0-65535
 768                   Head: 0-15
 769                   Sector: 1-255*/
 770                if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
 771                        return -ERANGE;
 772
 773                tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
 774                tf->lbal = sect;
 775                tf->lbam = cyl;
 776                tf->lbah = cyl >> 8;
 777                tf->device |= head;
 778        }
 779
 780        return 0;
 781}
 782
 783/**
 784 *      ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
 785 *      @pio_mask: pio_mask
 786 *      @mwdma_mask: mwdma_mask
 787 *      @udma_mask: udma_mask
 788 *
 789 *      Pack @pio_mask, @mwdma_mask and @udma_mask into a single
 790 *      unsigned int xfer_mask.
 791 *
 792 *      LOCKING:
 793 *      None.
 794 *
 795 *      RETURNS:
 796 *      Packed xfer_mask.
 797 */
 798unsigned long ata_pack_xfermask(unsigned long pio_mask,
 799                                unsigned long mwdma_mask,
 800                                unsigned long udma_mask)
 801{
 802        return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
 803                ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
 804                ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
 805}
 806EXPORT_SYMBOL_GPL(ata_pack_xfermask);
 807
 808/**
 809 *      ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
 810 *      @xfer_mask: xfer_mask to unpack
 811 *      @pio_mask: resulting pio_mask
 812 *      @mwdma_mask: resulting mwdma_mask
 813 *      @udma_mask: resulting udma_mask
 814 *
 815 *      Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
 816 *      Any NULL destination masks will be ignored.
 817 */
 818void ata_unpack_xfermask(unsigned long xfer_mask, unsigned long *pio_mask,
 819                         unsigned long *mwdma_mask, unsigned long *udma_mask)
 820{
 821        if (pio_mask)
 822                *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
 823        if (mwdma_mask)
 824                *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
 825        if (udma_mask)
 826                *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
 827}
 828
 829static const struct ata_xfer_ent {
 830        int shift, bits;
 831        u8 base;
 832} ata_xfer_tbl[] = {
 833        { ATA_SHIFT_PIO, ATA_NR_PIO_MODES, XFER_PIO_0 },
 834        { ATA_SHIFT_MWDMA, ATA_NR_MWDMA_MODES, XFER_MW_DMA_0 },
 835        { ATA_SHIFT_UDMA, ATA_NR_UDMA_MODES, XFER_UDMA_0 },
 836        { -1, },
 837};
 838
 839/**
 840 *      ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
 841 *      @xfer_mask: xfer_mask of interest
 842 *
 843 *      Return matching XFER_* value for @xfer_mask.  Only the highest
 844 *      bit of @xfer_mask is considered.
 845 *
 846 *      LOCKING:
 847 *      None.
 848 *
 849 *      RETURNS:
 850 *      Matching XFER_* value, 0xff if no match found.
 851 */
 852u8 ata_xfer_mask2mode(unsigned long xfer_mask)
 853{
 854        int highbit = fls(xfer_mask) - 1;
 855        const struct ata_xfer_ent *ent;
 856
 857        for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
 858                if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
 859                        return ent->base + highbit - ent->shift;
 860        return 0xff;
 861}
 862EXPORT_SYMBOL_GPL(ata_xfer_mask2mode);
 863
 864/**
 865 *      ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
 866 *      @xfer_mode: XFER_* of interest
 867 *
 868 *      Return matching xfer_mask for @xfer_mode.
 869 *
 870 *      LOCKING:
 871 *      None.
 872 *
 873 *      RETURNS:
 874 *      Matching xfer_mask, 0 if no match found.
 875 */
 876unsigned long ata_xfer_mode2mask(u8 xfer_mode)
 877{
 878        const struct ata_xfer_ent *ent;
 879
 880        for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
 881                if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
 882                        return ((2 << (ent->shift + xfer_mode - ent->base)) - 1)
 883                                & ~((1 << ent->shift) - 1);
 884        return 0;
 885}
 886EXPORT_SYMBOL_GPL(ata_xfer_mode2mask);
 887
 888/**
 889 *      ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
 890 *      @xfer_mode: XFER_* of interest
 891 *
 892 *      Return matching xfer_shift for @xfer_mode.
 893 *
 894 *      LOCKING:
 895 *      None.
 896 *
 897 *      RETURNS:
 898 *      Matching xfer_shift, -1 if no match found.
 899 */
 900int ata_xfer_mode2shift(unsigned long xfer_mode)
 901{
 902        const struct ata_xfer_ent *ent;
 903
 904        for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
 905                if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
 906                        return ent->shift;
 907        return -1;
 908}
 909EXPORT_SYMBOL_GPL(ata_xfer_mode2shift);
 910
 911/**
 912 *      ata_mode_string - convert xfer_mask to string
 913 *      @xfer_mask: mask of bits supported; only highest bit counts.
 914 *
 915 *      Determine string which represents the highest speed
 916 *      (highest bit in @modemask).
 917 *
 918 *      LOCKING:
 919 *      None.
 920 *
 921 *      RETURNS:
 922 *      Constant C string representing highest speed listed in
 923 *      @mode_mask, or the constant C string "<n/a>".
 924 */
 925const char *ata_mode_string(unsigned long xfer_mask)
 926{
 927        static const char * const xfer_mode_str[] = {
 928                "PIO0",
 929                "PIO1",
 930                "PIO2",
 931                "PIO3",
 932                "PIO4",
 933                "PIO5",
 934                "PIO6",
 935                "MWDMA0",
 936                "MWDMA1",
 937                "MWDMA2",
 938                "MWDMA3",
 939                "MWDMA4",
 940                "UDMA/16",
 941                "UDMA/25",
 942                "UDMA/33",
 943                "UDMA/44",
 944                "UDMA/66",
 945                "UDMA/100",
 946                "UDMA/133",
 947                "UDMA7",
 948        };
 949        int highbit;
 950
 951        highbit = fls(xfer_mask) - 1;
 952        if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
 953                return xfer_mode_str[highbit];
 954        return "<n/a>";
 955}
 956EXPORT_SYMBOL_GPL(ata_mode_string);
 957
 958const char *sata_spd_string(unsigned int spd)
 959{
 960        static const char * const spd_str[] = {
 961                "1.5 Gbps",
 962                "3.0 Gbps",
 963                "6.0 Gbps",
 964        };
 965
 966        if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
 967                return "<unknown>";
 968        return spd_str[spd - 1];
 969}
 970
 971/**
 972 *      ata_dev_classify - determine device type based on ATA-spec signature
 973 *      @tf: ATA taskfile register set for device to be identified
 974 *
 975 *      Determine from taskfile register contents whether a device is
 976 *      ATA or ATAPI, as per "Signature and persistence" section
 977 *      of ATA/PI spec (volume 1, sect 5.14).
 978 *
 979 *      LOCKING:
 980 *      None.
 981 *
 982 *      RETURNS:
 983 *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP,
 984 *      %ATA_DEV_ZAC, or %ATA_DEV_UNKNOWN the event of failure.
 985 */
 986unsigned int ata_dev_classify(const struct ata_taskfile *tf)
 987{
 988        /* Apple's open source Darwin code hints that some devices only
 989         * put a proper signature into the LBA mid/high registers,
 990         * So, we only check those.  It's sufficient for uniqueness.
 991         *
 992         * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate
 993         * signatures for ATA and ATAPI devices attached on SerialATA,
 994         * 0x3c/0xc3 and 0x69/0x96 respectively.  However, SerialATA
 995         * spec has never mentioned about using different signatures
 996         * for ATA/ATAPI devices.  Then, Serial ATA II: Port
 997         * Multiplier specification began to use 0x69/0x96 to identify
 998         * port multpliers and 0x3c/0xc3 to identify SEMB device.
 999         * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and
1000         * 0x69/0x96 shortly and described them as reserved for
1001         * SerialATA.
1002         *
1003         * We follow the current spec and consider that 0x69/0x96
1004         * identifies a port multiplier and 0x3c/0xc3 a SEMB device.
1005         * Unfortunately, WDC WD1600JS-62MHB5 (a hard drive) reports
1006         * SEMB signature.  This is worked around in
1007         * ata_dev_read_id().
1008         */
1009        if ((tf->lbam == 0) && (tf->lbah == 0)) {
1010                DPRINTK("found ATA device by sig\n");
1011                return ATA_DEV_ATA;
1012        }
1013
1014        if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) {
1015                DPRINTK("found ATAPI device by sig\n");
1016                return ATA_DEV_ATAPI;
1017        }
1018
1019        if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) {
1020                DPRINTK("found PMP device by sig\n");
1021                return ATA_DEV_PMP;
1022        }
1023
1024        if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) {
1025                DPRINTK("found SEMB device by sig (could be ATA device)\n");
1026                return ATA_DEV_SEMB;
1027        }
1028
1029        if ((tf->lbam == 0xcd) && (tf->lbah == 0xab)) {
1030                DPRINTK("found ZAC device by sig\n");
1031                return ATA_DEV_ZAC;
1032        }
1033
1034        DPRINTK("unknown device\n");
1035        return ATA_DEV_UNKNOWN;
1036}
1037EXPORT_SYMBOL_GPL(ata_dev_classify);
1038
1039/**
1040 *      ata_id_string - Convert IDENTIFY DEVICE page into string
1041 *      @id: IDENTIFY DEVICE results we will examine
1042 *      @s: string into which data is output
1043 *      @ofs: offset into identify device page
1044 *      @len: length of string to return. must be an even number.
1045 *
1046 *      The strings in the IDENTIFY DEVICE page are broken up into
1047 *      16-bit chunks.  Run through the string, and output each
1048 *      8-bit chunk linearly, regardless of platform.
1049 *
1050 *      LOCKING:
1051 *      caller.
1052 */
1053
1054void ata_id_string(const u16 *id, unsigned char *s,
1055                   unsigned int ofs, unsigned int len)
1056{
1057        unsigned int c;
1058
1059        BUG_ON(len & 1);
1060
1061        while (len > 0) {
1062                c = id[ofs] >> 8;
1063                *s = c;
1064                s++;
1065
1066                c = id[ofs] & 0xff;
1067                *s = c;
1068                s++;
1069
1070                ofs++;
1071                len -= 2;
1072        }
1073}
1074EXPORT_SYMBOL_GPL(ata_id_string);
1075
1076/**
1077 *      ata_id_c_string - Convert IDENTIFY DEVICE page into C string
1078 *      @id: IDENTIFY DEVICE results we will examine
1079 *      @s: string into which data is output
1080 *      @ofs: offset into identify device page
1081 *      @len: length of string to return. must be an odd number.
1082 *
1083 *      This function is identical to ata_id_string except that it
1084 *      trims trailing spaces and terminates the resulting string with
1085 *      null.  @len must be actual maximum length (even number) + 1.
1086 *
1087 *      LOCKING:
1088 *      caller.
1089 */
1090void ata_id_c_string(const u16 *id, unsigned char *s,
1091                     unsigned int ofs, unsigned int len)
1092{
1093        unsigned char *p;
1094
1095        ata_id_string(id, s, ofs, len - 1);
1096
1097        p = s + strnlen(s, len - 1);
1098        while (p > s && p[-1] == ' ')
1099                p--;
1100        *p = '\0';
1101}
1102EXPORT_SYMBOL_GPL(ata_id_c_string);
1103
1104static u64 ata_id_n_sectors(const u16 *id)
1105{
1106        if (ata_id_has_lba(id)) {
1107                if (ata_id_has_lba48(id))
1108                        return ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
1109                else
1110                        return ata_id_u32(id, ATA_ID_LBA_CAPACITY);
1111        } else {
1112                if (ata_id_current_chs_valid(id))
1113                        return id[ATA_ID_CUR_CYLS] * id[ATA_ID_CUR_HEADS] *
1114                               id[ATA_ID_CUR_SECTORS];
1115                else
1116                        return id[ATA_ID_CYLS] * id[ATA_ID_HEADS] *
1117                               id[ATA_ID_SECTORS];
1118        }
1119}
1120
1121u64 ata_tf_to_lba48(const struct ata_taskfile *tf)
1122{
1123        u64 sectors = 0;
1124
1125        sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40;
1126        sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32;
1127        sectors |= ((u64)(tf->hob_lbal & 0xff)) << 24;
1128        sectors |= (tf->lbah & 0xff) << 16;
1129        sectors |= (tf->lbam & 0xff) << 8;
1130        sectors |= (tf->lbal & 0xff);
1131
1132        return sectors;
1133}
1134
1135u64 ata_tf_to_lba(const struct ata_taskfile *tf)
1136{
1137        u64 sectors = 0;
1138
1139        sectors |= (tf->device & 0x0f) << 24;
1140        sectors |= (tf->lbah & 0xff) << 16;
1141        sectors |= (tf->lbam & 0xff) << 8;
1142        sectors |= (tf->lbal & 0xff);
1143
1144        return sectors;
1145}
1146
1147/**
1148 *      ata_read_native_max_address - Read native max address
1149 *      @dev: target device
1150 *      @max_sectors: out parameter for the result native max address
1151 *
1152 *      Perform an LBA48 or LBA28 native size query upon the device in
1153 *      question.
1154 *
1155 *      RETURNS:
1156 *      0 on success, -EACCES if command is aborted by the drive.
1157 *      -EIO on other errors.
1158 */
1159static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
1160{
1161        unsigned int err_mask;
1162        struct ata_taskfile tf;
1163        int lba48 = ata_id_has_lba48(dev->id);
1164
1165        ata_tf_init(dev, &tf);
1166
1167        /* always clear all address registers */
1168        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1169
1170        if (lba48) {
1171                tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
1172                tf.flags |= ATA_TFLAG_LBA48;
1173        } else
1174                tf.command = ATA_CMD_READ_NATIVE_MAX;
1175
1176        tf.protocol = ATA_PROT_NODATA;
1177        tf.device |= ATA_LBA;
1178
1179        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1180        if (err_mask) {
1181                ata_dev_warn(dev,
1182                             "failed to read native max address (err_mask=0x%x)\n",
1183                             err_mask);
1184                if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
1185                        return -EACCES;
1186                return -EIO;
1187        }
1188
1189        if (lba48)
1190                *max_sectors = ata_tf_to_lba48(&tf) + 1;
1191        else
1192                *max_sectors = ata_tf_to_lba(&tf) + 1;
1193        if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
1194                (*max_sectors)--;
1195        return 0;
1196}
1197
1198/**
1199 *      ata_set_max_sectors - Set max sectors
1200 *      @dev: target device
1201 *      @new_sectors: new max sectors value to set for the device
1202 *
1203 *      Set max sectors of @dev to @new_sectors.
1204 *
1205 *      RETURNS:
1206 *      0 on success, -EACCES if command is aborted or denied (due to
1207 *      previous non-volatile SET_MAX) by the drive.  -EIO on other
1208 *      errors.
1209 */
1210static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors)
1211{
1212        unsigned int err_mask;
1213        struct ata_taskfile tf;
1214        int lba48 = ata_id_has_lba48(dev->id);
1215
1216        new_sectors--;
1217
1218        ata_tf_init(dev, &tf);
1219
1220        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1221
1222        if (lba48) {
1223                tf.command = ATA_CMD_SET_MAX_EXT;
1224                tf.flags |= ATA_TFLAG_LBA48;
1225
1226                tf.hob_lbal = (new_sectors >> 24) & 0xff;
1227                tf.hob_lbam = (new_sectors >> 32) & 0xff;
1228                tf.hob_lbah = (new_sectors >> 40) & 0xff;
1229        } else {
1230                tf.command = ATA_CMD_SET_MAX;
1231
1232                tf.device |= (new_sectors >> 24) & 0xf;
1233        }
1234
1235        tf.protocol = ATA_PROT_NODATA;
1236        tf.device |= ATA_LBA;
1237
1238        tf.lbal = (new_sectors >> 0) & 0xff;
1239        tf.lbam = (new_sectors >> 8) & 0xff;
1240        tf.lbah = (new_sectors >> 16) & 0xff;
1241
1242        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1243        if (err_mask) {
1244                ata_dev_warn(dev,
1245                             "failed to set max address (err_mask=0x%x)\n",
1246                             err_mask);
1247                if (err_mask == AC_ERR_DEV &&
1248                    (tf.feature & (ATA_ABORTED | ATA_IDNF)))
1249                        return -EACCES;
1250                return -EIO;
1251        }
1252
1253        return 0;
1254}
1255
1256/**
1257 *      ata_hpa_resize          -       Resize a device with an HPA set
1258 *      @dev: Device to resize
1259 *
1260 *      Read the size of an LBA28 or LBA48 disk with HPA features and resize
1261 *      it if required to the full size of the media. The caller must check
1262 *      the drive has the HPA feature set enabled.
1263 *
1264 *      RETURNS:
1265 *      0 on success, -errno on failure.
1266 */
1267static int ata_hpa_resize(struct ata_device *dev)
1268{
1269        struct ata_eh_context *ehc = &dev->link->eh_context;
1270        int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
1271        bool unlock_hpa = ata_ignore_hpa || dev->flags & ATA_DFLAG_UNLOCK_HPA;
1272        u64 sectors = ata_id_n_sectors(dev->id);
1273        u64 native_sectors;
1274        int rc;
1275
1276        /* do we need to do it? */
1277        if ((dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC) ||
1278            !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) ||
1279            (dev->horkage & ATA_HORKAGE_BROKEN_HPA))
1280                return 0;
1281
1282        /* read native max address */
1283        rc = ata_read_native_max_address(dev, &native_sectors);
1284        if (rc) {
1285                /* If device aborted the command or HPA isn't going to
1286                 * be unlocked, skip HPA resizing.
1287                 */
1288                if (rc == -EACCES || !unlock_hpa) {
1289                        ata_dev_warn(dev,
1290                                     "HPA support seems broken, skipping HPA handling\n");
1291                        dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
1292
1293                        /* we can continue if device aborted the command */
1294                        if (rc == -EACCES)
1295                                rc = 0;
1296                }
1297
1298                return rc;
1299        }
1300        dev->n_native_sectors = native_sectors;
1301
1302        /* nothing to do? */
1303        if (native_sectors <= sectors || !unlock_hpa) {
1304                if (!print_info || native_sectors == sectors)
1305                        return 0;
1306
1307                if (native_sectors > sectors)
1308                        ata_dev_info(dev,
1309                                "HPA detected: current %llu, native %llu\n",
1310                                (unsigned long long)sectors,
1311                                (unsigned long long)native_sectors);
1312                else if (native_sectors < sectors)
1313                        ata_dev_warn(dev,
1314                                "native sectors (%llu) is smaller than sectors (%llu)\n",
1315                                (unsigned long long)native_sectors,
1316                                (unsigned long long)sectors);
1317                return 0;
1318        }
1319
1320        /* let's unlock HPA */
1321        rc = ata_set_max_sectors(dev, native_sectors);
1322        if (rc == -EACCES) {
1323                /* if device aborted the command, skip HPA resizing */
1324                ata_dev_warn(dev,
1325                             "device aborted resize (%llu -> %llu), skipping HPA handling\n",
1326                             (unsigned long long)sectors,
1327                             (unsigned long long)native_sectors);
1328                dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
1329                return 0;
1330        } else if (rc)
1331                return rc;
1332
1333        /* re-read IDENTIFY data */
1334        rc = ata_dev_reread_id(dev, 0);
1335        if (rc) {
1336                ata_dev_err(dev,
1337                            "failed to re-read IDENTIFY data after HPA resizing\n");
1338                return rc;
1339        }
1340
1341        if (print_info) {
1342                u64 new_sectors = ata_id_n_sectors(dev->id);
1343                ata_dev_info(dev,
1344                        "HPA unlocked: %llu -> %llu, native %llu\n",
1345                        (unsigned long long)sectors,
1346                        (unsigned long long)new_sectors,
1347                        (unsigned long long)native_sectors);
1348        }
1349
1350        return 0;
1351}
1352
1353/**
1354 *      ata_dump_id - IDENTIFY DEVICE info debugging output
1355 *      @id: IDENTIFY DEVICE page to dump
1356 *
1357 *      Dump selected 16-bit words from the given IDENTIFY DEVICE
1358 *      page.
1359 *
1360 *      LOCKING:
1361 *      caller.
1362 */
1363
1364static inline void ata_dump_id(const u16 *id)
1365{
1366        DPRINTK("49==0x%04x  "
1367                "53==0x%04x  "
1368                "63==0x%04x  "
1369                "64==0x%04x  "
1370                "75==0x%04x  \n",
1371                id[49],
1372                id[53],
1373                id[63],
1374                id[64],
1375                id[75]);
1376        DPRINTK("80==0x%04x  "
1377                "81==0x%04x  "
1378                "82==0x%04x  "
1379                "83==0x%04x  "
1380                "84==0x%04x  \n",
1381                id[80],
1382                id[81],
1383                id[82],
1384                id[83],
1385                id[84]);
1386        DPRINTK("88==0x%04x  "
1387                "93==0x%04x\n",
1388                id[88],
1389                id[93]);
1390}
1391
1392/**
1393 *      ata_id_xfermask - Compute xfermask from the given IDENTIFY data
1394 *      @id: IDENTIFY data to compute xfer mask from
1395 *
1396 *      Compute the xfermask for this device. This is not as trivial
1397 *      as it seems if we must consider early devices correctly.
1398 *
1399 *      FIXME: pre IDE drive timing (do we care ?).
1400 *
1401 *      LOCKING:
1402 *      None.
1403 *
1404 *      RETURNS:
1405 *      Computed xfermask
1406 */
1407unsigned long ata_id_xfermask(const u16 *id)
1408{
1409        unsigned long pio_mask, mwdma_mask, udma_mask;
1410
1411        /* Usual case. Word 53 indicates word 64 is valid */
1412        if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
1413                pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
1414                pio_mask <<= 3;
1415                pio_mask |= 0x7;
1416        } else {
1417                /* If word 64 isn't valid then Word 51 high byte holds
1418                 * the PIO timing number for the maximum. Turn it into
1419                 * a mask.
1420                 */
1421                u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
1422                if (mode < 5)   /* Valid PIO range */
1423                        pio_mask = (2 << mode) - 1;
1424                else
1425                        pio_mask = 1;
1426
1427                /* But wait.. there's more. Design your standards by
1428                 * committee and you too can get a free iordy field to
1429                 * process. However its the speeds not the modes that
1430                 * are supported... Note drivers using the timing API
1431                 * will get this right anyway
1432                 */
1433        }
1434
1435        mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
1436
1437        if (ata_id_is_cfa(id)) {
1438                /*
1439                 *      Process compact flash extended modes
1440                 */
1441                int pio = (id[ATA_ID_CFA_MODES] >> 0) & 0x7;
1442                int dma = (id[ATA_ID_CFA_MODES] >> 3) & 0x7;
1443
1444                if (pio)
1445                        pio_mask |= (1 << 5);
1446                if (pio > 1)
1447                        pio_mask |= (1 << 6);
1448                if (dma)
1449                        mwdma_mask |= (1 << 3);
1450                if (dma > 1)
1451                        mwdma_mask |= (1 << 4);
1452        }
1453
1454        udma_mask = 0;
1455        if (id[ATA_ID_FIELD_VALID] & (1 << 2))
1456                udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
1457
1458        return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
1459}
1460EXPORT_SYMBOL_GPL(ata_id_xfermask);
1461
1462static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
1463{
1464        struct completion *waiting = qc->private_data;
1465
1466        complete(waiting);
1467}
1468
1469/**
1470 *      ata_exec_internal_sg - execute libata internal command
1471 *      @dev: Device to which the command is sent
1472 *      @tf: Taskfile registers for the command and the result
1473 *      @cdb: CDB for packet command
1474 *      @dma_dir: Data transfer direction of the command
1475 *      @sgl: sg list for the data buffer of the command
1476 *      @n_elem: Number of sg entries
1477 *      @timeout: Timeout in msecs (0 for default)
1478 *
1479 *      Executes libata internal command with timeout.  @tf contains
1480 *      command on entry and result on return.  Timeout and error
1481 *      conditions are reported via return value.  No recovery action
1482 *      is taken after a command times out.  It's caller's duty to
1483 *      clean up after timeout.
1484 *
1485 *      LOCKING:
1486 *      None.  Should be called with kernel context, might sleep.
1487 *
1488 *      RETURNS:
1489 *      Zero on success, AC_ERR_* mask on failure
1490 */
1491unsigned ata_exec_internal_sg(struct ata_device *dev,
1492                              struct ata_taskfile *tf, const u8 *cdb,
1493                              int dma_dir, struct scatterlist *sgl,
1494                              unsigned int n_elem, unsigned long timeout)
1495{
1496        struct ata_link *link = dev->link;
1497        struct ata_port *ap = link->ap;
1498        u8 command = tf->command;
1499        int auto_timeout = 0;
1500        struct ata_queued_cmd *qc;
1501        unsigned int preempted_tag;
1502        u32 preempted_sactive;
1503        u64 preempted_qc_active;
1504        int preempted_nr_active_links;
1505        DECLARE_COMPLETION_ONSTACK(wait);
1506        unsigned long flags;
1507        unsigned int err_mask;
1508        int rc;
1509
1510        spin_lock_irqsave(ap->lock, flags);
1511
1512        /* no internal command while frozen */
1513        if (ap->pflags & ATA_PFLAG_FROZEN) {
1514                spin_unlock_irqrestore(ap->lock, flags);
1515                return AC_ERR_SYSTEM;
1516        }
1517
1518        /* initialize internal qc */
1519        qc = __ata_qc_from_tag(ap, ATA_TAG_INTERNAL);
1520
1521        qc->tag = ATA_TAG_INTERNAL;
1522        qc->hw_tag = 0;
1523        qc->scsicmd = NULL;
1524        qc->ap = ap;
1525        qc->dev = dev;
1526        ata_qc_reinit(qc);
1527
1528        preempted_tag = link->active_tag;
1529        preempted_sactive = link->sactive;
1530        preempted_qc_active = ap->qc_active;
1531        preempted_nr_active_links = ap->nr_active_links;
1532        link->active_tag = ATA_TAG_POISON;
1533        link->sactive = 0;
1534        ap->qc_active = 0;
1535        ap->nr_active_links = 0;
1536
1537        /* prepare & issue qc */
1538        qc->tf = *tf;
1539        if (cdb)
1540                memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
1541
1542        /* some SATA bridges need us to indicate data xfer direction */
1543        if (tf->protocol == ATAPI_PROT_DMA && (dev->flags & ATA_DFLAG_DMADIR) &&
1544            dma_dir == DMA_FROM_DEVICE)
1545                qc->tf.feature |= ATAPI_DMADIR;
1546
1547        qc->flags |= ATA_QCFLAG_RESULT_TF;
1548        qc->dma_dir = dma_dir;
1549        if (dma_dir != DMA_NONE) {
1550                unsigned int i, buflen = 0;
1551                struct scatterlist *sg;
1552
1553                for_each_sg(sgl, sg, n_elem, i)
1554                        buflen += sg->length;
1555
1556                ata_sg_init(qc, sgl, n_elem);
1557                qc->nbytes = buflen;
1558        }
1559
1560        qc->private_data = &wait;
1561        qc->complete_fn = ata_qc_complete_internal;
1562
1563        ata_qc_issue(qc);
1564
1565        spin_unlock_irqrestore(ap->lock, flags);
1566
1567        if (!timeout) {
1568                if (ata_probe_timeout)
1569                        timeout = ata_probe_timeout * 1000;
1570                else {
1571                        timeout = ata_internal_cmd_timeout(dev, command);
1572                        auto_timeout = 1;
1573                }
1574        }
1575
1576        if (ap->ops->error_handler)
1577                ata_eh_release(ap);
1578
1579        rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));
1580
1581        if (ap->ops->error_handler)
1582                ata_eh_acquire(ap);
1583
1584        ata_sff_flush_pio_task(ap);
1585
1586        if (!rc) {
1587                spin_lock_irqsave(ap->lock, flags);
1588
1589                /* We're racing with irq here.  If we lose, the
1590                 * following test prevents us from completing the qc
1591                 * twice.  If we win, the port is frozen and will be
1592                 * cleaned up by ->post_internal_cmd().
1593                 */
1594                if (qc->flags & ATA_QCFLAG_ACTIVE) {
1595                        qc->err_mask |= AC_ERR_TIMEOUT;
1596
1597                        if (ap->ops->error_handler)
1598                                ata_port_freeze(ap);
1599                        else
1600                                ata_qc_complete(qc);
1601
1602                        if (ata_msg_warn(ap))
1603                                ata_dev_warn(dev, "qc timeout (cmd 0x%x)\n",
1604                                             command);
1605                }
1606
1607                spin_unlock_irqrestore(ap->lock, flags);
1608        }
1609
1610        /* do post_internal_cmd */
1611        if (ap->ops->post_internal_cmd)
1612                ap->ops->post_internal_cmd(qc);
1613
1614        /* perform minimal error analysis */
1615        if (qc->flags & ATA_QCFLAG_FAILED) {
1616                if (qc->result_tf.command & (ATA_ERR | ATA_DF))
1617                        qc->err_mask |= AC_ERR_DEV;
1618
1619                if (!qc->err_mask)
1620                        qc->err_mask |= AC_ERR_OTHER;
1621
1622                if (qc->err_mask & ~AC_ERR_OTHER)
1623                        qc->err_mask &= ~AC_ERR_OTHER;
1624        } else if (qc->tf.command == ATA_CMD_REQ_SENSE_DATA) {
1625                qc->result_tf.command |= ATA_SENSE;
1626        }
1627
1628        /* finish up */
1629        spin_lock_irqsave(ap->lock, flags);
1630
1631        *tf = qc->result_tf;
1632        err_mask = qc->err_mask;
1633
1634        ata_qc_free(qc);
1635        link->active_tag = preempted_tag;
1636        link->sactive = preempted_sactive;
1637        ap->qc_active = preempted_qc_active;
1638        ap->nr_active_links = preempted_nr_active_links;
1639
1640        spin_unlock_irqrestore(ap->lock, flags);
1641
1642        if ((err_mask & AC_ERR_TIMEOUT) && auto_timeout)
1643                ata_internal_cmd_timed_out(dev, command);
1644
1645        return err_mask;
1646}
1647
1648/**
1649 *      ata_exec_internal - execute libata internal command
1650 *      @dev: Device to which the command is sent
1651 *      @tf: Taskfile registers for the command and the result
1652 *      @cdb: CDB for packet command
1653 *      @dma_dir: Data transfer direction of the command
1654 *      @buf: Data buffer of the command
1655 *      @buflen: Length of data buffer
1656 *      @timeout: Timeout in msecs (0 for default)
1657 *
1658 *      Wrapper around ata_exec_internal_sg() which takes simple
1659 *      buffer instead of sg list.
1660 *
1661 *      LOCKING:
1662 *      None.  Should be called with kernel context, might sleep.
1663 *
1664 *      RETURNS:
1665 *      Zero on success, AC_ERR_* mask on failure
1666 */
1667unsigned ata_exec_internal(struct ata_device *dev,
1668                           struct ata_taskfile *tf, const u8 *cdb,
1669                           int dma_dir, void *buf, unsigned int buflen,
1670                           unsigned long timeout)
1671{
1672        struct scatterlist *psg = NULL, sg;
1673        unsigned int n_elem = 0;
1674
1675        if (dma_dir != DMA_NONE) {
1676                WARN_ON(!buf);
1677                sg_init_one(&sg, buf, buflen);
1678                psg = &sg;
1679                n_elem++;
1680        }
1681
1682        return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem,
1683                                    timeout);
1684}
1685
1686/**
1687 *      ata_pio_need_iordy      -       check if iordy needed
1688 *      @adev: ATA device
1689 *
1690 *      Check if the current speed of the device requires IORDY. Used
1691 *      by various controllers for chip configuration.
1692 */
1693unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1694{
1695        /* Don't set IORDY if we're preparing for reset.  IORDY may
1696         * lead to controller lock up on certain controllers if the
1697         * port is not occupied.  See bko#11703 for details.
1698         */
1699        if (adev->link->ap->pflags & ATA_PFLAG_RESETTING)
1700                return 0;
1701        /* Controller doesn't support IORDY.  Probably a pointless
1702         * check as the caller should know this.
1703         */
1704        if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
1705                return 0;
1706        /* CF spec. r4.1 Table 22 says no iordy on PIO5 and PIO6.  */
1707        if (ata_id_is_cfa(adev->id)
1708            && (adev->pio_mode == XFER_PIO_5 || adev->pio_mode == XFER_PIO_6))
1709                return 0;
1710        /* PIO3 and higher it is mandatory */
1711        if (adev->pio_mode > XFER_PIO_2)
1712                return 1;
1713        /* We turn it on when possible */
1714        if (ata_id_has_iordy(adev->id))
1715                return 1;
1716        return 0;
1717}
1718EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
1719
1720/**
1721 *      ata_pio_mask_no_iordy   -       Return the non IORDY mask
1722 *      @adev: ATA device
1723 *
1724 *      Compute the highest mode possible if we are not using iordy. Return
1725 *      -1 if no iordy mode is available.
1726 */
1727static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
1728{
1729        /* If we have no drive specific rule, then PIO 2 is non IORDY */
1730        if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
1731                u16 pio = adev->id[ATA_ID_EIDE_PIO];
1732                /* Is the speed faster than the drive allows non IORDY ? */
1733                if (pio) {
1734                        /* This is cycle times not frequency - watch the logic! */
1735                        if (pio > 240)  /* PIO2 is 240nS per cycle */
1736                                return 3 << ATA_SHIFT_PIO;
1737                        return 7 << ATA_SHIFT_PIO;
1738                }
1739        }
1740        return 3 << ATA_SHIFT_PIO;
1741}
1742
1743/**
1744 *      ata_do_dev_read_id              -       default ID read method
1745 *      @dev: device
1746 *      @tf: proposed taskfile
1747 *      @id: data buffer
1748 *
1749 *      Issue the identify taskfile and hand back the buffer containing
1750 *      identify data. For some RAID controllers and for pre ATA devices
1751 *      this function is wrapped or replaced by the driver
1752 */
1753unsigned int ata_do_dev_read_id(struct ata_device *dev,
1754                                        struct ata_taskfile *tf, u16 *id)
1755{
1756        return ata_exec_internal(dev, tf, NULL, DMA_FROM_DEVICE,
1757                                     id, sizeof(id[0]) * ATA_ID_WORDS, 0);
1758}
1759EXPORT_SYMBOL_GPL(ata_do_dev_read_id);
1760
1761/**
1762 *      ata_dev_read_id - Read ID data from the specified device
1763 *      @dev: target device
1764 *      @p_class: pointer to class of the target device (may be changed)
1765 *      @flags: ATA_READID_* flags
1766 *      @id: buffer to read IDENTIFY data into
1767 *
1768 *      Read ID data from the specified device.  ATA_CMD_ID_ATA is
1769 *      performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
1770 *      devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
1771 *      for pre-ATA4 drives.
1772 *
1773 *      FIXME: ATA_CMD_ID_ATA is optional for early drives and right
1774 *      now we abort if we hit that case.
1775 *
1776 *      LOCKING:
1777 *      Kernel thread context (may sleep)
1778 *
1779 *      RETURNS:
1780 *      0 on success, -errno otherwise.
1781 */
1782int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
1783                    unsigned int flags, u16 *id)
1784{
1785        struct ata_port *ap = dev->link->ap;
1786        unsigned int class = *p_class;
1787        struct ata_taskfile tf;
1788        unsigned int err_mask = 0;
1789        const char *reason;
1790        bool is_semb = class == ATA_DEV_SEMB;
1791        int may_fallback = 1, tried_spinup = 0;
1792        int rc;
1793
1794        if (ata_msg_ctl(ap))
1795                ata_dev_dbg(dev, "%s: ENTER\n", __func__);
1796
1797retry:
1798        ata_tf_init(dev, &tf);
1799
1800        switch (class) {
1801        case ATA_DEV_SEMB:
1802                class = ATA_DEV_ATA;    /* some hard drives report SEMB sig */
1803                fallthrough;
1804        case ATA_DEV_ATA:
1805        case ATA_DEV_ZAC:
1806                tf.command = ATA_CMD_ID_ATA;
1807                break;
1808        case ATA_DEV_ATAPI:
1809                tf.command = ATA_CMD_ID_ATAPI;
1810                break;
1811        default:
1812                rc = -ENODEV;
1813                reason = "unsupported class";
1814                goto err_out;
1815        }
1816
1817        tf.protocol = ATA_PROT_PIO;
1818
1819        /* Some devices choke if TF registers contain garbage.  Make
1820         * sure those are properly initialized.
1821         */
1822        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1823
1824        /* Device presence detection is unreliable on some
1825         * controllers.  Always poll IDENTIFY if available.
1826         */
1827        tf.flags |= ATA_TFLAG_POLLING;
1828
1829        if (ap->ops->read_id)
1830                err_mask = ap->ops->read_id(dev, &tf, id);
1831        else
1832                err_mask = ata_do_dev_read_id(dev, &tf, id);
1833
1834        if (err_mask) {
1835                if (err_mask & AC_ERR_NODEV_HINT) {
1836                        ata_dev_dbg(dev, "NODEV after polling detection\n");
1837                        return -ENOENT;
1838                }
1839
1840                if (is_semb) {
1841                        ata_dev_info(dev,
1842                     "IDENTIFY failed on device w/ SEMB sig, disabled\n");
1843                        /* SEMB is not supported yet */
1844                        *p_class = ATA_DEV_SEMB_UNSUP;
1845                        return 0;
1846                }
1847
1848                if ((err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) {
1849                        /* Device or controller might have reported
1850                         * the wrong device class.  Give a shot at the
1851                         * other IDENTIFY if the current one is
1852                         * aborted by the device.
1853                         */
1854                        if (may_fallback) {
1855                                may_fallback = 0;
1856
1857                                if (class == ATA_DEV_ATA)
1858                                        class = ATA_DEV_ATAPI;
1859                                else
1860                                        class = ATA_DEV_ATA;
1861                                goto retry;
1862                        }
1863
1864                        /* Control reaches here iff the device aborted
1865                         * both flavors of IDENTIFYs which happens
1866                         * sometimes with phantom devices.
1867                         */
1868                        ata_dev_dbg(dev,
1869                                    "both IDENTIFYs aborted, assuming NODEV\n");
1870                        return -ENOENT;
1871                }
1872
1873                rc = -EIO;
1874                reason = "I/O error";
1875                goto err_out;
1876        }
1877
1878        if (dev->horkage & ATA_HORKAGE_DUMP_ID) {
1879                ata_dev_dbg(dev, "dumping IDENTIFY data, "
1880                            "class=%d may_fallback=%d tried_spinup=%d\n",
1881                            class, may_fallback, tried_spinup);
1882                print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,
1883                               16, 2, id, ATA_ID_WORDS * sizeof(*id), true);
1884        }
1885
1886        /* Falling back doesn't make sense if ID data was read
1887         * successfully at least once.
1888         */
1889        may_fallback = 0;
1890
1891        swap_buf_le16(id, ATA_ID_WORDS);
1892
1893        /* sanity check */
1894        rc = -EINVAL;
1895        reason = "device reports invalid type";
1896
1897        if (class == ATA_DEV_ATA || class == ATA_DEV_ZAC) {
1898                if (!ata_id_is_ata(id) && !ata_id_is_cfa(id))
1899                        goto err_out;
1900                if (ap->host->flags & ATA_HOST_IGNORE_ATA &&
1901                                                        ata_id_is_ata(id)) {
1902                        ata_dev_dbg(dev,
1903                                "host indicates ignore ATA devices, ignored\n");
1904                        return -ENOENT;
1905                }
1906        } else {
1907                if (ata_id_is_ata(id))
1908                        goto err_out;
1909        }
1910
1911        if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) {
1912                tried_spinup = 1;
1913                /*
1914                 * Drive powered-up in standby mode, and requires a specific
1915                 * SET_FEATURES spin-up subcommand before it will accept
1916                 * anything other than the original IDENTIFY command.
1917                 */
1918                err_mask = ata_dev_set_feature(dev, SETFEATURES_SPINUP, 0);
1919                if (err_mask && id[2] != 0x738c) {
1920                        rc = -EIO;
1921                        reason = "SPINUP failed";
1922                        goto err_out;
1923                }
1924                /*
1925                 * If the drive initially returned incomplete IDENTIFY info,
1926                 * we now must reissue the IDENTIFY command.
1927                 */
1928                if (id[2] == 0x37c8)
1929                        goto retry;
1930        }
1931
1932        if ((flags & ATA_READID_POSTRESET) &&
1933            (class == ATA_DEV_ATA || class == ATA_DEV_ZAC)) {
1934                /*
1935                 * The exact sequence expected by certain pre-ATA4 drives is:
1936                 * SRST RESET
1937                 * IDENTIFY (optional in early ATA)
1938                 * INITIALIZE DEVICE PARAMETERS (later IDE and ATA)
1939                 * anything else..
1940                 * Some drives were very specific about that exact sequence.
1941                 *
1942                 * Note that ATA4 says lba is mandatory so the second check
1943                 * should never trigger.
1944                 */
1945                if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
1946                        err_mask = ata_dev_init_params(dev, id[3], id[6]);
1947                        if (err_mask) {
1948                                rc = -EIO;
1949                                reason = "INIT_DEV_PARAMS failed";
1950                                goto err_out;
1951                        }
1952
1953                        /* current CHS translation info (id[53-58]) might be
1954                         * changed. reread the identify device info.
1955                         */
1956                        flags &= ~ATA_READID_POSTRESET;
1957                        goto retry;
1958                }
1959        }
1960
1961        *p_class = class;
1962
1963        return 0;
1964
1965 err_out:
1966        if (ata_msg_warn(ap))
1967                ata_dev_warn(dev, "failed to IDENTIFY (%s, err_mask=0x%x)\n",
1968                             reason, err_mask);
1969        return rc;
1970}
1971
1972/**
1973 *      ata_read_log_page - read a specific log page
1974 *      @dev: target device
1975 *      @log: log to read
1976 *      @page: page to read
1977 *      @buf: buffer to store read page
1978 *      @sectors: number of sectors to read
1979 *
1980 *      Read log page using READ_LOG_EXT command.
1981 *
1982 *      LOCKING:
1983 *      Kernel thread context (may sleep).
1984 *
1985 *      RETURNS:
1986 *      0 on success, AC_ERR_* mask otherwise.
1987 */
1988unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
1989                               u8 page, void *buf, unsigned int sectors)
1990{
1991        unsigned long ap_flags = dev->link->ap->flags;
1992        struct ata_taskfile tf;
1993        unsigned int err_mask;
1994        bool dma = false;
1995
1996        DPRINTK("read log page - log 0x%x, page 0x%x\n", log, page);
1997
1998        /*
1999         * Return error without actually issuing the command on controllers
2000         * which e.g. lockup on a read log page.
2001         */
2002        if (ap_flags & ATA_FLAG_NO_LOG_PAGE)
2003                return AC_ERR_DEV;
2004
2005retry:
2006        ata_tf_init(dev, &tf);
2007        if (dev->dma_mode && ata_id_has_read_log_dma_ext(dev->id) &&
2008            !(dev->horkage & ATA_HORKAGE_NO_DMA_LOG)) {
2009                tf.command = ATA_CMD_READ_LOG_DMA_EXT;
2010                tf.protocol = ATA_PROT_DMA;
2011                dma = true;
2012        } else {
2013                tf.command = ATA_CMD_READ_LOG_EXT;
2014                tf.protocol = ATA_PROT_PIO;
2015                dma = false;
2016        }
2017        tf.lbal = log;
2018        tf.lbam = page;
2019        tf.nsect = sectors;
2020        tf.hob_nsect = sectors >> 8;
2021        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
2022
2023        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
2024                                     buf, sectors * ATA_SECT_SIZE, 0);
2025
2026        if (err_mask && dma) {
2027                dev->horkage |= ATA_HORKAGE_NO_DMA_LOG;
2028                ata_dev_warn(dev, "READ LOG DMA EXT failed, trying PIO\n");
2029                goto retry;
2030        }
2031
2032        DPRINTK("EXIT, err_mask=%x\n", err_mask);
2033        return err_mask;
2034}
2035
2036static bool ata_log_supported(struct ata_device *dev, u8 log)
2037{
2038        struct ata_port *ap = dev->link->ap;
2039
2040        if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
2041                return false;
2042        return get_unaligned_le16(&ap->sector_buf[log * 2]) ? true : false;
2043}
2044
2045static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
2046{
2047        struct ata_port *ap = dev->link->ap;
2048        unsigned int err, i;
2049
2050        if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE)) {
2051                ata_dev_warn(dev, "ATA Identify Device Log not supported\n");
2052                return false;
2053        }
2054
2055        /*
2056         * Read IDENTIFY DEVICE data log, page 0, to figure out if the page is
2057         * supported.
2058         */
2059        err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, 0, ap->sector_buf,
2060                                1);
2061        if (err) {
2062                ata_dev_info(dev,
2063                             "failed to get Device Identify Log Emask 0x%x\n",
2064                             err);
2065                return false;
2066        }
2067
2068        for (i = 0; i < ap->sector_buf[8]; i++) {
2069                if (ap->sector_buf[9 + i] == page)
2070                        return true;
2071        }
2072
2073        return false;
2074}
2075
2076static int ata_do_link_spd_horkage(struct ata_device *dev)
2077{
2078        struct ata_link *plink = ata_dev_phys_link(dev);
2079        u32 target, target_limit;
2080
2081        if (!sata_scr_valid(plink))
2082                return 0;
2083
2084        if (dev->horkage & ATA_HORKAGE_1_5_GBPS)
2085                target = 1;
2086        else
2087                return 0;
2088
2089        target_limit = (1 << target) - 1;
2090
2091        /* if already on stricter limit, no need to push further */
2092        if (plink->sata_spd_limit <= target_limit)
2093                return 0;
2094
2095        plink->sata_spd_limit = target_limit;
2096
2097        /* Request another EH round by returning -EAGAIN if link is
2098         * going faster than the target speed.  Forward progress is
2099         * guaranteed by setting sata_spd_limit to target_limit above.
2100         */
2101        if (plink->sata_spd > target) {
2102                ata_dev_info(dev, "applying link speed limit horkage to %s\n",
2103                             sata_spd_string(target));
2104                return -EAGAIN;
2105        }
2106        return 0;
2107}
2108
2109static inline u8 ata_dev_knobble(struct ata_device *dev)
2110{
2111        struct ata_port *ap = dev->link->ap;
2112
2113        if (ata_dev_blacklisted(dev) & ATA_HORKAGE_BRIDGE_OK)
2114                return 0;
2115
2116        return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
2117}
2118
2119static void ata_dev_config_ncq_send_recv(struct ata_device *dev)
2120{
2121        struct ata_port *ap = dev->link->ap;
2122        unsigned int err_mask;
2123
2124        if (!ata_log_supported(dev, ATA_LOG_NCQ_SEND_RECV)) {
2125                ata_dev_warn(dev, "NCQ Send/Recv Log not supported\n");
2126                return;
2127        }
2128        err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_SEND_RECV,
2129                                     0, ap->sector_buf, 1);
2130        if (err_mask) {
2131                ata_dev_dbg(dev,
2132                            "failed to get NCQ Send/Recv Log Emask 0x%x\n",
2133                            err_mask);
2134        } else {
2135                u8 *cmds = dev->ncq_send_recv_cmds;
2136
2137                dev->flags |= ATA_DFLAG_NCQ_SEND_RECV;
2138                memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_SEND_RECV_SIZE);
2139
2140                if (dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM) {
2141                        ata_dev_dbg(dev, "disabling queued TRIM support\n");
2142                        cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &=
2143                                ~ATA_LOG_NCQ_SEND_RECV_DSM_TRIM;
2144                }
2145        }
2146}
2147
2148static void ata_dev_config_ncq_non_data(struct ata_device *dev)
2149{
2150        struct ata_port *ap = dev->link->ap;
2151        unsigned int err_mask;
2152
2153        if (!ata_log_supported(dev, ATA_LOG_NCQ_NON_DATA)) {
2154                ata_dev_warn(dev,
2155                             "NCQ Send/Recv Log not supported\n");
2156                return;
2157        }
2158        err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_NON_DATA,
2159                                     0, ap->sector_buf, 1);
2160        if (err_mask) {
2161                ata_dev_dbg(dev,
2162                            "failed to get NCQ Non-Data Log Emask 0x%x\n",
2163                            err_mask);
2164        } else {
2165                u8 *cmds = dev->ncq_non_data_cmds;
2166
2167                memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_NON_DATA_SIZE);
2168        }
2169}
2170
2171static void ata_dev_config_ncq_prio(struct ata_device *dev)
2172{
2173        struct ata_port *ap = dev->link->ap;
2174        unsigned int err_mask;
2175
2176        if (!(dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLE)) {
2177                dev->flags &= ~ATA_DFLAG_NCQ_PRIO;
2178                return;
2179        }
2180
2181        err_mask = ata_read_log_page(dev,
2182                                     ATA_LOG_IDENTIFY_DEVICE,
2183                                     ATA_LOG_SATA_SETTINGS,
2184                                     ap->sector_buf,
2185                                     1);
2186        if (err_mask) {
2187                ata_dev_dbg(dev,
2188                            "failed to get Identify Device data, Emask 0x%x\n",
2189                            err_mask);
2190                return;
2191        }
2192
2193        if (ap->sector_buf[ATA_LOG_NCQ_PRIO_OFFSET] & BIT(3)) {
2194                dev->flags |= ATA_DFLAG_NCQ_PRIO;
2195        } else {
2196                dev->flags &= ~ATA_DFLAG_NCQ_PRIO;
2197                ata_dev_dbg(dev, "SATA page does not support priority\n");
2198        }
2199
2200}
2201
2202static int ata_dev_config_ncq(struct ata_device *dev,
2203                               char *desc, size_t desc_sz)
2204{
2205        struct ata_port *ap = dev->link->ap;
2206        int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
2207        unsigned int err_mask;
2208        char *aa_desc = "";
2209
2210        if (!ata_id_has_ncq(dev->id)) {
2211                desc[0] = '\0';
2212                return 0;
2213        }
2214        if (!IS_ENABLED(CONFIG_SATA_HOST))
2215                return 0;
2216        if (dev->horkage & ATA_HORKAGE_NONCQ) {
2217                snprintf(desc, desc_sz, "NCQ (not used)");
2218                return 0;
2219        }
2220        if (ap->flags & ATA_FLAG_NCQ) {
2221                hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE);
2222                dev->flags |= ATA_DFLAG_NCQ;
2223        }
2224
2225        if (!(dev->horkage & ATA_HORKAGE_BROKEN_FPDMA_AA) &&
2226                (ap->flags & ATA_FLAG_FPDMA_AA) &&
2227                ata_id_has_fpdma_aa(dev->id)) {
2228                err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE,
2229                        SATA_FPDMA_AA);
2230                if (err_mask) {
2231                        ata_dev_err(dev,
2232                                    "failed to enable AA (error_mask=0x%x)\n",
2233                                    err_mask);
2234                        if (err_mask != AC_ERR_DEV) {
2235                                dev->horkage |= ATA_HORKAGE_BROKEN_FPDMA_AA;
2236                                return -EIO;
2237                        }
2238                } else
2239                        aa_desc = ", AA";
2240        }
2241
2242        if (hdepth >= ddepth)
2243                snprintf(desc, desc_sz, "NCQ (depth %d)%s", ddepth, aa_desc);
2244        else
2245                snprintf(desc, desc_sz, "NCQ (depth %d/%d)%s", hdepth,
2246                        ddepth, aa_desc);
2247
2248        if ((ap->flags & ATA_FLAG_FPDMA_AUX)) {
2249                if (ata_id_has_ncq_send_and_recv(dev->id))
2250                        ata_dev_config_ncq_send_recv(dev);
2251                if (ata_id_has_ncq_non_data(dev->id))
2252                        ata_dev_config_ncq_non_data(dev);
2253                if (ata_id_has_ncq_prio(dev->id))
2254                        ata_dev_config_ncq_prio(dev);
2255        }
2256
2257        return 0;
2258}
2259
2260static void ata_dev_config_sense_reporting(struct ata_device *dev)
2261{
2262        unsigned int err_mask;
2263
2264        if (!ata_id_has_sense_reporting(dev->id))
2265                return;
2266
2267        if (ata_id_sense_reporting_enabled(dev->id))
2268                return;
2269
2270        err_mask = ata_dev_set_feature(dev, SETFEATURE_SENSE_DATA, 0x1);
2271        if (err_mask) {
2272                ata_dev_dbg(dev,
2273                            "failed to enable Sense Data Reporting, Emask 0x%x\n",
2274                            err_mask);
2275        }
2276}
2277
2278static void ata_dev_config_zac(struct ata_device *dev)
2279{
2280        struct ata_port *ap = dev->link->ap;
2281        unsigned int err_mask;
2282        u8 *identify_buf = ap->sector_buf;
2283
2284        dev->zac_zones_optimal_open = U32_MAX;
2285        dev->zac_zones_optimal_nonseq = U32_MAX;
2286        dev->zac_zones_max_open = U32_MAX;
2287
2288        /*
2289         * Always set the 'ZAC' flag for Host-managed devices.
2290         */
2291        if (dev->class == ATA_DEV_ZAC)
2292                dev->flags |= ATA_DFLAG_ZAC;
2293        else if (ata_id_zoned_cap(dev->id) == 0x01)
2294                /*
2295                 * Check for host-aware devices.
2296                 */
2297                dev->flags |= ATA_DFLAG_ZAC;
2298
2299        if (!(dev->flags & ATA_DFLAG_ZAC))
2300                return;
2301
2302        if (!ata_identify_page_supported(dev, ATA_LOG_ZONED_INFORMATION)) {
2303                ata_dev_warn(dev,
2304                             "ATA Zoned Information Log not supported\n");
2305                return;
2306        }
2307
2308        /*
2309         * Read IDENTIFY DEVICE data log, page 9 (Zoned-device information)
2310         */
2311        err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
2312                                     ATA_LOG_ZONED_INFORMATION,
2313                                     identify_buf, 1);
2314        if (!err_mask) {
2315                u64 zoned_cap, opt_open, opt_nonseq, max_open;
2316
2317                zoned_cap = get_unaligned_le64(&identify_buf[8]);
2318                if ((zoned_cap >> 63))
2319                        dev->zac_zoned_cap = (zoned_cap & 1);
2320                opt_open = get_unaligned_le64(&identify_buf[24]);
2321                if ((opt_open >> 63))
2322                        dev->zac_zones_optimal_open = (u32)opt_open;
2323                opt_nonseq = get_unaligned_le64(&identify_buf[32]);
2324                if ((opt_nonseq >> 63))
2325                        dev->zac_zones_optimal_nonseq = (u32)opt_nonseq;
2326                max_open = get_unaligned_le64(&identify_buf[40]);
2327                if ((max_open >> 63))
2328                        dev->zac_zones_max_open = (u32)max_open;
2329        }
2330}
2331
2332static void ata_dev_config_trusted(struct ata_device *dev)
2333{
2334        struct ata_port *ap = dev->link->ap;
2335        u64 trusted_cap;
2336        unsigned int err;
2337
2338        if (!ata_id_has_trusted(dev->id))
2339                return;
2340
2341        if (!ata_identify_page_supported(dev, ATA_LOG_SECURITY)) {
2342                ata_dev_warn(dev,
2343                             "Security Log not supported\n");
2344                return;
2345        }
2346
2347        err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, ATA_LOG_SECURITY,
2348                        ap->sector_buf, 1);
2349        if (err) {
2350                ata_dev_dbg(dev,
2351                            "failed to read Security Log, Emask 0x%x\n", err);
2352                return;
2353        }
2354
2355        trusted_cap = get_unaligned_le64(&ap->sector_buf[40]);
2356        if (!(trusted_cap & (1ULL << 63))) {
2357                ata_dev_dbg(dev,
2358                            "Trusted Computing capability qword not valid!\n");
2359                return;
2360        }
2361
2362        if (trusted_cap & (1 << 0))
2363                dev->flags |= ATA_DFLAG_TRUSTED;
2364}
2365
2366/**
2367 *      ata_dev_configure - Configure the specified ATA/ATAPI device
2368 *      @dev: Target device to configure
2369 *
2370 *      Configure @dev according to @dev->id.  Generic and low-level
2371 *      driver specific fixups are also applied.
2372 *
2373 *      LOCKING:
2374 *      Kernel thread context (may sleep)
2375 *
2376 *      RETURNS:
2377 *      0 on success, -errno otherwise
2378 */
2379int ata_dev_configure(struct ata_device *dev)
2380{
2381        struct ata_port *ap = dev->link->ap;
2382        struct ata_eh_context *ehc = &dev->link->eh_context;
2383        int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
2384        const u16 *id = dev->id;
2385        unsigned long xfer_mask;
2386        unsigned int err_mask;
2387        char revbuf[7];         /* XYZ-99\0 */
2388        char fwrevbuf[ATA_ID_FW_REV_LEN+1];
2389        char modelbuf[ATA_ID_PROD_LEN+1];
2390        int rc;
2391
2392        if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
2393                ata_dev_info(dev, "%s: ENTER/EXIT -- nodev\n", __func__);
2394                return 0;
2395        }
2396
2397        if (ata_msg_probe(ap))
2398                ata_dev_dbg(dev, "%s: ENTER\n", __func__);
2399
2400        /* set horkage */
2401        dev->horkage |= ata_dev_blacklisted(dev);
2402        ata_force_horkage(dev);
2403
2404        if (dev->horkage & ATA_HORKAGE_DISABLE) {
2405                ata_dev_info(dev, "unsupported device, disabling\n");
2406                ata_dev_disable(dev);
2407                return 0;
2408        }
2409
2410        if ((!atapi_enabled || (ap->flags & ATA_FLAG_NO_ATAPI)) &&
2411            dev->class == ATA_DEV_ATAPI) {
2412                ata_dev_warn(dev, "WARNING: ATAPI is %s, device ignored\n",
2413                             atapi_enabled ? "not supported with this driver"
2414                             : "disabled");
2415                ata_dev_disable(dev);
2416                return 0;
2417        }
2418
2419        rc = ata_do_link_spd_horkage(dev);
2420        if (rc)
2421                return rc;
2422
2423        /* some WD SATA-1 drives have issues with LPM, turn on NOLPM for them */
2424        if ((dev->horkage & ATA_HORKAGE_WD_BROKEN_LPM) &&
2425            (id[ATA_ID_SATA_CAPABILITY] & 0xe) == 0x2)
2426                dev->horkage |= ATA_HORKAGE_NOLPM;
2427
2428        if (ap->flags & ATA_FLAG_NO_LPM)
2429                dev->horkage |= ATA_HORKAGE_NOLPM;
2430
2431        if (dev->horkage & ATA_HORKAGE_NOLPM) {
2432                ata_dev_warn(dev, "LPM support broken, forcing max_power\n");
2433                dev->link->ap->target_lpm_policy = ATA_LPM_MAX_POWER;
2434        }
2435
2436        /* let ACPI work its magic */
2437        rc = ata_acpi_on_devcfg(dev);
2438        if (rc)
2439                return rc;
2440
2441        /* massage HPA, do it early as it might change IDENTIFY data */
2442        rc = ata_hpa_resize(dev);
2443        if (rc)
2444                return rc;
2445
2446        /* print device capabilities */
2447        if (ata_msg_probe(ap))
2448                ata_dev_dbg(dev,
2449                            "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
2450                            "85:%04x 86:%04x 87:%04x 88:%04x\n",
2451                            __func__,
2452                            id[49], id[82], id[83], id[84],
2453                            id[85], id[86], id[87], id[88]);
2454
2455        /* initialize to-be-configured parameters */
2456        dev->flags &= ~ATA_DFLAG_CFG_MASK;
2457        dev->max_sectors = 0;
2458        dev->cdb_len = 0;
2459        dev->n_sectors = 0;
2460        dev->cylinders = 0;
2461        dev->heads = 0;
2462        dev->sectors = 0;
2463        dev->multi_count = 0;
2464
2465        /*
2466         * common ATA, ATAPI feature tests
2467         */
2468
2469        /* find max transfer mode; for printk only */
2470        xfer_mask = ata_id_xfermask(id);
2471
2472        if (ata_msg_probe(ap))
2473                ata_dump_id(id);
2474
2475        /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */
2476        ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
2477                        sizeof(fwrevbuf));
2478
2479        ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
2480                        sizeof(modelbuf));
2481
2482        /* ATA-specific feature tests */
2483        if (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ZAC) {
2484                if (ata_id_is_cfa(id)) {
2485                        /* CPRM may make this media unusable */
2486                        if (id[ATA_ID_CFA_KEY_MGMT] & 1)
2487                                ata_dev_warn(dev,
2488        "supports DRM functions and may not be fully accessible\n");
2489                        snprintf(revbuf, 7, "CFA");
2490                } else {
2491                        snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
2492                        /* Warn the user if the device has TPM extensions */
2493                        if (ata_id_has_tpm(id))
2494                                ata_dev_warn(dev,
2495        "supports DRM functions and may not be fully accessible\n");
2496                }
2497
2498                dev->n_sectors = ata_id_n_sectors(id);
2499
2500                /* get current R/W Multiple count setting */
2501                if ((dev->id[47] >> 8) == 0x80 && (dev->id[59] & 0x100)) {
2502                        unsigned int max = dev->id[47] & 0xff;
2503                        unsigned int cnt = dev->id[59] & 0xff;
2504                        /* only recognize/allow powers of two here */
2505                        if (is_power_of_2(max) && is_power_of_2(cnt))
2506                                if (cnt <= max)
2507                                        dev->multi_count = cnt;
2508                }
2509
2510                if (ata_id_has_lba(id)) {
2511                        const char *lba_desc;
2512                        char ncq_desc[24];
2513
2514                        lba_desc = "LBA";
2515                        dev->flags |= ATA_DFLAG_LBA;
2516                        if (ata_id_has_lba48(id)) {
2517                                dev->flags |= ATA_DFLAG_LBA48;
2518                                lba_desc = "LBA48";
2519
2520                                if (dev->n_sectors >= (1UL << 28) &&
2521                                    ata_id_has_flush_ext(id))
2522                                        dev->flags |= ATA_DFLAG_FLUSH_EXT;
2523                        }
2524
2525                        /* config NCQ */
2526                        rc = ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
2527                        if (rc)
2528                                return rc;
2529
2530                        /* print device info to dmesg */
2531                        if (ata_msg_drv(ap) && print_info) {
2532                                ata_dev_info(dev, "%s: %s, %s, max %s\n",
2533                                             revbuf, modelbuf, fwrevbuf,
2534                                             ata_mode_string(xfer_mask));
2535                                ata_dev_info(dev,
2536                                             "%llu sectors, multi %u: %s %s\n",
2537                                        (unsigned long long)dev->n_sectors,
2538                                        dev->multi_count, lba_desc, ncq_desc);
2539                        }
2540                } else {
2541                        /* CHS */
2542
2543                        /* Default translation */
2544                        dev->cylinders  = id[1];
2545                        dev->heads      = id[3];
2546                        dev->sectors    = id[6];
2547
2548                        if (ata_id_current_chs_valid(id)) {
2549                                /* Current CHS translation is valid. */
2550                                dev->cylinders = id[54];
2551                                dev->heads     = id[55];
2552                                dev->sectors   = id[56];
2553                        }
2554
2555                        /* print device info to dmesg */
2556                        if (ata_msg_drv(ap) && print_info) {
2557                                ata_dev_info(dev, "%s: %s, %s, max %s\n",
2558                                             revbuf,    modelbuf, fwrevbuf,
2559                                             ata_mode_string(xfer_mask));
2560                                ata_dev_info(dev,
2561                                             "%llu sectors, multi %u, CHS %u/%u/%u\n",
2562                                             (unsigned long long)dev->n_sectors,
2563                                             dev->multi_count, dev->cylinders,
2564                                             dev->heads, dev->sectors);
2565                        }
2566                }
2567
2568                /* Check and mark DevSlp capability. Get DevSlp timing variables
2569                 * from SATA Settings page of Identify Device Data Log.
2570                 */
2571                if (ata_id_has_devslp(dev->id)) {
2572                        u8 *sata_setting = ap->sector_buf;
2573                        int i, j;
2574
2575                        dev->flags |= ATA_DFLAG_DEVSLP;
2576                        err_mask = ata_read_log_page(dev,
2577                                                     ATA_LOG_IDENTIFY_DEVICE,
2578                                                     ATA_LOG_SATA_SETTINGS,
2579                                                     sata_setting,
2580                                                     1);
2581                        if (err_mask)
2582                                ata_dev_dbg(dev,
2583                                            "failed to get Identify Device Data, Emask 0x%x\n",
2584                                            err_mask);
2585                        else
2586                                for (i = 0; i < ATA_LOG_DEVSLP_SIZE; i++) {
2587                                        j = ATA_LOG_DEVSLP_OFFSET + i;
2588                                        dev->devslp_timing[i] = sata_setting[j];
2589                                }
2590                }
2591                ata_dev_config_sense_reporting(dev);
2592                ata_dev_config_zac(dev);
2593                ata_dev_config_trusted(dev);
2594                dev->cdb_len = 32;
2595        }
2596
2597        /* ATAPI-specific feature tests */
2598        else if (dev->class == ATA_DEV_ATAPI) {
2599                const char *cdb_intr_string = "";
2600                const char *atapi_an_string = "";
2601                const char *dma_dir_string = "";
2602                u32 sntf;
2603
2604                rc = atapi_cdb_len(id);
2605                if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
2606                        if (ata_msg_warn(ap))
2607                                ata_dev_warn(dev, "unsupported CDB len\n");
2608                        rc = -EINVAL;
2609                        goto err_out_nosup;
2610                }
2611                dev->cdb_len = (unsigned int) rc;
2612
2613                /* Enable ATAPI AN if both the host and device have
2614                 * the support.  If PMP is attached, SNTF is required
2615                 * to enable ATAPI AN to discern between PHY status
2616                 * changed notifications and ATAPI ANs.
2617                 */
2618                if (atapi_an &&
2619                    (ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
2620                    (!sata_pmp_attached(ap) ||
2621                     sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
2622                        /* issue SET feature command to turn this on */
2623                        err_mask = ata_dev_set_feature(dev,
2624                                        SETFEATURES_SATA_ENABLE, SATA_AN);
2625                        if (err_mask)
2626                                ata_dev_err(dev,
2627                                            "failed to enable ATAPI AN (err_mask=0x%x)\n",
2628                                            err_mask);
2629                        else {
2630                                dev->flags |= ATA_DFLAG_AN;
2631                                atapi_an_string = ", ATAPI AN";
2632                        }
2633                }
2634
2635                if (ata_id_cdb_intr(dev->id)) {
2636                        dev->flags |= ATA_DFLAG_CDB_INTR;
2637                        cdb_intr_string = ", CDB intr";
2638                }
2639
2640                if (atapi_dmadir || (dev->horkage & ATA_HORKAGE_ATAPI_DMADIR) || atapi_id_dmadir(dev->id)) {
2641                        dev->flags |= ATA_DFLAG_DMADIR;
2642                        dma_dir_string = ", DMADIR";
2643                }
2644
2645                if (ata_id_has_da(dev->id)) {
2646                        dev->flags |= ATA_DFLAG_DA;
2647                        zpodd_init(dev);
2648                }
2649
2650                /* print device info to dmesg */
2651                if (ata_msg_drv(ap) && print_info)
2652                        ata_dev_info(dev,
2653                                     "ATAPI: %s, %s, max %s%s%s%s\n",
2654                                     modelbuf, fwrevbuf,
2655                                     ata_mode_string(xfer_mask),
2656                                     cdb_intr_string, atapi_an_string,
2657                                     dma_dir_string);
2658        }
2659
2660        /* determine max_sectors */
2661        dev->max_sectors = ATA_MAX_SECTORS;
2662        if (dev->flags & ATA_DFLAG_LBA48)
2663                dev->max_sectors = ATA_MAX_SECTORS_LBA48;
2664
2665        /* Limit PATA drive on SATA cable bridge transfers to udma5,
2666           200 sectors */
2667        if (ata_dev_knobble(dev)) {
2668                if (ata_msg_drv(ap) && print_info)
2669                        ata_dev_info(dev, "applying bridge limits\n");
2670                dev->udma_mask &= ATA_UDMA5;
2671                dev->max_sectors = ATA_MAX_SECTORS;
2672        }
2673
2674        if ((dev->class == ATA_DEV_ATAPI) &&
2675            (atapi_command_packet_set(id) == TYPE_TAPE)) {
2676                dev->max_sectors = ATA_MAX_SECTORS_TAPE;
2677                dev->horkage |= ATA_HORKAGE_STUCK_ERR;
2678        }
2679
2680        if (dev->horkage & ATA_HORKAGE_MAX_SEC_128)
2681                dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
2682                                         dev->max_sectors);
2683
2684        if (dev->horkage & ATA_HORKAGE_MAX_SEC_1024)
2685                dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_1024,
2686                                         dev->max_sectors);
2687
2688        if (dev->horkage & ATA_HORKAGE_MAX_SEC_LBA48)
2689                dev->max_sectors = ATA_MAX_SECTORS_LBA48;
2690
2691        if (ap->ops->dev_config)
2692                ap->ops->dev_config(dev);
2693
2694        if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) {
2695                /* Let the user know. We don't want to disallow opens for
2696                   rescue purposes, or in case the vendor is just a blithering
2697                   idiot. Do this after the dev_config call as some controllers
2698                   with buggy firmware may want to avoid reporting false device
2699                   bugs */
2700
2701                if (print_info) {
2702                        ata_dev_warn(dev,
2703"Drive reports diagnostics failure. This may indicate a drive\n");
2704                        ata_dev_warn(dev,
2705"fault or invalid emulation. Contact drive vendor for information.\n");
2706                }
2707        }
2708
2709        if ((dev->horkage & ATA_HORKAGE_FIRMWARE_WARN) && print_info) {
2710                ata_dev_warn(dev, "WARNING: device requires firmware update to be fully functional\n");
2711                ata_dev_warn(dev, "         contact the vendor or visit http://ata.wiki.kernel.org\n");
2712        }
2713
2714        return 0;
2715
2716err_out_nosup:
2717        if (ata_msg_probe(ap))
2718                ata_dev_dbg(dev, "%s: EXIT, err\n", __func__);
2719        return rc;
2720}
2721
2722/**
2723 *      ata_cable_40wire        -       return 40 wire cable type
2724 *      @ap: port
2725 *
2726 *      Helper method for drivers which want to hardwire 40 wire cable
2727 *      detection.
2728 */
2729
2730int ata_cable_40wire(struct ata_port *ap)
2731{
2732        return ATA_CBL_PATA40;
2733}
2734EXPORT_SYMBOL_GPL(ata_cable_40wire);
2735
2736/**
2737 *      ata_cable_80wire        -       return 80 wire cable type
2738 *      @ap: port
2739 *
2740 *      Helper method for drivers which want to hardwire 80 wire cable
2741 *      detection.
2742 */
2743
2744int ata_cable_80wire(struct ata_port *ap)
2745{
2746        return ATA_CBL_PATA80;
2747}
2748EXPORT_SYMBOL_GPL(ata_cable_80wire);
2749
2750/**
2751 *      ata_cable_unknown       -       return unknown PATA cable.
2752 *      @ap: port
2753 *
2754 *      Helper method for drivers which have no PATA cable detection.
2755 */
2756
2757int ata_cable_unknown(struct ata_port *ap)
2758{
2759        return ATA_CBL_PATA_UNK;
2760}
2761EXPORT_SYMBOL_GPL(ata_cable_unknown);
2762
2763/**
2764 *      ata_cable_ignore        -       return ignored PATA cable.
2765 *      @ap: port
2766 *
2767 *      Helper method for drivers which don't use cable type to limit
2768 *      transfer mode.
2769 */
2770int ata_cable_ignore(struct ata_port *ap)
2771{
2772        return ATA_CBL_PATA_IGN;
2773}
2774EXPORT_SYMBOL_GPL(ata_cable_ignore);
2775
2776/**
2777 *      ata_cable_sata  -       return SATA cable type
2778 *      @ap: port
2779 *
2780 *      Helper method for drivers which have SATA cables
2781 */
2782
2783int ata_cable_sata(struct ata_port *ap)
2784{
2785        return ATA_CBL_SATA;
2786}
2787EXPORT_SYMBOL_GPL(ata_cable_sata);
2788
2789/**
2790 *      ata_bus_probe - Reset and probe ATA bus
2791 *      @ap: Bus to probe
2792 *
2793 *      Master ATA bus probing function.  Initiates a hardware-dependent
2794 *      bus reset, then attempts to identify any devices found on
2795 *      the bus.
2796 *
2797 *      LOCKING:
2798 *      PCI/etc. bus probe sem.
2799 *
2800 *      RETURNS:
2801 *      Zero on success, negative errno otherwise.
2802 */
2803
2804int ata_bus_probe(struct ata_port *ap)
2805{
2806        unsigned int classes[ATA_MAX_DEVICES];
2807        int tries[ATA_MAX_DEVICES];
2808        int rc;
2809        struct ata_device *dev;
2810
2811        ata_for_each_dev(dev, &ap->link, ALL)
2812                tries[dev->devno] = ATA_PROBE_MAX_TRIES;
2813
2814 retry:
2815        ata_for_each_dev(dev, &ap->link, ALL) {
2816                /* If we issue an SRST then an ATA drive (not ATAPI)
2817                 * may change configuration and be in PIO0 timing. If
2818                 * we do a hard reset (or are coming from power on)
2819                 * this is true for ATA or ATAPI. Until we've set a
2820                 * suitable controller mode we should not touch the
2821                 * bus as we may be talking too fast.
2822                 */
2823                dev->pio_mode = XFER_PIO_0;
2824                dev->dma_mode = 0xff;
2825
2826                /* If the controller has a pio mode setup function
2827                 * then use it to set the chipset to rights. Don't
2828                 * touch the DMA setup as that will be dealt with when
2829                 * configuring devices.
2830                 */
2831                if (ap->ops->set_piomode)
2832                        ap->ops->set_piomode(ap, dev);
2833        }
2834
2835        /* reset and determine device classes */
2836        ap->ops->phy_reset(ap);
2837
2838        ata_for_each_dev(dev, &ap->link, ALL) {
2839                if (dev->class != ATA_DEV_UNKNOWN)
2840                        classes[dev->devno] = dev->class;
2841                else
2842                        classes[dev->devno] = ATA_DEV_NONE;
2843
2844                dev->class = ATA_DEV_UNKNOWN;
2845        }
2846
2847        /* read IDENTIFY page and configure devices. We have to do the identify
2848           specific sequence bass-ackwards so that PDIAG- is released by
2849           the slave device */
2850
2851        ata_for_each_dev(dev, &ap->link, ALL_REVERSE) {
2852                if (tries[dev->devno])
2853                        dev->class = classes[dev->devno];
2854
2855                if (!ata_dev_enabled(dev))
2856                        continue;
2857
2858                rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET,
2859                                     dev->id);
2860                if (rc)
2861                        goto fail;
2862        }
2863
2864        /* Now ask for the cable type as PDIAG- should have been released */
2865        if (ap->ops->cable_detect)
2866                ap->cbl = ap->ops->cable_detect(ap);
2867
2868        /* We may have SATA bridge glue hiding here irrespective of
2869         * the reported cable types and sensed types.  When SATA
2870         * drives indicate we have a bridge, we don't know which end
2871         * of the link the bridge is which is a problem.
2872         */
2873        ata_for_each_dev(dev, &ap->link, ENABLED)
2874                if (ata_id_is_sata(dev->id))
2875                        ap->cbl = ATA_CBL_SATA;
2876
2877        /* After the identify sequence we can now set up the devices. We do
2878           this in the normal order so that the user doesn't get confused */
2879
2880        ata_for_each_dev(dev, &ap->link, ENABLED) {
2881                ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;
2882                rc = ata_dev_configure(dev);
2883                ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
2884                if (rc)
2885                        goto fail;
2886        }
2887
2888        /* configure transfer mode */
2889        rc = ata_set_mode(&ap->link, &dev);
2890        if (rc)
2891                goto fail;
2892
2893        ata_for_each_dev(dev, &ap->link, ENABLED)
2894                return 0;
2895
2896        return -ENODEV;
2897
2898 fail:
2899        tries[dev->devno]--;
2900
2901        switch (rc) {
2902        case -EINVAL:
2903                /* eeek, something went very wrong, give up */
2904                tries[dev->devno] = 0;
2905                break;
2906
2907        case -ENODEV:
2908                /* give it just one more chance */
2909                tries[dev->devno] = min(tries[dev->devno], 1);
2910                fallthrough;
2911        case -EIO:
2912                if (tries[dev->devno] == 1) {
2913                        /* This is the last chance, better to slow
2914                         * down than lose it.
2915                         */
2916                        sata_down_spd_limit(&ap->link, 0);
2917                        ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
2918                }
2919        }
2920
2921        if (!tries[dev->devno])
2922                ata_dev_disable(dev);
2923
2924        goto retry;
2925}
2926
2927/**
2928 *      sata_print_link_status - Print SATA link status
2929 *      @link: SATA link to printk link status about
2930 *
2931 *      This function prints link speed and status of a SATA link.
2932 *
2933 *      LOCKING:
2934 *      None.
2935 */
2936static void sata_print_link_status(struct ata_link *link)
2937{
2938        u32 sstatus, scontrol, tmp;
2939
2940        if (sata_scr_read(link, SCR_STATUS, &sstatus))
2941                return;
2942        sata_scr_read(link, SCR_CONTROL, &scontrol);
2943
2944        if (ata_phys_link_online(link)) {
2945                tmp = (sstatus >> 4) & 0xf;
2946                ata_link_info(link, "SATA link up %s (SStatus %X SControl %X)\n",
2947                              sata_spd_string(tmp), sstatus, scontrol);
2948        } else {
2949                ata_link_info(link, "SATA link down (SStatus %X SControl %X)\n",
2950                              sstatus, scontrol);
2951        }
2952}
2953
2954/**
2955 *      ata_dev_pair            -       return other device on cable
2956 *      @adev: device
2957 *
2958 *      Obtain the other device on the same cable, or if none is
2959 *      present NULL is returned
2960 */
2961
2962struct ata_device *ata_dev_pair(struct ata_device *adev)
2963{
2964        struct ata_link *link = adev->link;
2965        struct ata_device *pair = &link->device[1 - adev->devno];
2966        if (!ata_dev_enabled(pair))
2967                return NULL;
2968        return pair;
2969}
2970EXPORT_SYMBOL_GPL(ata_dev_pair);
2971
2972/**
2973 *      sata_down_spd_limit - adjust SATA spd limit downward
2974 *      @link: Link to adjust SATA spd limit for
2975 *      @spd_limit: Additional limit
2976 *
2977 *      Adjust SATA spd limit of @link downward.  Note that this
2978 *      function only adjusts the limit.  The change must be applied
2979 *      using sata_set_spd().
2980 *
2981 *      If @spd_limit is non-zero, the speed is limited to equal to or
2982 *      lower than @spd_limit if such speed is supported.  If
2983 *      @spd_limit is slower than any supported speed, only the lowest
2984 *      supported speed is allowed.
2985 *
2986 *      LOCKING:
2987 *      Inherited from caller.
2988 *
2989 *      RETURNS:
2990 *      0 on success, negative errno on failure
2991 */
2992int sata_down_spd_limit(struct ata_link *link, u32 spd_limit)
2993{
2994        u32 sstatus, spd, mask;
2995        int rc, bit;
2996
2997        if (!sata_scr_valid(link))
2998                return -EOPNOTSUPP;
2999
3000        /* If SCR can be read, use it to determine the current SPD.
3001         * If not, use cached value in link->sata_spd.
3002         */
3003        rc = sata_scr_read(link, SCR_STATUS, &sstatus);
3004        if (rc == 0 && ata_sstatus_online(sstatus))
3005                spd = (sstatus >> 4) & 0xf;
3006        else
3007                spd = link->sata_spd;
3008
3009        mask = link->sata_spd_limit;
3010        if (mask <= 1)
3011                return -EINVAL;
3012
3013        /* unconditionally mask off the highest bit */
3014        bit = fls(mask) - 1;
3015        mask &= ~(1 << bit);
3016
3017        /*
3018         * Mask off all speeds higher than or equal to the current one.  At
3019         * this point, if current SPD is not available and we previously
3020         * recorded the link speed from SStatus, the driver has already
3021         * masked off the highest bit so mask should already be 1 or 0.
3022         * Otherwise, we should not force 1.5Gbps on a link where we have
3023         * not previously recorded speed from SStatus.  Just return in this
3024         * case.
3025         */
3026        if (spd > 1)
3027                mask &= (1 << (spd - 1)) - 1;
3028        else
3029                return -EINVAL;
3030
3031        /* were we already at the bottom? */
3032        if (!mask)
3033                return -EINVAL;
3034
3035        if (spd_limit) {
3036                if (mask & ((1 << spd_limit) - 1))
3037                        mask &= (1 << spd_limit) - 1;
3038                else {
3039                        bit = ffs(mask) - 1;
3040                        mask = 1 << bit;
3041                }
3042        }
3043
3044        link->sata_spd_limit = mask;
3045
3046        ata_link_warn(link, "limiting SATA link speed to %s\n",
3047                      sata_spd_string(fls(mask)));
3048
3049        return 0;
3050}
3051
3052#ifdef CONFIG_ATA_ACPI
3053/**
3054 *      ata_timing_cycle2mode - find xfer mode for the specified cycle duration
3055 *      @xfer_shift: ATA_SHIFT_* value for transfer type to examine.
3056 *      @cycle: cycle duration in ns
3057 *
3058 *      Return matching xfer mode for @cycle.  The returned mode is of
3059 *      the transfer type specified by @xfer_shift.  If @cycle is too
3060 *      slow for @xfer_shift, 0xff is returned.  If @cycle is faster
3061 *      than the fastest known mode, the fasted mode is returned.
3062 *
3063 *      LOCKING:
3064 *      None.
3065 *
3066 *      RETURNS:
3067 *      Matching xfer_mode, 0xff if no match found.
3068 */
3069u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle)
3070{
3071        u8 base_mode = 0xff, last_mode = 0xff;
3072        const struct ata_xfer_ent *ent;
3073        const struct ata_timing *t;
3074
3075        for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
3076                if (ent->shift == xfer_shift)
3077                        base_mode = ent->base;
3078
3079        for (t = ata_timing_find_mode(base_mode);
3080             t && ata_xfer_mode2shift(t->mode) == xfer_shift; t++) {
3081                unsigned short this_cycle;
3082
3083                switch (xfer_shift) {
3084                case ATA_SHIFT_PIO:
3085                case ATA_SHIFT_MWDMA:
3086                        this_cycle = t->cycle;
3087                        break;
3088                case ATA_SHIFT_UDMA:
3089                        this_cycle = t->udma;
3090                        break;
3091                default:
3092                        return 0xff;
3093                }
3094
3095                if (cycle > this_cycle)
3096                        break;
3097
3098                last_mode = t->mode;
3099        }
3100
3101        return last_mode;
3102}
3103#endif
3104
3105/**
3106 *      ata_down_xfermask_limit - adjust dev xfer masks downward
3107 *      @dev: Device to adjust xfer masks
3108 *      @sel: ATA_DNXFER_* selector
3109 *
3110 *      Adjust xfer masks of @dev downward.  Note that this function
3111 *      does not apply the change.  Invoking ata_set_mode() afterwards
3112 *      will apply the limit.
3113 *
3114 *      LOCKING:
3115 *      Inherited from caller.
3116 *
3117 *      RETURNS:
3118 *      0 on success, negative errno on failure
3119 */
3120int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
3121{
3122        char buf[32];
3123        unsigned long orig_mask, xfer_mask;
3124        unsigned long pio_mask, mwdma_mask, udma_mask;
3125        int quiet, highbit;
3126
3127        quiet = !!(sel & ATA_DNXFER_QUIET);
3128        sel &= ~ATA_DNXFER_QUIET;
3129
3130        xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask,
3131                                                  dev->mwdma_mask,
3132                                                  dev->udma_mask);
3133        ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask);
3134
3135        switch (sel) {
3136        case ATA_DNXFER_PIO:
3137                highbit = fls(pio_mask) - 1;
3138                pio_mask &= ~(1 << highbit);
3139                break;
3140
3141        case ATA_DNXFER_DMA:
3142                if (udma_mask) {
3143                        highbit = fls(udma_mask) - 1;
3144                        udma_mask &= ~(1 << highbit);
3145                        if (!udma_mask)
3146                                return -ENOENT;
3147                } else if (mwdma_mask) {
3148                        highbit = fls(mwdma_mask) - 1;
3149                        mwdma_mask &= ~(1 << highbit);
3150                        if (!mwdma_mask)
3151                                return -ENOENT;
3152                }
3153                break;
3154
3155        case ATA_DNXFER_40C:
3156                udma_mask &= ATA_UDMA_MASK_40C;
3157                break;
3158
3159        case ATA_DNXFER_FORCE_PIO0:
3160                pio_mask &= 1;
3161                fallthrough;
3162        case ATA_DNXFER_FORCE_PIO:
3163                mwdma_mask = 0;
3164                udma_mask = 0;
3165                break;
3166
3167        default:
3168                BUG();
3169        }
3170
3171        xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
3172
3173        if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask)
3174                return -ENOENT;
3175
3176        if (!quiet) {
3177                if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA))
3178                        snprintf(buf, sizeof(buf), "%s:%s",
3179                                 ata_mode_string(xfer_mask),
3180                                 ata_mode_string(xfer_mask & ATA_MASK_PIO));
3181                else
3182                        snprintf(buf, sizeof(buf), "%s",
3183                                 ata_mode_string(xfer_mask));
3184
3185                ata_dev_warn(dev, "limiting speed to %s\n", buf);
3186        }
3187
3188        ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
3189                            &dev->udma_mask);
3190
3191        return 0;
3192}
3193
3194static int ata_dev_set_mode(struct ata_device *dev)
3195{
3196        struct ata_port *ap = dev->link->ap;
3197        struct ata_eh_context *ehc = &dev->link->eh_context;
3198        const bool nosetxfer = dev->horkage & ATA_HORKAGE_NOSETXFER;
3199        const char *dev_err_whine = "";
3200        int ign_dev_err = 0;
3201        unsigned int err_mask = 0;
3202        int rc;
3203
3204        dev->flags &= ~ATA_DFLAG_PIO;
3205        if (dev->xfer_shift == ATA_SHIFT_PIO)
3206                dev->flags |= ATA_DFLAG_PIO;
3207
3208        if (nosetxfer && ap->flags & ATA_FLAG_SATA && ata_id_is_sata(dev->id))
3209                dev_err_whine = " (SET_XFERMODE skipped)";
3210        else {
3211                if (nosetxfer)
3212                        ata_dev_warn(dev,
3213                                     "NOSETXFER but PATA detected - can't "
3214                                     "skip SETXFER, might malfunction\n");
3215                err_mask = ata_dev_set_xfermode(dev);
3216        }
3217
3218        if (err_mask & ~AC_ERR_DEV)
3219                goto fail;
3220
3221        /* revalidate */
3222        ehc->i.flags |= ATA_EHI_POST_SETMODE;
3223        rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0);
3224        ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
3225        if (rc)
3226                return rc;
3227
3228        if (dev->xfer_shift == ATA_SHIFT_PIO) {
3229                /* Old CFA may refuse this command, which is just fine */
3230                if (ata_id_is_cfa(dev->id))
3231                        ign_dev_err = 1;
3232                /* Catch several broken garbage emulations plus some pre
3233                   ATA devices */
3234                if (ata_id_major_version(dev->id) == 0 &&
3235                                        dev->pio_mode <= XFER_PIO_2)
3236                        ign_dev_err = 1;
3237                /* Some very old devices and some bad newer ones fail
3238                   any kind of SET_XFERMODE request but support PIO0-2
3239                   timings and no IORDY */
3240                if (!ata_id_has_iordy(dev->id) && dev->pio_mode <= XFER_PIO_2)
3241                        ign_dev_err = 1;
3242        }
3243        /* Early MWDMA devices do DMA but don't allow DMA mode setting.
3244           Don't fail an MWDMA0 set IFF the device indicates it is in MWDMA0 */
3245        if (dev->xfer_shift == ATA_SHIFT_MWDMA &&
3246            dev->dma_mode == XFER_MW_DMA_0 &&
3247            (dev->id[63] >> 8) & 1)
3248                ign_dev_err = 1;
3249
3250        /* if the device is actually configured correctly, ignore dev err */
3251        if (dev->xfer_mode == ata_xfer_mask2mode(ata_id_xfermask(dev->id)))
3252                ign_dev_err = 1;
3253
3254        if (err_mask & AC_ERR_DEV) {
3255                if (!ign_dev_err)
3256                        goto fail;
3257                else
3258                        dev_err_whine = " (device error ignored)";
3259        }
3260
3261        DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
3262                dev->xfer_shift, (int)dev->xfer_mode);
3263
3264        if (!(ehc->i.flags & ATA_EHI_QUIET) ||
3265            ehc->i.flags & ATA_EHI_DID_HARDRESET)
3266                ata_dev_info(dev, "configured for %s%s\n",
3267                             ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)),
3268                             dev_err_whine);
3269
3270        return 0;
3271
3272 fail:
3273        ata_dev_err(dev, "failed to set xfermode (err_mask=0x%x)\n", err_mask);
3274        return -EIO;
3275}
3276
3277/**
3278 *      ata_do_set_mode - Program timings and issue SET FEATURES - XFER
3279 *      @link: link on which timings will be programmed
3280 *      @r_failed_dev: out parameter for failed device
3281 *
3282 *      Standard implementation of the function used to tune and set
3283 *      ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
3284 *      ata_dev_set_mode() fails, pointer to the failing device is
3285 *      returned in @r_failed_dev.
3286 *
3287 *      LOCKING:
3288 *      PCI/etc. bus probe sem.
3289 *
3290 *      RETURNS:
3291 *      0 on success, negative errno otherwise
3292 */
3293
3294int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3295{
3296        struct ata_port *ap = link->ap;
3297        struct ata_device *dev;
3298        int rc = 0, used_dma = 0, found = 0;
3299
3300        /* step 1: calculate xfer_mask */
3301        ata_for_each_dev(dev, link, ENABLED) {
3302                unsigned long pio_mask, dma_mask;
3303                unsigned int mode_mask;
3304
3305                mode_mask = ATA_DMA_MASK_ATA;
3306                if (dev->class == ATA_DEV_ATAPI)
3307                        mode_mask = ATA_DMA_MASK_ATAPI;
3308                else if (ata_id_is_cfa(dev->id))
3309                        mode_mask = ATA_DMA_MASK_CFA;
3310
3311                ata_dev_xfermask(dev);
3312                ata_force_xfermask(dev);
3313
3314                pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
3315
3316                if (libata_dma_mask & mode_mask)
3317                        dma_mask = ata_pack_xfermask(0, dev->mwdma_mask,
3318                                                     dev->udma_mask);
3319                else
3320                        dma_mask = 0;
3321
3322                dev->pio_mode = ata_xfer_mask2mode(pio_mask);
3323                dev->dma_mode = ata_xfer_mask2mode(dma_mask);
3324
3325                found = 1;
3326                if (ata_dma_enabled(dev))
3327                        used_dma = 1;
3328        }
3329        if (!found)
3330                goto out;
3331
3332        /* step 2: always set host PIO timings */
3333        ata_for_each_dev(dev, link, ENABLED) {
3334                if (dev->pio_mode == 0xff) {
3335                        ata_dev_warn(dev, "no PIO support\n");
3336                        rc = -EINVAL;
3337                        goto out;
3338                }
3339
3340                dev->xfer_mode = dev->pio_mode;
3341                dev->xfer_shift = ATA_SHIFT_PIO;
3342                if (ap->ops->set_piomode)
3343                        ap->ops->set_piomode(ap, dev);
3344        }
3345
3346        /* step 3: set host DMA timings */
3347        ata_for_each_dev(dev, link, ENABLED) {
3348                if (!ata_dma_enabled(dev))
3349                        continue;
3350
3351                dev->xfer_mode = dev->dma_mode;
3352                dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
3353                if (ap->ops->set_dmamode)
3354                        ap->ops->set_dmamode(ap, dev);
3355        }
3356
3357        /* step 4: update devices' xfer mode */
3358        ata_for_each_dev(dev, link, ENABLED) {
3359                rc = ata_dev_set_mode(dev);
3360                if (rc)
3361                        goto out;
3362        }
3363
3364        /* Record simplex status. If we selected DMA then the other
3365         * host channels are not permitted to do so.
3366         */
3367        if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
3368                ap->host->simplex_claimed = ap;
3369
3370 out:
3371        if (rc)
3372                *r_failed_dev = dev;
3373        return rc;
3374}
3375EXPORT_SYMBOL_GPL(ata_do_set_mode);
3376
3377/**
3378 *      ata_wait_ready - wait for link to become ready
3379 *      @link: link to be waited on
3380 *      @deadline: deadline jiffies for the operation
3381 *      @check_ready: callback to check link readiness
3382 *
3383 *      Wait for @link to become ready.  @check_ready should return
3384 *      positive number if @link is ready, 0 if it isn't, -ENODEV if
3385 *      link doesn't seem to be occupied, other errno for other error
3386 *      conditions.
3387 *
3388 *      Transient -ENODEV conditions are allowed for
3389 *      ATA_TMOUT_FF_WAIT.
3390 *
3391 *      LOCKING:
3392 *      EH context.
3393 *
3394 *      RETURNS:
3395 *      0 if @link is ready before @deadline; otherwise, -errno.
3396 */
3397int ata_wait_ready(struct ata_link *link, unsigned long deadline,
3398                   int (*check_ready)(struct ata_link *link))
3399{
3400        unsigned long start = jiffies;
3401        unsigned long nodev_deadline;
3402        int warned = 0;
3403
3404        /* choose which 0xff timeout to use, read comment in libata.h */
3405        if (link->ap->host->flags & ATA_HOST_PARALLEL_SCAN)
3406                nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT_LONG);
3407        else
3408                nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT);
3409
3410        /* Slave readiness can't be tested separately from master.  On
3411         * M/S emulation configuration, this function should be called
3412         * only on the master and it will handle both master and slave.
3413         */
3414        WARN_ON(link == link->ap->slave_link);
3415
3416        if (time_after(nodev_deadline, deadline))
3417                nodev_deadline = deadline;
3418
3419        while (1) {
3420                unsigned long now = jiffies;
3421                int ready, tmp;
3422
3423                ready = tmp = check_ready(link);
3424                if (ready > 0)
3425                        return 0;
3426
3427                /*
3428                 * -ENODEV could be transient.  Ignore -ENODEV if link
3429                 * is online.  Also, some SATA devices take a long
3430                 * time to clear 0xff after reset.  Wait for
3431                 * ATA_TMOUT_FF_WAIT[_LONG] on -ENODEV if link isn't
3432                 * offline.
3433                 *
3434                 * Note that some PATA controllers (pata_ali) explode
3435                 * if status register is read more than once when
3436                 * there's no device attached.
3437                 */
3438                if (ready == -ENODEV) {
3439                        if (ata_link_online(link))
3440                                ready = 0;
3441                        else if ((link->ap->flags & ATA_FLAG_SATA) &&
3442                                 !ata_link_offline(link) &&
3443                                 time_before(now, nodev_deadline))
3444                                ready = 0;
3445                }
3446
3447                if (ready)
3448                        return ready;
3449                if (time_after(now, deadline))
3450                        return -EBUSY;
3451
3452                if (!warned && time_after(now, start + 5 * HZ) &&
3453                    (deadline - now > 3 * HZ)) {
3454                        ata_link_warn(link,
3455                                "link is slow to respond, please be patient "
3456                                "(ready=%d)\n", tmp);
3457                        warned = 1;
3458                }
3459
3460                ata_msleep(link->ap, 50);
3461        }
3462}
3463
3464/**
3465 *      ata_wait_after_reset - wait for link to become ready after reset
3466 *      @link: link to be waited on
3467 *      @deadline: deadline jiffies for the operation
3468 *      @check_ready: callback to check link readiness
3469 *
3470 *      Wait for @link to become ready after reset.
3471 *
3472 *      LOCKING:
3473 *      EH context.
3474 *
3475 *      RETURNS:
3476 *      0 if @link is ready before @deadline; otherwise, -errno.
3477 */
3478int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
3479                                int (*check_ready)(struct ata_link *link))
3480{
3481        ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
3482
3483        return ata_wait_ready(link, deadline, check_ready);
3484}
3485EXPORT_SYMBOL_GPL(ata_wait_after_reset);
3486
3487/**
3488 *      ata_std_prereset - prepare for reset
3489 *      @link: ATA link to be reset
3490 *      @deadline: deadline jiffies for the operation
3491 *
3492 *      @link is about to be reset.  Initialize it.  Failure from
3493 *      prereset makes libata abort whole reset sequence and give up
3494 *      that port, so prereset should be best-effort.  It does its
3495 *      best to prepare for reset sequence but if things go wrong, it
3496 *      should just whine, not fail.
3497 *
3498 *      LOCKING:
3499 *      Kernel thread context (may sleep)
3500 *
3501 *      RETURNS:
3502 *      0 on success, -errno otherwise.
3503 */
3504int ata_std_prereset(struct ata_link *link, unsigned long deadline)
3505{
3506        struct ata_port *ap = link->ap;
3507        struct ata_eh_context *ehc = &link->eh_context;
3508        const unsigned long *timing = sata_ehc_deb_timing(ehc);
3509        int rc;
3510
3511        /* if we're about to do hardreset, nothing more to do */
3512        if (ehc->i.action & ATA_EH_HARDRESET)
3513                return 0;
3514
3515        /* if SATA, resume link */
3516        if (ap->flags & ATA_FLAG_SATA) {
3517                rc = sata_link_resume(link, timing, deadline);
3518                /* whine about phy resume failure but proceed */
3519                if (rc && rc != -EOPNOTSUPP)
3520                        ata_link_warn(link,
3521                                      "failed to resume link for reset (errno=%d)\n",
3522                                      rc);
3523        }
3524
3525        /* no point in trying softreset on offline link */
3526        if (ata_phys_link_offline(link))
3527                ehc->i.action &= ~ATA_EH_SOFTRESET;
3528
3529        return 0;
3530}
3531EXPORT_SYMBOL_GPL(ata_std_prereset);
3532
3533/**
3534 *      sata_std_hardreset - COMRESET w/o waiting or classification
3535 *      @link: link to reset
3536 *      @class: resulting class of attached device
3537 *      @deadline: deadline jiffies for the operation
3538 *
3539 *      Standard SATA COMRESET w/o waiting or classification.
3540 *
3541 *      LOCKING:
3542 *      Kernel thread context (may sleep)
3543 *
3544 *      RETURNS:
3545 *      0 if link offline, -EAGAIN if link online, -errno on errors.
3546 */
3547int sata_std_hardreset(struct ata_link *link, unsigned int *class,
3548                       unsigned long deadline)
3549{
3550        const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
3551        bool online;
3552        int rc;
3553
3554        /* do hardreset */
3555        rc = sata_link_hardreset(link, timing, deadline, &online, NULL);
3556        return online ? -EAGAIN : rc;
3557}
3558EXPORT_SYMBOL_GPL(sata_std_hardreset);
3559
3560/**
3561 *      ata_std_postreset - standard postreset callback
3562 *      @link: the target ata_link
3563 *      @classes: classes of attached devices
3564 *
3565 *      This function is invoked after a successful reset.  Note that
3566 *      the device might have been reset more than once using
3567 *      different reset methods before postreset is invoked.
3568 *
3569 *      LOCKING:
3570 *      Kernel thread context (may sleep)
3571 */
3572void ata_std_postreset(struct ata_link *link, unsigned int *classes)
3573{
3574        u32 serror;
3575
3576        DPRINTK("ENTER\n");
3577
3578        /* reset complete, clear SError */
3579        if (!sata_scr_read(link, SCR_ERROR, &serror))
3580                sata_scr_write(link, SCR_ERROR, serror);
3581
3582        /* print link status */
3583        sata_print_link_status(link);
3584
3585        DPRINTK("EXIT\n");
3586}
3587EXPORT_SYMBOL_GPL(ata_std_postreset);
3588
3589/**
3590 *      ata_dev_same_device - Determine whether new ID matches configured device
3591 *      @dev: device to compare against
3592 *      @new_class: class of the new device
3593 *      @new_id: IDENTIFY page of the new device
3594 *
3595 *      Compare @new_class and @new_id against @dev and determine
3596 *      whether @dev is the device indicated by @new_class and
3597 *      @new_id.
3598 *
3599 *      LOCKING:
3600 *      None.
3601 *
3602 *      RETURNS:
3603 *      1 if @dev matches @new_class and @new_id, 0 otherwise.
3604 */
3605static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
3606                               const u16 *new_id)
3607{
3608        const u16 *old_id = dev->id;
3609        unsigned char model[2][ATA_ID_PROD_LEN + 1];
3610        unsigned char serial[2][ATA_ID_SERNO_LEN + 1];
3611
3612        if (dev->class != new_class) {
3613                ata_dev_info(dev, "class mismatch %d != %d\n",
3614                             dev->class, new_class);
3615                return 0;
3616        }
3617
3618        ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0]));
3619        ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1]));
3620        ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0]));
3621        ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1]));
3622
3623        if (strcmp(model[0], model[1])) {
3624                ata_dev_info(dev, "model number mismatch '%s' != '%s'\n",
3625                             model[0], model[1]);
3626                return 0;
3627        }
3628
3629        if (strcmp(serial[0], serial[1])) {
3630                ata_dev_info(dev, "serial number mismatch '%s' != '%s'\n",
3631                             serial[0], serial[1]);
3632                return 0;
3633        }
3634
3635        return 1;
3636}
3637
3638/**
3639 *      ata_dev_reread_id - Re-read IDENTIFY data
3640 *      @dev: target ATA device
3641 *      @readid_flags: read ID flags
3642 *
3643 *      Re-read IDENTIFY page and make sure @dev is still attached to
3644 *      the port.
3645 *
3646 *      LOCKING:
3647 *      Kernel thread context (may sleep)
3648 *
3649 *      RETURNS:
3650 *      0 on success, negative errno otherwise
3651 */
3652int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
3653{
3654        unsigned int class = dev->class;
3655        u16 *id = (void *)dev->link->ap->sector_buf;
3656        int rc;
3657
3658        /* read ID data */
3659        rc = ata_dev_read_id(dev, &class, readid_flags, id);
3660        if (rc)
3661                return rc;
3662
3663        /* is the device still there? */
3664        if (!ata_dev_same_device(dev, class, id))
3665                return -ENODEV;
3666
3667        memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
3668        return 0;
3669}
3670
3671/**
3672 *      ata_dev_revalidate - Revalidate ATA device
3673 *      @dev: device to revalidate
3674 *      @new_class: new class code
3675 *      @readid_flags: read ID flags
3676 *
3677 *      Re-read IDENTIFY page, make sure @dev is still attached to the
3678 *      port and reconfigure it according to the new IDENTIFY page.
3679 *
3680 *      LOCKING:
3681 *      Kernel thread context (may sleep)
3682 *
3683 *      RETURNS:
3684 *      0 on success, negative errno otherwise
3685 */
3686int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
3687                       unsigned int readid_flags)
3688{
3689        u64 n_sectors = dev->n_sectors;
3690        u64 n_native_sectors = dev->n_native_sectors;
3691        int rc;
3692
3693        if (!ata_dev_enabled(dev))
3694                return -ENODEV;
3695
3696        /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */
3697        if (ata_class_enabled(new_class) &&
3698            new_class != ATA_DEV_ATA &&
3699            new_class != ATA_DEV_ATAPI &&
3700            new_class != ATA_DEV_ZAC &&
3701            new_class != ATA_DEV_SEMB) {
3702                ata_dev_info(dev, "class mismatch %u != %u\n",
3703                             dev->class, new_class);
3704                rc = -ENODEV;
3705                goto fail;
3706        }
3707
3708        /* re-read ID */
3709        rc = ata_dev_reread_id(dev, readid_flags);
3710        if (rc)
3711                goto fail;
3712
3713        /* configure device according to the new ID */
3714        rc = ata_dev_configure(dev);
3715        if (rc)
3716                goto fail;
3717
3718        /* verify n_sectors hasn't changed */
3719        if (dev->class != ATA_DEV_ATA || !n_sectors ||
3720            dev->n_sectors == n_sectors)
3721                return 0;
3722
3723        /* n_sectors has changed */
3724        ata_dev_warn(dev, "n_sectors mismatch %llu != %llu\n",
3725                     (unsigned long long)n_sectors,
3726                     (unsigned long long)dev->n_sectors);
3727
3728        /*
3729         * Something could have caused HPA to be unlocked
3730         * involuntarily.  If n_native_sectors hasn't changed and the
3731         * new size matches it, keep the device.
3732         */
3733        if (dev->n_native_sectors == n_native_sectors &&
3734            dev->n_sectors > n_sectors && dev->n_sectors == n_native_sectors) {
3735                ata_dev_warn(dev,
3736                             "new n_sectors matches native, probably "
3737                             "late HPA unlock, n_sectors updated\n");
3738                /* use the larger n_sectors */
3739                return 0;
3740        }
3741
3742        /*
3743         * Some BIOSes boot w/o HPA but resume w/ HPA locked.  Try
3744         * unlocking HPA in those cases.
3745         *
3746         * https://bugzilla.kernel.org/show_bug.cgi?id=15396
3747         */
3748        if (dev->n_native_sectors == n_native_sectors &&
3749            dev->n_sectors < n_sectors && n_sectors == n_native_sectors &&
3750            !(dev->horkage & ATA_HORKAGE_BROKEN_HPA)) {
3751                ata_dev_warn(dev,
3752                             "old n_sectors matches native, probably "
3753                             "late HPA lock, will try to unlock HPA\n");
3754                /* try unlocking HPA */
3755                dev->flags |= ATA_DFLAG_UNLOCK_HPA;
3756                rc = -EIO;
3757        } else
3758                rc = -ENODEV;
3759
3760        /* restore original n_[native_]sectors and fail */
3761        dev->n_native_sectors = n_native_sectors;
3762        dev->n_sectors = n_sectors;
3763 fail:
3764        ata_dev_err(dev, "revalidation failed (errno=%d)\n", rc);
3765        return rc;
3766}
3767
3768struct ata_blacklist_entry {
3769        const char *model_num;
3770        const char *model_rev;
3771        unsigned long horkage;
3772};
3773
3774static const struct ata_blacklist_entry ata_device_blacklist [] = {
3775        /* Devices with DMA related problems under Linux */
3776        { "WDC AC11000H",       NULL,           ATA_HORKAGE_NODMA },
3777        { "WDC AC22100H",       NULL,           ATA_HORKAGE_NODMA },
3778        { "WDC AC32500H",       NULL,           ATA_HORKAGE_NODMA },
3779        { "WDC AC33100H",       NULL,           ATA_HORKAGE_NODMA },
3780        { "WDC AC31600H",       NULL,           ATA_HORKAGE_NODMA },
3781        { "WDC AC32100H",       "24.09P07",     ATA_HORKAGE_NODMA },
3782        { "WDC AC23200L",       "21.10N21",     ATA_HORKAGE_NODMA },
3783        { "Compaq CRD-8241B",   NULL,           ATA_HORKAGE_NODMA },
3784        { "CRD-8400B",          NULL,           ATA_HORKAGE_NODMA },
3785        { "CRD-848[02]B",       NULL,           ATA_HORKAGE_NODMA },
3786        { "CRD-84",             NULL,           ATA_HORKAGE_NODMA },
3787        { "SanDisk SDP3B",      NULL,           ATA_HORKAGE_NODMA },
3788        { "SanDisk SDP3B-64",   NULL,           ATA_HORKAGE_NODMA },
3789        { "SANYO CD-ROM CRD",   NULL,           ATA_HORKAGE_NODMA },
3790        { "HITACHI CDR-8",      NULL,           ATA_HORKAGE_NODMA },
3791        { "HITACHI CDR-8[34]35",NULL,           ATA_HORKAGE_NODMA },
3792        { "Toshiba CD-ROM XM-6202B", NULL,      ATA_HORKAGE_NODMA },
3793        { "TOSHIBA CD-ROM XM-1702BC", NULL,     ATA_HORKAGE_NODMA },
3794        { "CD-532E-A",          NULL,           ATA_HORKAGE_NODMA },
3795        { "E-IDE CD-ROM CR-840",NULL,           ATA_HORKAGE_NODMA },
3796        { "CD-ROM Drive/F5A",   NULL,           ATA_HORKAGE_NODMA },
3797        { "WPI CDD-820",        NULL,           ATA_HORKAGE_NODMA },
3798        { "SAMSUNG CD-ROM SC-148C", NULL,       ATA_HORKAGE_NODMA },
3799        { "SAMSUNG CD-ROM SC",  NULL,           ATA_HORKAGE_NODMA },
3800        { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
3801        { "_NEC DV5800A",       NULL,           ATA_HORKAGE_NODMA },
3802        { "SAMSUNG CD-ROM SN-124", "N001",      ATA_HORKAGE_NODMA },
3803        { "Seagate STT20000A", NULL,            ATA_HORKAGE_NODMA },
3804        { " 2GB ATA Flash Disk", "ADMA428M",    ATA_HORKAGE_NODMA },
3805        { "VRFDFC22048UCHC-TE*", NULL,          ATA_HORKAGE_NODMA },
3806        /* Odd clown on sil3726/4726 PMPs */
3807        { "Config  Disk",       NULL,           ATA_HORKAGE_DISABLE },
3808
3809        /* Weird ATAPI devices */
3810        { "TORiSAN DVD-ROM DRD-N216", NULL,     ATA_HORKAGE_MAX_SEC_128 },
3811        { "QUANTUM DAT    DAT72-000", NULL,     ATA_HORKAGE_ATAPI_MOD16_DMA },
3812        { "Slimtype DVD A  DS8A8SH", NULL,      ATA_HORKAGE_MAX_SEC_LBA48 },
3813        { "Slimtype DVD A  DS8A9SH", NULL,      ATA_HORKAGE_MAX_SEC_LBA48 },
3814
3815        /*
3816         * Causes silent data corruption with higher max sects.
3817         * http://lkml.kernel.org/g/x49wpy40ysk.fsf@segfault.boston.devel.redhat.com
3818         */
3819        { "ST380013AS",         "3.20",         ATA_HORKAGE_MAX_SEC_1024 },
3820
3821        /*
3822         * These devices time out with higher max sects.
3823         * https://bugzilla.kernel.org/show_bug.cgi?id=121671
3824         */
3825        { "LITEON CX1-JB*-HP",  NULL,           ATA_HORKAGE_MAX_SEC_1024 },
3826        { "LITEON EP1-*",       NULL,           ATA_HORKAGE_MAX_SEC_1024 },
3827
3828        /* Devices we expect to fail diagnostics */
3829
3830        /* Devices where NCQ should be avoided */
3831        /* NCQ is slow */
3832        { "WDC WD740ADFD-00",   NULL,           ATA_HORKAGE_NONCQ },
3833        { "WDC WD740ADFD-00NLR1", NULL,         ATA_HORKAGE_NONCQ, },
3834        /* http://thread.gmane.org/gmane.linux.ide/14907 */
3835        { "FUJITSU MHT2060BH",  NULL,           ATA_HORKAGE_NONCQ },
3836        /* NCQ is broken */
3837        { "Maxtor *",           "BANC*",        ATA_HORKAGE_NONCQ },
3838        { "Maxtor 7V300F0",     "VA111630",     ATA_HORKAGE_NONCQ },
3839        { "ST380817AS",         "3.42",         ATA_HORKAGE_NONCQ },
3840        { "ST3160023AS",        "3.42",         ATA_HORKAGE_NONCQ },
3841        { "OCZ CORE_SSD",       "02.10104",     ATA_HORKAGE_NONCQ },
3842
3843        /* Seagate NCQ + FLUSH CACHE firmware bug */
3844        { "ST31500341AS",       "SD1[5-9]",     ATA_HORKAGE_NONCQ |
3845                                                ATA_HORKAGE_FIRMWARE_WARN },
3846
3847        { "ST31000333AS",       "SD1[5-9]",     ATA_HORKAGE_NONCQ |
3848                                                ATA_HORKAGE_FIRMWARE_WARN },
3849
3850        { "ST3640[36]23AS",     "SD1[5-9]",     ATA_HORKAGE_NONCQ |
3851                                                ATA_HORKAGE_FIRMWARE_WARN },
3852
3853        { "ST3320[68]13AS",     "SD1[5-9]",     ATA_HORKAGE_NONCQ |
3854                                                ATA_HORKAGE_FIRMWARE_WARN },
3855
3856        /* drives which fail FPDMA_AA activation (some may freeze afterwards)
3857           the ST disks also have LPM issues */
3858        { "ST1000LM024 HN-M101MBB", NULL,       ATA_HORKAGE_BROKEN_FPDMA_AA |
3859                                                ATA_HORKAGE_NOLPM, },
3860        { "VB0250EAVER",        "HPG7",         ATA_HORKAGE_BROKEN_FPDMA_AA },
3861
3862        /* Blacklist entries taken from Silicon Image 3124/3132
3863           Windows driver .inf file - also several Linux problem reports */
3864        { "HTS541060G9SA00",    "MB3OC60D",     ATA_HORKAGE_NONCQ, },
3865        { "HTS541080G9SA00",    "MB4OC60D",     ATA_HORKAGE_NONCQ, },
3866        { "HTS541010G9SA00",    "MBZOC60D",     ATA_HORKAGE_NONCQ, },
3867
3868        /* https://bugzilla.kernel.org/show_bug.cgi?id=15573 */
3869        { "C300-CTFDDAC128MAG", "0001",         ATA_HORKAGE_NONCQ, },
3870
3871        /* Sandisk SD7/8/9s lock up hard on large trims */
3872        { "SanDisk SD[789]*",   NULL,           ATA_HORKAGE_MAX_TRIM_128M, },
3873
3874        /* devices which puke on READ_NATIVE_MAX */
3875        { "HDS724040KLSA80",    "KFAOA20N",     ATA_HORKAGE_BROKEN_HPA, },
3876        { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA },
3877        { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
3878        { "MAXTOR 6L080L4",     "A93.0500",     ATA_HORKAGE_BROKEN_HPA },
3879
3880        /* this one allows HPA unlocking but fails IOs on the area */
3881        { "OCZ-VERTEX",             "1.30",     ATA_HORKAGE_BROKEN_HPA },
3882
3883        /* Devices which report 1 sector over size HPA */
3884        { "ST340823A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
3885        { "ST320413A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
3886        { "ST310211A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
3887
3888        /* Devices which get the IVB wrong */
3889        { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB, },
3890        /* Maybe we should just blacklist TSSTcorp... */
3891        { "TSSTcorp CDDVDW SH-S202[HJN]", "SB0[01]",  ATA_HORKAGE_IVB, },
3892
3893        /* Devices that do not need bridging limits applied */
3894        { "MTRON MSP-SATA*",            NULL,   ATA_HORKAGE_BRIDGE_OK, },
3895        { "BUFFALO HD-QSU2/R5",         NULL,   ATA_HORKAGE_BRIDGE_OK, },
3896
3897        /* Devices which aren't very happy with higher link speeds */
3898        { "WD My Book",                 NULL,   ATA_HORKAGE_1_5_GBPS, },
3899        { "Seagate FreeAgent GoFlex",   NULL,   ATA_HORKAGE_1_5_GBPS, },
3900
3901        /*
3902         * Devices which choke on SETXFER.  Applies only if both the
3903         * device and controller are SATA.
3904         */
3905        { "PIONEER DVD-RW  DVRTD08",    NULL,   ATA_HORKAGE_NOSETXFER },
3906        { "PIONEER DVD-RW  DVRTD08A",   NULL,   ATA_HORKAGE_NOSETXFER },
3907        { "PIONEER DVD-RW  DVR-215",    NULL,   ATA_HORKAGE_NOSETXFER },
3908        { "PIONEER DVD-RW  DVR-212D",   NULL,   ATA_HORKAGE_NOSETXFER },
3909        { "PIONEER DVD-RW  DVR-216D",   NULL,   ATA_HORKAGE_NOSETXFER },
3910
3911        /* Crucial BX100 SSD 500GB has broken LPM support */
3912        { "CT500BX100SSD1",             NULL,   ATA_HORKAGE_NOLPM },
3913
3914        /* 512GB MX100 with MU01 firmware has both queued TRIM and LPM issues */
3915        { "Crucial_CT512MX100*",        "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
3916                                                ATA_HORKAGE_ZERO_AFTER_TRIM |
3917                                                ATA_HORKAGE_NOLPM, },
3918        /* 512GB MX100 with newer firmware has only LPM issues */
3919        { "Crucial_CT512MX100*",        NULL,   ATA_HORKAGE_ZERO_AFTER_TRIM |
3920                                                ATA_HORKAGE_NOLPM, },
3921
3922        /* 480GB+ M500 SSDs have both queued TRIM and LPM issues */
3923        { "Crucial_CT480M500*",         NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
3924                                                ATA_HORKAGE_ZERO_AFTER_TRIM |
3925                                                ATA_HORKAGE_NOLPM, },
3926        { "Crucial_CT960M500*",         NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
3927                                                ATA_HORKAGE_ZERO_AFTER_TRIM |
3928                                                ATA_HORKAGE_NOLPM, },
3929
3930        /* These specific Samsung models/firmware-revs do not handle LPM well */
3931        { "SAMSUNG MZMPC128HBFU-000MV", "CXM14M1Q", ATA_HORKAGE_NOLPM, },
3932        { "SAMSUNG SSD PM830 mSATA *",  "CXM13D1Q", ATA_HORKAGE_NOLPM, },
3933        { "SAMSUNG MZ7TD256HAFV-000L9", NULL,       ATA_HORKAGE_NOLPM, },
3934        { "SAMSUNG MZ7TE512HMHP-000L1", "EXT06L0Q", ATA_HORKAGE_NOLPM, },
3935
3936        /* devices that don't properly handle queued TRIM commands */
3937        { "Micron_M500IT_*",            "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
3938                                                ATA_HORKAGE_ZERO_AFTER_TRIM, },
3939        { "Micron_M500_*",              NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
3940                                                ATA_HORKAGE_ZERO_AFTER_TRIM, },
3941        { "Crucial_CT*M500*",           NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
3942                                                ATA_HORKAGE_ZERO_AFTER_TRIM, },
3943        { "Micron_M5[15]0_*",           "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
3944                                                ATA_HORKAGE_ZERO_AFTER_TRIM, },
3945        { "Crucial_CT*M550*",           "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
3946                                                ATA_HORKAGE_ZERO_AFTER_TRIM, },
3947        { "Crucial_CT*MX100*",          "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
3948                                                ATA_HORKAGE_ZERO_AFTER_TRIM, },
3949        { "Samsung SSD 840*",           NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
3950                                                ATA_HORKAGE_ZERO_AFTER_TRIM, },
3951        { "Samsung SSD 850*",           NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
3952                                                ATA_HORKAGE_ZERO_AFTER_TRIM, },
3953        { "FCCT*M500*",                 NULL,   ATA_HORKAGE_NO_NCQ_TRIM |
3954                                                ATA_HORKAGE_ZERO_AFTER_TRIM, },
3955
3956        /* devices that don't properly handle TRIM commands */
3957        { "SuperSSpeed S238*",          NULL,   ATA_HORKAGE_NOTRIM, },
3958
3959        /*
3960         * As defined, the DRAT (Deterministic Read After Trim) and RZAT
3961         * (Return Zero After Trim) flags in the ATA Command Set are
3962         * unreliable in the sense that they only define what happens if
3963         * the device successfully executed the DSM TRIM command. TRIM
3964         * is only advisory, however, and the device is free to silently
3965         * ignore all or parts of the request.
3966         *
3967         * Whitelist drives that are known to reliably return zeroes
3968         * after TRIM.
3969         */
3970
3971        /*
3972         * The intel 510 drive has buggy DRAT/RZAT. Explicitly exclude
3973         * that model before whitelisting all other intel SSDs.
3974         */
3975        { "INTEL*SSDSC2MH*",            NULL,   0, },
3976
3977        { "Micron*",                    NULL,   ATA_HORKAGE_ZERO_AFTER_TRIM, },
3978        { "Crucial*",                   NULL,   ATA_HORKAGE_ZERO_AFTER_TRIM, },
3979        { "INTEL*SSD*",                 NULL,   ATA_HORKAGE_ZERO_AFTER_TRIM, },
3980        { "SSD*INTEL*",                 NULL,   ATA_HORKAGE_ZERO_AFTER_TRIM, },
3981        { "Samsung*SSD*",               NULL,   ATA_HORKAGE_ZERO_AFTER_TRIM, },
3982        { "SAMSUNG*SSD*",               NULL,   ATA_HORKAGE_ZERO_AFTER_TRIM, },
3983        { "SAMSUNG*MZ7KM*",             NULL,   ATA_HORKAGE_ZERO_AFTER_TRIM, },
3984        { "ST[1248][0248]0[FH]*",       NULL,   ATA_HORKAGE_ZERO_AFTER_TRIM, },
3985
3986        /*
3987         * Some WD SATA-I drives spin up and down erratically when the link
3988         * is put into the slumber mode.  We don't have full list of the
3989         * affected devices.  Disable LPM if the device matches one of the
3990         * known prefixes and is SATA-1.  As a side effect LPM partial is
3991         * lost too.
3992         *
3993         * https://bugzilla.kernel.org/show_bug.cgi?id=57211
3994         */
3995        { "WDC WD800JD-*",              NULL,   ATA_HORKAGE_WD_BROKEN_LPM },
3996        { "WDC WD1200JD-*",             NULL,   ATA_HORKAGE_WD_BROKEN_LPM },
3997        { "WDC WD1600JD-*",             NULL,   ATA_HORKAGE_WD_BROKEN_LPM },
3998        { "WDC WD2000JD-*",             NULL,   ATA_HORKAGE_WD_BROKEN_LPM },
3999        { "WDC WD2500JD-*",             NULL,   ATA_HORKAGE_WD_BROKEN_LPM },
4000        { "WDC WD3000JD-*",             NULL,   ATA_HORKAGE_WD_BROKEN_LPM },
4001        { "WDC WD3200JD-*",             NULL,   ATA_HORKAGE_WD_BROKEN_LPM },
4002
4003        /* End Marker */
4004        { }
4005};
4006
4007static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
4008{
4009        unsigned char model_num[ATA_ID_PROD_LEN + 1];
4010        unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
4011        const struct ata_blacklist_entry *ad = ata_device_blacklist;
4012
4013        ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
4014        ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
4015
4016        while (ad->model_num) {
4017                if (glob_match(ad->model_num, model_num)) {
4018                        if (ad->model_rev == NULL)
4019                                return ad->horkage;
4020                        if (glob_match(ad->model_rev, model_rev))
4021                                return ad->horkage;
4022                }
4023                ad++;
4024        }
4025        return 0;
4026}
4027
4028static int ata_dma_blacklisted(const struct ata_device *dev)
4029{
4030        /* We don't support polling DMA.
4031         * DMA blacklist those ATAPI devices with CDB-intr (and use PIO)
4032         * if the LLDD handles only interrupts in the HSM_ST_LAST state.
4033         */
4034        if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
4035            (dev->flags & ATA_DFLAG_CDB_INTR))
4036                return 1;
4037        return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
4038}
4039
4040/**
4041 *      ata_is_40wire           -       check drive side detection
4042 *      @dev: device
4043 *
4044 *      Perform drive side detection decoding, allowing for device vendors
4045 *      who can't follow the documentation.
4046 */
4047
4048static int ata_is_40wire(struct ata_device *dev)
4049{
4050        if (dev->horkage & ATA_HORKAGE_IVB)
4051                return ata_drive_40wire_relaxed(dev->id);
4052        return ata_drive_40wire(dev->id);
4053}
4054
4055/**
4056 *      cable_is_40wire         -       40/80/SATA decider
4057 *      @ap: port to consider
4058 *
4059 *      This function encapsulates the policy for speed management
4060 *      in one place. At the moment we don't cache the result but
4061 *      there is a good case for setting ap->cbl to the result when
4062 *      we are called with unknown cables (and figuring out if it
4063 *      impacts hotplug at all).
4064 *
4065 *      Return 1 if the cable appears to be 40 wire.
4066 */
4067
4068static int cable_is_40wire(struct ata_port *ap)
4069{
4070        struct ata_link *link;
4071        struct ata_device *dev;
4072
4073        /* If the controller thinks we are 40 wire, we are. */
4074        if (ap->cbl == ATA_CBL_PATA40)
4075                return 1;
4076
4077        /* If the controller thinks we are 80 wire, we are. */
4078        if (ap->cbl == ATA_CBL_PATA80 || ap->cbl == ATA_CBL_SATA)
4079                return 0;
4080
4081        /* If the system is known to be 40 wire short cable (eg
4082         * laptop), then we allow 80 wire modes even if the drive
4083         * isn't sure.
4084         */
4085        if (ap->cbl == ATA_CBL_PATA40_SHORT)
4086                return 0;
4087
4088        /* If the controller doesn't know, we scan.
4089         *
4090         * Note: We look for all 40 wire detects at this point.  Any
4091         *       80 wire detect is taken to be 80 wire cable because
4092         * - in many setups only the one drive (slave if present) will
4093         *   give a valid detect
4094         * - if you have a non detect capable drive you don't want it
4095         *   to colour the choice
4096         */
4097        ata_for_each_link(link, ap, EDGE) {
4098                ata_for_each_dev(dev, link, ENABLED) {
4099                        if (!ata_is_40wire(dev))
4100                                return 0;
4101                }
4102        }
4103        return 1;
4104}
4105
4106/**
4107 *      ata_dev_xfermask - Compute supported xfermask of the given device
4108 *      @dev: Device to compute xfermask for
4109 *
4110 *      Compute supported xfermask of @dev and store it in
4111 *      dev->*_mask.  This function is responsible for applying all
4112 *      known limits including host controller limits, device
4113 *      blacklist, etc...
4114 *
4115 *      LOCKING:
4116 *      None.
4117 */
4118static void ata_dev_xfermask(struct ata_device *dev)
4119{
4120        struct ata_link *link = dev->link;
4121        struct ata_port *ap = link->ap;
4122        struct ata_host *host = ap->host;
4123        unsigned long xfer_mask;
4124
4125        /* controller modes available */
4126        xfer_mask = ata_pack_xfermask(ap->pio_mask,
4127                                      ap->mwdma_mask, ap->udma_mask);
4128
4129        /* drive modes available */
4130        xfer_mask &= ata_pack_xfermask(dev->pio_mask,
4131                                       dev->mwdma_mask, dev->udma_mask);
4132        xfer_mask &= ata_id_xfermask(dev->id);
4133
4134        /*
4135         *      CFA Advanced TrueIDE timings are not allowed on a shared
4136         *      cable
4137         */
4138        if (ata_dev_pair(dev)) {
4139                /* No PIO5 or PIO6 */
4140                xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5));
4141                /* No MWDMA3 or MWDMA 4 */
4142                xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3));
4143        }
4144
4145        if (ata_dma_blacklisted(dev)) {
4146                xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
4147                ata_dev_warn(dev,
4148                             "device is on DMA blacklist, disabling DMA\n");
4149        }
4150
4151        if ((host->flags & ATA_HOST_SIMPLEX) &&
4152            host->simplex_claimed && host->simplex_claimed != ap) {
4153                xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
4154                ata_dev_warn(dev,
4155                             "simplex DMA is claimed by other device, disabling DMA\n");
4156        }
4157
4158        if (ap->flags & ATA_FLAG_NO_IORDY)
4159                xfer_mask &= ata_pio_mask_no_iordy(dev);
4160
4161        if (ap->ops->mode_filter)
4162                xfer_mask = ap->ops->mode_filter(dev, xfer_mask);
4163
4164        /* Apply cable rule here.  Don't apply it early because when
4165         * we handle hot plug the cable type can itself change.
4166         * Check this last so that we know if the transfer rate was
4167         * solely limited by the cable.
4168         * Unknown or 80 wire cables reported host side are checked
4169         * drive side as well. Cases where we know a 40wire cable
4170         * is used safely for 80 are not checked here.
4171         */
4172        if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
4173                /* UDMA/44 or higher would be available */
4174                if (cable_is_40wire(ap)) {
4175                        ata_dev_warn(dev,
4176                                     "limited to UDMA/33 due to 40-wire cable\n");
4177                        xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
4178                }
4179
4180        ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
4181                            &dev->mwdma_mask, &dev->udma_mask);
4182}
4183
4184/**
4185 *      ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
4186 *      @dev: Device to which command will be sent
4187 *
4188 *      Issue SET FEATURES - XFER MODE command to device @dev
4189 *      on port @ap.
4190 *
4191 *      LOCKING:
4192 *      PCI/etc. bus probe sem.
4193 *
4194 *      RETURNS:
4195 *      0 on success, AC_ERR_* mask otherwise.
4196 */
4197
4198static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
4199{
4200        struct ata_taskfile tf;
4201        unsigned int err_mask;
4202
4203        /* set up set-features taskfile */
4204        DPRINTK("set features - xfer mode\n");
4205
4206        /* Some controllers and ATAPI devices show flaky interrupt
4207         * behavior after setting xfer mode.  Use polling instead.
4208         */
4209        ata_tf_init(dev, &tf);
4210        tf.command = ATA_CMD_SET_FEATURES;
4211        tf.feature = SETFEATURES_XFER;
4212        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING;
4213        tf.protocol = ATA_PROT_NODATA;
4214        /* If we are using IORDY we must send the mode setting command */
4215        if (ata_pio_need_iordy(dev))
4216                tf.nsect = dev->xfer_mode;
4217        /* If the device has IORDY and the controller does not - turn it off */
4218        else if (ata_id_has_iordy(dev->id))
4219                tf.nsect = 0x01;
4220        else /* In the ancient relic department - skip all of this */
4221                return 0;
4222
4223        /* On some disks, this command causes spin-up, so we need longer timeout */
4224        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 15000);
4225
4226        DPRINTK("EXIT, err_mask=%x\n", err_mask);
4227        return err_mask;
4228}
4229
4230/**
4231 *      ata_dev_set_feature - Issue SET FEATURES - SATA FEATURES
4232 *      @dev: Device to which command will be sent
4233 *      @enable: Whether to enable or disable the feature
4234 *      @feature: The sector count represents the feature to set
4235 *
4236 *      Issue SET FEATURES - SATA FEATURES command to device @dev
4237 *      on port @ap with sector count
4238 *
4239 *      LOCKING:
4240 *      PCI/etc. bus probe sem.
4241 *
4242 *      RETURNS:
4243 *      0 on success, AC_ERR_* mask otherwise.
4244 */
4245unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable, u8 feature)
4246{
4247        struct ata_taskfile tf;
4248        unsigned int err_mask;
4249        unsigned long timeout = 0;
4250
4251        /* set up set-features taskfile */
4252        DPRINTK("set features - SATA features\n");
4253
4254        ata_tf_init(dev, &tf);
4255        tf.command = ATA_CMD_SET_FEATURES;
4256        tf.feature = enable;
4257        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4258        tf.protocol = ATA_PROT_NODATA;
4259        tf.nsect = feature;
4260
4261        if (enable == SETFEATURES_SPINUP)
4262                timeout = ata_probe_timeout ?
4263                          ata_probe_timeout * 1000 : SETFEATURES_SPINUP_TIMEOUT;
4264        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, timeout);
4265
4266        DPRINTK("EXIT, err_mask=%x\n", err_mask);
4267        return err_mask;
4268}
4269EXPORT_SYMBOL_GPL(ata_dev_set_feature);
4270
4271/**
4272 *      ata_dev_init_params - Issue INIT DEV PARAMS command
4273 *      @dev: Device to which command will be sent
4274 *      @heads: Number of heads (taskfile parameter)
4275 *      @sectors: Number of sectors (taskfile parameter)
4276 *
4277 *      LOCKING:
4278 *      Kernel thread context (may sleep)
4279 *
4280 *      RETURNS:
4281 *      0 on success, AC_ERR_* mask otherwise.
4282 */
4283static unsigned int ata_dev_init_params(struct ata_device *dev,
4284                                        u16 heads, u16 sectors)
4285{
4286        struct ata_taskfile tf;
4287        unsigned int err_mask;
4288
4289        /* Number of sectors per track 1-255. Number of heads 1-16 */
4290        if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
4291                return AC_ERR_INVALID;
4292
4293        /* set up init dev params taskfile */
4294        DPRINTK("init dev params \n");
4295
4296        ata_tf_init(dev, &tf);
4297        tf.command = ATA_CMD_INIT_DEV_PARAMS;
4298        tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4299        tf.protocol = ATA_PROT_NODATA;
4300        tf.nsect = sectors;
4301        tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
4302
4303        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
4304        /* A clean abort indicates an original or just out of spec drive
4305           and we should continue as we issue the setup based on the
4306           drive reported working geometry */
4307        if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
4308                err_mask = 0;
4309
4310        DPRINTK("EXIT, err_mask=%x\n", err_mask);
4311        return err_mask;
4312}
4313
4314/**
4315 *      atapi_check_dma - Check whether ATAPI DMA can be supported
4316 *      @qc: Metadata associated with taskfile to check
4317 *
4318 *      Allow low-level driver to filter ATA PACKET commands, returning
4319 *      a status indicating whether or not it is OK to use DMA for the
4320 *      supplied PACKET command.
4321 *
4322 *      LOCKING:
4323 *      spin_lock_irqsave(host lock)
4324 *
4325 *      RETURNS: 0 when ATAPI DMA can be used
4326 *               nonzero otherwise
4327 */
4328int atapi_check_dma(struct ata_queued_cmd *qc)
4329{
4330        struct ata_port *ap = qc->ap;
4331
4332        /* Don't allow DMA if it isn't multiple of 16 bytes.  Quite a
4333         * few ATAPI devices choke on such DMA requests.
4334         */
4335        if (!(qc->dev->horkage & ATA_HORKAGE_ATAPI_MOD16_DMA) &&
4336            unlikely(qc->nbytes & 15))
4337                return 1;
4338
4339        if (ap->ops->check_atapi_dma)
4340                return ap->ops->check_atapi_dma(qc);
4341
4342        return 0;
4343}
4344
4345/**
4346 *      ata_std_qc_defer - Check whether a qc needs to be deferred
4347 *      @qc: ATA command in question
4348 *
4349 *      Non-NCQ commands cannot run with any other command, NCQ or
4350 *      not.  As upper layer only knows the queue depth, we are
4351 *      responsible for maintaining exclusion.  This function checks
4352 *      whether a new command @qc can be issued.
4353 *
4354 *      LOCKING:
4355 *      spin_lock_irqsave(host lock)
4356 *
4357 *      RETURNS:
4358 *      ATA_DEFER_* if deferring is needed, 0 otherwise.
4359 */
4360int ata_std_qc_defer(struct ata_queued_cmd *qc)
4361{
4362        struct ata_link *link = qc->dev->link;
4363
4364        if (ata_is_ncq(qc->tf.protocol)) {
4365                if (!ata_tag_valid(link->active_tag))
4366                        return 0;
4367        } else {
4368                if (!ata_tag_valid(link->active_tag) && !link->sactive)
4369                        return 0;
4370        }
4371
4372        return ATA_DEFER_LINK;
4373}
4374EXPORT_SYMBOL_GPL(ata_std_qc_defer);
4375
4376enum ata_completion_errors ata_noop_qc_prep(struct ata_queued_cmd *qc)
4377{
4378        return AC_ERR_OK;
4379}
4380EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
4381
4382/**
4383 *      ata_sg_init - Associate command with scatter-gather table.
4384 *      @qc: Command to be associated
4385 *      @sg: Scatter-gather table.
4386 *      @n_elem: Number of elements in s/g table.
4387 *
4388 *      Initialize the data-related elements of queued_cmd @qc
4389 *      to point to a scatter-gather table @sg, containing @n_elem
4390 *      elements.
4391 *
4392 *      LOCKING:
4393 *      spin_lock_irqsave(host lock)
4394 */
4395void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
4396                 unsigned int n_elem)
4397{
4398        qc->sg = sg;
4399        qc->n_elem = n_elem;
4400        qc->cursg = qc->sg;
4401}
4402
4403#ifdef CONFIG_HAS_DMA
4404
4405/**
4406 *      ata_sg_clean - Unmap DMA memory associated with command
4407 *      @qc: Command containing DMA memory to be released
4408 *
4409 *      Unmap all mapped DMA memory associated with this command.
4410 *
4411 *      LOCKING:
4412 *      spin_lock_irqsave(host lock)
4413 */
4414static void ata_sg_clean(struct ata_queued_cmd *qc)
4415{
4416        struct ata_port *ap = qc->ap;
4417        struct scatterlist *sg = qc->sg;
4418        int dir = qc->dma_dir;
4419
4420        WARN_ON_ONCE(sg == NULL);
4421
4422        VPRINTK("unmapping %u sg elements\n", qc->n_elem);
4423
4424        if (qc->n_elem)
4425                dma_unmap_sg(ap->dev, sg, qc->orig_n_elem, dir);
4426
4427        qc->flags &= ~ATA_QCFLAG_DMAMAP;
4428        qc->sg = NULL;
4429}
4430
4431/**
4432 *      ata_sg_setup - DMA-map the scatter-gather table associated with a command.
4433 *      @qc: Command with scatter-gather table to be mapped.
4434 *
4435 *      DMA-map the scatter-gather table associated with queued_cmd @qc.
4436 *
4437 *      LOCKING:
4438 *      spin_lock_irqsave(host lock)
4439 *
4440 *      RETURNS:
4441 *      Zero on success, negative on error.
4442 *
4443 */
4444static int ata_sg_setup(struct ata_queued_cmd *qc)
4445{
4446        struct ata_port *ap = qc->ap;
4447        unsigned int n_elem;
4448
4449        VPRINTK("ENTER, ata%u\n", ap->print_id);
4450
4451        n_elem = dma_map_sg(ap->dev, qc->sg, qc->n_elem, qc->dma_dir);
4452        if (n_elem < 1)
4453                return -1;
4454
4455        VPRINTK("%d sg elements mapped\n", n_elem);
4456        qc->orig_n_elem = qc->n_elem;
4457        qc->n_elem = n_elem;
4458        qc->flags |= ATA_QCFLAG_DMAMAP;
4459
4460        return 0;
4461}
4462
4463#else /* !CONFIG_HAS_DMA */
4464
4465static inline void ata_sg_clean(struct ata_queued_cmd *qc) {}
4466static inline int ata_sg_setup(struct ata_queued_cmd *qc) { return -1; }
4467
4468#endif /* !CONFIG_HAS_DMA */
4469
4470/**
4471 *      swap_buf_le16 - swap halves of 16-bit words in place
4472 *      @buf:  Buffer to swap
4473 *      @buf_words:  Number of 16-bit words in buffer.
4474 *
4475 *      Swap halves of 16-bit words if needed to convert from
4476 *      little-endian byte order to native cpu byte order, or
4477 *      vice-versa.
4478 *
4479 *      LOCKING:
4480 *      Inherited from caller.
4481 */
4482void swap_buf_le16(u16 *buf, unsigned int buf_words)
4483{
4484#ifdef __BIG_ENDIAN
4485        unsigned int i;
4486
4487        for (i = 0; i < buf_words; i++)
4488                buf[i] = le16_to_cpu(buf[i]);
4489#endif /* __BIG_ENDIAN */
4490}
4491
4492/**
4493 *      ata_qc_new_init - Request an available ATA command, and initialize it
4494 *      @dev: Device from whom we request an available command structure
4495 *      @tag: tag
4496 *
4497 *      LOCKING:
4498 *      None.
4499 */
4500
4501struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev, int tag)
4502{
4503        struct ata_port *ap = dev->link->ap;
4504        struct ata_queued_cmd *qc;
4505
4506        /* no command while frozen */
4507        if (unlikely(ap->pflags & ATA_PFLAG_FROZEN))
4508                return NULL;
4509
4510        /* libsas case */
4511        if (ap->flags & ATA_FLAG_SAS_HOST) {
4512                tag = ata_sas_allocate_tag(ap);
4513                if (tag < 0)
4514                        return NULL;
4515        }
4516
4517        qc = __ata_qc_from_tag(ap, tag);
4518        qc->tag = qc->hw_tag = tag;
4519        qc->scsicmd = NULL;
4520        qc->ap = ap;
4521        qc->dev = dev;
4522
4523        ata_qc_reinit(qc);
4524
4525        return qc;
4526}
4527
4528/**
4529 *      ata_qc_free - free unused ata_queued_cmd
4530 *      @qc: Command to complete
4531 *
4532 *      Designed to free unused ata_queued_cmd object
4533 *      in case something prevents using it.
4534 *
4535 *      LOCKING:
4536 *      spin_lock_irqsave(host lock)
4537 */
4538void ata_qc_free(struct ata_queued_cmd *qc)
4539{
4540        struct ata_port *ap;
4541        unsigned int tag;
4542
4543        WARN_ON_ONCE(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
4544        ap = qc->ap;
4545
4546        qc->flags = 0;
4547        tag = qc->tag;
4548        if (ata_tag_valid(tag)) {
4549                qc->tag = ATA_TAG_POISON;
4550                if (ap->flags & ATA_FLAG_SAS_HOST)
4551                        ata_sas_free_tag(tag, ap);
4552        }
4553}
4554
4555void __ata_qc_complete(struct ata_queued_cmd *qc)
4556{
4557        struct ata_port *ap;
4558        struct ata_link *link;
4559
4560        WARN_ON_ONCE(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
4561        WARN_ON_ONCE(!(qc->flags & ATA_QCFLAG_ACTIVE));
4562        ap = qc->ap;
4563        link = qc->dev->link;
4564
4565        if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4566                ata_sg_clean(qc);
4567
4568        /* command should be marked inactive atomically with qc completion */
4569        if (ata_is_ncq(qc->tf.protocol)) {
4570                link->sactive &= ~(1 << qc->hw_tag);
4571                if (!link->sactive)
4572                        ap->nr_active_links--;
4573        } else {
4574                link->active_tag = ATA_TAG_POISON;
4575                ap->nr_active_links--;
4576        }
4577
4578        /* clear exclusive status */
4579        if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL &&
4580                     ap->excl_link == link))
4581                ap->excl_link = NULL;
4582
4583        /* atapi: mark qc as inactive to prevent the interrupt handler
4584         * from completing the command twice later, before the error handler
4585         * is called. (when rc != 0 and atapi request sense is needed)
4586         */
4587        qc->flags &= ~ATA_QCFLAG_ACTIVE;
4588        ap->qc_active &= ~(1ULL << qc->tag);
4589
4590        /* call completion callback */
4591        qc->complete_fn(qc);
4592}
4593
4594static void fill_result_tf(struct ata_queued_cmd *qc)
4595{
4596        struct ata_port *ap = qc->ap;
4597
4598        qc->result_tf.flags = qc->tf.flags;
4599        ap->ops->qc_fill_rtf(qc);
4600}
4601
4602static void ata_verify_xfer(struct ata_queued_cmd *qc)
4603{
4604        struct ata_device *dev = qc->dev;
4605
4606        if (!ata_is_data(qc->tf.protocol))
4607                return;
4608
4609        if ((dev->mwdma_mask || dev->udma_mask) && ata_is_pio(qc->tf.protocol))
4610                return;
4611
4612        dev->flags &= ~ATA_DFLAG_DUBIOUS_XFER;
4613}
4614
4615/**
4616 *      ata_qc_complete - Complete an active ATA command
4617 *      @qc: Command to complete
4618 *
4619 *      Indicate to the mid and upper layers that an ATA command has
4620 *      completed, with either an ok or not-ok status.
4621 *
4622 *      Refrain from calling this function multiple times when
4623 *      successfully completing multiple NCQ commands.
4624 *      ata_qc_complete_multiple() should be used instead, which will
4625 *      properly update IRQ expect state.
4626 *
4627 *      LOCKING:
4628 *      spin_lock_irqsave(host lock)
4629 */
4630void ata_qc_complete(struct ata_queued_cmd *qc)
4631{
4632        struct ata_port *ap = qc->ap;
4633
4634        /* Trigger the LED (if available) */
4635        ledtrig_disk_activity(!!(qc->tf.flags & ATA_TFLAG_WRITE));
4636
4637        /* XXX: New EH and old EH use different mechanisms to
4638         * synchronize EH with regular execution path.
4639         *
4640         * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED.
4641         * Normal execution path is responsible for not accessing a
4642         * failed qc.  libata core enforces the rule by returning NULL
4643         * from ata_qc_from_tag() for failed qcs.
4644         *
4645         * Old EH depends on ata_qc_complete() nullifying completion
4646         * requests if ATA_QCFLAG_EH_SCHEDULED is set.  Old EH does
4647         * not synchronize with interrupt handler.  Only PIO task is
4648         * taken care of.
4649         */
4650        if (ap->ops->error_handler) {
4651                struct ata_device *dev = qc->dev;
4652                struct ata_eh_info *ehi = &dev->link->eh_info;
4653
4654                if (unlikely(qc->err_mask))
4655                        qc->flags |= ATA_QCFLAG_FAILED;
4656
4657                /*
4658                 * Finish internal commands without any further processing
4659                 * and always with the result TF filled.
4660                 */
4661                if (unlikely(ata_tag_internal(qc->tag))) {
4662                        fill_result_tf(qc);
4663                        trace_ata_qc_complete_internal(qc);
4664                        __ata_qc_complete(qc);
4665                        return;
4666                }
4667
4668                /*
4669                 * Non-internal qc has failed.  Fill the result TF and
4670                 * summon EH.
4671                 */
4672                if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
4673                        fill_result_tf(qc);
4674                        trace_ata_qc_complete_failed(qc);
4675                        ata_qc_schedule_eh(qc);
4676                        return;
4677                }
4678
4679                WARN_ON_ONCE(ap->pflags & ATA_PFLAG_FROZEN);
4680
4681                /* read result TF if requested */
4682                if (qc->flags & ATA_QCFLAG_RESULT_TF)
4683                        fill_result_tf(qc);
4684
4685                trace_ata_qc_complete_done(qc);
4686                /* Some commands need post-processing after successful
4687                 * completion.
4688                 */
4689                switch (qc->tf.command) {
4690                case ATA_CMD_SET_FEATURES:
4691                        if (qc->tf.feature != SETFEATURES_WC_ON &&
4692                            qc->tf.feature != SETFEATURES_WC_OFF &&
4693