/*
 *  libata-core.c - helper library for ATA
 *
 *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
 *                  Please ALWAYS copy linux-ide@vger.kernel.org
 *                  on emails.
 *
 *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
 *  Copyright 2003-2004 Jeff Garzik
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *
 *  libata documentation is available via 'make {ps|pdf}docs',
 *  as Documentation/DocBook/libata.*
 *
 *  Hardware documentation available from http://www.t13.org/ and
 *  http://www.sata-io.org/
 *
 *  Standards documents from:
 *      http://www.t13.org (ATA standards, PCI DMA IDE spec)
 *      http://www.t10.org (SCSI MMC - for ATAPI MMC)
 *      http://www.sata-io.org (SATA)
 *      http://www.compactflash.org (CF)
 *      http://www.qic.org (QIC157 - Tape and DSC)
 *      http://www.ce-ata.org (CE-ATA: not supported)
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/mm.h>
#include <linux/spinlock.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
#include <linux/completion.h>
#include <linux/suspend.h>
#include <linux/workqueue.h>
#include <linux/scatterlist.h>
#include <linux/io.h>
#include <linux/async.h>
#include <linux/log2.h>
#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_host.h>
#include <linux/libata.h>
#include <asm/byteorder.h>
#include <linux/cdrom.h>

#include "libata.h"


/* debounce timing parameters in msecs { interval, duration, timeout } */
const unsigned long sata_deb_timing_normal[]            = {   5,  100, 2000 };
const unsigned long sata_deb_timing_hotplug[]           = {  25,  500, 2000 };
const unsigned long sata_deb_timing_long[]              = { 100, 2000, 5000 };

const struct ata_port_operations ata_base_port_ops = {
        .prereset               = ata_std_prereset,
        .postreset              = ata_std_postreset,
        .error_handler          = ata_std_error_handler,
};

const struct ata_port_operations sata_port_ops = {
        .inherits               = &ata_base_port_ops,

        .qc_defer               = ata_std_qc_defer,
        .hardreset              = sata_std_hardreset,
};

static unsigned int ata_dev_init_params(struct ata_device *dev,
                                        u16 heads, u16 sectors);
static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
static unsigned int ata_dev_set_feature(struct ata_device *dev,
                                        u8 enable, u8 feature);
static void ata_dev_xfermask(struct ata_device *dev);
static unsigned long ata_dev_blacklisted(const struct ata_device *dev);

unsigned int ata_print_id = 1;
static struct workqueue_struct *ata_wq;

struct workqueue_struct *ata_aux_wq;

struct ata_force_param {
        const char      *name;
        unsigned int    cbl;
        int             spd_limit;
        unsigned long   xfer_mask;
        unsigned int    horkage_on;
        unsigned int    horkage_off;
        unsigned int    lflags;
};

struct ata_force_ent {
        int                     port;
        int                     device;
        struct ata_force_param  param;
};

static struct ata_force_ent *ata_force_tbl;
static int ata_force_tbl_size;

static char ata_force_param_buf[PAGE_SIZE] __initdata;
/* param_buf is thrown away after initialization, disallow read */
module_param_string(force, ata_force_param_buf, sizeof(ata_force_param_buf), 0);
MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link speed and transfer mode (see Documentation/kernel-parameters.txt for details)");

static int atapi_enabled = 1;
module_param(atapi_enabled, int, 0444);
MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");

static int atapi_dmadir = 0;
module_param(atapi_dmadir, int, 0444);
MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");

int atapi_passthru16 = 1;
module_param(atapi_passthru16, int, 0444);
MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices; on by default (0=off, 1=on)");

int libata_fua = 0;
module_param_named(fua, libata_fua, int, 0444);
MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");

static int ata_ignore_hpa;
module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)");

static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA;
module_param_named(dma, libata_dma_mask, int, 0444);
MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)");

static int ata_probe_timeout;
module_param(ata_probe_timeout, int, 0444);
MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");

int libata_noacpi = 0;
module_param_named(noacpi, libata_noacpi, int, 0444);
MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in probe/suspend/resume when set");

int libata_allow_tpm = 0;
module_param_named(allow_tpm, libata_allow_tpm, int, 0444);
MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands");

MODULE_AUTHOR("Jeff Garzik");
MODULE_DESCRIPTION("Library module for ATA devices");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);


static bool ata_sstatus_online(u32 sstatus)
{
        return (sstatus & 0xf) == 0x3;
}

/**
 *      ata_link_next - link iteration helper
 *      @link: the previous link, NULL to start
 *      @ap: ATA port containing links to iterate
 *      @mode: iteration mode, one of ATA_LITER_*
 *
 *      LOCKING:
 *      Host lock or EH context.
 *
 *      RETURNS:
 *      Pointer to the next link.
 */
struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap,
                               enum ata_link_iter_mode mode)
{
        BUG_ON(mode != ATA_LITER_EDGE &&
               mode != ATA_LITER_PMP_FIRST && mode != ATA_LITER_HOST_FIRST);

        /* NULL link indicates start of iteration */
        if (!link)
                switch (mode) {
                case ATA_LITER_EDGE:
                case ATA_LITER_PMP_FIRST:
                        if (sata_pmp_attached(ap))
                                return ap->pmp_link;
                        /* fall through */
                case ATA_LITER_HOST_FIRST:
                        return &ap->link;
                }

        /* we just iterated over the host link, what's next? */
        if (link == &ap->link)
                switch (mode) {
                case ATA_LITER_HOST_FIRST:
                        if (sata_pmp_attached(ap))
                                return ap->pmp_link;
                        /* fall through */
                case ATA_LITER_PMP_FIRST:
                        if (unlikely(ap->slave_link))
                                return ap->slave_link;
                        /* fall through */
                case ATA_LITER_EDGE:
                        return NULL;
                }

        /* slave_link excludes PMP */
        if (unlikely(link == ap->slave_link))
                return NULL;

        /* we were over a PMP link */
        if (++link < ap->pmp_link + ap->nr_pmp_links)
                return link;

        if (mode == ATA_LITER_PMP_FIRST)
                return &ap->link;

        return NULL;
}

/**
 *      ata_dev_next - device iteration helper
 *      @dev: the previous device, NULL to start
 *      @link: ATA link containing devices to iterate
 *      @mode: iteration mode, one of ATA_DITER_*
 *
 *      LOCKING:
 *      Host lock or EH context.
 *
 *      RETURNS:
 *      Pointer to the next device.
 */
struct ata_device *ata_dev_next(struct ata_device *dev, struct ata_link *link,
                                enum ata_dev_iter_mode mode)
{
        BUG_ON(mode != ATA_DITER_ENABLED && mode != ATA_DITER_ENABLED_REVERSE &&
               mode != ATA_DITER_ALL && mode != ATA_DITER_ALL_REVERSE);

        /* NULL dev indicates start of iteration */
        if (!dev)
                switch (mode) {
                case ATA_DITER_ENABLED:
                case ATA_DITER_ALL:
                        dev = link->device;
                        goto check;
                case ATA_DITER_ENABLED_REVERSE:
                case ATA_DITER_ALL_REVERSE:
                        dev = link->device + ata_link_max_devices(link) - 1;
                        goto check;
                }

 next:
        /* move to the next one */
        switch (mode) {
        case ATA_DITER_ENABLED:
        case ATA_DITER_ALL:
                if (++dev < link->device + ata_link_max_devices(link))
                        goto check;
                return NULL;
        case ATA_DITER_ENABLED_REVERSE:
        case ATA_DITER_ALL_REVERSE:
                if (--dev >= link->device)
                        goto check;
                return NULL;
        }

 check:
        if ((mode == ATA_DITER_ENABLED || mode == ATA_DITER_ENABLED_REVERSE) &&
            !ata_dev_enabled(dev))
                goto next;
        return dev;
}

/**
 *      ata_dev_phys_link - find physical link for a device
 *      @dev: ATA device to look up physical link for
 *
 *      Look up physical link which @dev is attached to.  Note that
 *      this is different from @dev->link only when @dev is on slave
 *      link.  For all other cases, it's the same as @dev->link.
 *
 *      LOCKING:
 *      Don't care.
 *
 *      RETURNS:
 *      Pointer to the found physical link.
 */
struct ata_link *ata_dev_phys_link(struct ata_device *dev)
{
        struct ata_port *ap = dev->link->ap;

        if (!ap->slave_link)
                return dev->link;
        if (!dev->devno)
                return &ap->link;
        return ap->slave_link;
}

/**
 *      ata_force_cbl - force cable type according to libata.force
 *      @ap: ATA port of interest
 *
 *      Force cable type according to libata.force and whine about it.
 *      The last entry which has matching port number is used, so it
 *      can be specified as part of device force parameters.  For
 *      example, both "a:40c,1.00:udma4" and "1.00:40c,udma4" have the
 *      same effect.
 *
 *      LOCKING:
 *      EH context.
 */
void ata_force_cbl(struct ata_port *ap)
{
        int i;

        for (i = ata_force_tbl_size - 1; i >= 0; i--) {
                const struct ata_force_ent *fe = &ata_force_tbl[i];

                if (fe->port != -1 && fe->port != ap->print_id)
                        continue;

                if (fe->param.cbl == ATA_CBL_NONE)
                        continue;

                ap->cbl = fe->param.cbl;
                ata_port_printk(ap, KERN_NOTICE,
                                "FORCE: cable set to %s\n", fe->param.name);
                return;
        }
}

/**
 *      ata_force_link_limits - force link limits according to libata.force
 *      @link: ATA link of interest
 *
 *      Force link flags and SATA spd limit according to libata.force
 *      and whine about it.  When only the port part is specified
 *      (e.g. 1:), the limit applies to all links connected to both
 *      the host link and all fan-out ports connected via PMP.  If the
 *      device part is specified as 0 (e.g. 1.00:), it specifies the
 *      first fan-out link not the host link.  Device number 15 always
 *      points to the host link whether PMP is attached or not.  If the
 *      controller has slave link, device number 16 points to it.
 *
 *      LOCKING:
 *      EH context.
 */
static void ata_force_link_limits(struct ata_link *link)
{
        bool did_spd = false;
        int linkno = link->pmp;
        int i;

        if (ata_is_host_link(link))
                linkno += 15;

        for (i = ata_force_tbl_size - 1; i >= 0; i--) {
                const struct ata_force_ent *fe = &ata_force_tbl[i];

                if (fe->port != -1 && fe->port != link->ap->print_id)
                        continue;

                if (fe->device != -1 && fe->device != linkno)
                        continue;

                /* only honor the first spd limit */
                if (!did_spd && fe->param.spd_limit) {
                        link->hw_sata_spd_limit = (1 << fe->param.spd_limit) - 1;
                        ata_link_printk(link, KERN_NOTICE,
                                        "FORCE: PHY spd limit set to %s\n",
                                        fe->param.name);
                        did_spd = true;
                }

                /* let lflags stack */
                if (fe->param.lflags) {
                        link->flags |= fe->param.lflags;
                        ata_link_printk(link, KERN_NOTICE,
                                        "FORCE: link flag 0x%x forced -> 0x%x\n",
                                        fe->param.lflags, link->flags);
                }
        }
}

/**
 *      ata_force_xfermask - force xfermask according to libata.force
 *      @dev: ATA device of interest
 *
 *      Force xfer_mask according to libata.force and whine about it.
 *      For consistency with link selection, device number 15 selects
 *      the first device connected to the host link.
 *
 *      LOCKING:
 *      EH context.
 */
static void ata_force_xfermask(struct ata_device *dev)
{
        int devno = dev->link->pmp + dev->devno;
        int alt_devno = devno;
        int i;

        /* allow n.15/16 for devices attached to host port */
        if (ata_is_host_link(dev->link))
                alt_devno += 15;

        for (i = ata_force_tbl_size - 1; i >= 0; i--) {
                const struct ata_force_ent *fe = &ata_force_tbl[i];
                unsigned long pio_mask, mwdma_mask, udma_mask;

                if (fe->port != -1 && fe->port != dev->link->ap->print_id)
                        continue;

                if (fe->device != -1 && fe->device != devno &&
                    fe->device != alt_devno)
                        continue;

                if (!fe->param.xfer_mask)
                        continue;

                ata_unpack_xfermask(fe->param.xfer_mask,
                                    &pio_mask, &mwdma_mask, &udma_mask);
                if (udma_mask)
                        dev->udma_mask = udma_mask;
                else if (mwdma_mask) {
                        dev->udma_mask = 0;
                        dev->mwdma_mask = mwdma_mask;
                } else {
                        dev->udma_mask = 0;
                        dev->mwdma_mask = 0;
                        dev->pio_mask = pio_mask;
                }

                ata_dev_printk(dev, KERN_NOTICE,
                        "FORCE: xfer_mask set to %s\n", fe->param.name);
                return;
        }
}

/**
 *      ata_force_horkage - force horkage according to libata.force
 *      @dev: ATA device of interest
 *
 *      Force horkage according to libata.force and whine about it.
 *      For consistency with link selection, device number 15 selects
 *      the first device connected to the host link.
 *
 *      LOCKING:
 *      EH context.
 */
static void ata_force_horkage(struct ata_device *dev)
{
        int devno = dev->link->pmp + dev->devno;
        int alt_devno = devno;
        int i;

        /* allow n.15/16 for devices attached to host port */
        if (ata_is_host_link(dev->link))
                alt_devno += 15;

        for (i = 0; i < ata_force_tbl_size; i++) {
                const struct ata_force_ent *fe = &ata_force_tbl[i];

                if (fe->port != -1 && fe->port != dev->link->ap->print_id)
                        continue;

                if (fe->device != -1 && fe->device != devno &&
                    fe->device != alt_devno)
                        continue;

                if (!(~dev->horkage & fe->param.horkage_on) &&
                    !(dev->horkage & fe->param.horkage_off))
                        continue;

                dev->horkage |= fe->param.horkage_on;
                dev->horkage &= ~fe->param.horkage_off;

                ata_dev_printk(dev, KERN_NOTICE,
                        "FORCE: horkage modified (%s)\n", fe->param.name);
        }
}

/**
 *      atapi_cmd_type - Determine ATAPI command type from SCSI opcode
 *      @opcode: SCSI opcode
 *
 *      Determine ATAPI command type from @opcode.
 *
 *      LOCKING:
 *      None.
 *
 *      RETURNS:
 *      ATAPI_{READ|WRITE|READ_CD|PASS_THRU|MISC}
 */
int atapi_cmd_type(u8 opcode)
{
        switch (opcode) {
        case GPCMD_READ_10:
        case GPCMD_READ_12:
                return ATAPI_READ;

        case GPCMD_WRITE_10:
        case GPCMD_WRITE_12:
        case GPCMD_WRITE_AND_VERIFY_10:
                return ATAPI_WRITE;

        case GPCMD_READ_CD:
        case GPCMD_READ_CD_MSF:
                return ATAPI_READ_CD;

        case ATA_16:
        case ATA_12:
                if (atapi_passthru16)
                        return ATAPI_PASS_THRU;
                /* fall thru */
        default:
                return ATAPI_MISC;
        }
}

/**
 *      ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
 *      @tf: Taskfile to convert
 *      @pmp: Port multiplier port
 *      @is_cmd: This FIS is for command
 *      @fis: Buffer into which data will output
 *
 *      Converts a standard ATA taskfile to a Serial ATA
 *      FIS structure (Register - Host to Device).
 *
 *      LOCKING:
 *      Inherited from caller.
 */
void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis)
{
        fis[0] = 0x27;                  /* Register - Host to Device FIS */
        fis[1] = pmp & 0xf;             /* Port multiplier number*/
        if (is_cmd)
                fis[1] |= (1 << 7);     /* bit 7 indicates Command FIS */

        fis[2] = tf->command;
        fis[3] = tf->feature;

        fis[4] = tf->lbal;
        fis[5] = tf->lbam;
        fis[6] = tf->lbah;
        fis[7] = tf->device;

        fis[8] = tf->hob_lbal;
        fis[9] = tf->hob_lbam;
        fis[10] = tf->hob_lbah;
        fis[11] = tf->hob_feature;

        fis[12] = tf->nsect;
        fis[13] = tf->hob_nsect;
        fis[14] = 0;
        fis[15] = tf->ctl;

        fis[16] = 0;
        fis[17] = 0;
        fis[18] = 0;
        fis[19] = 0;
}

/**
 *      ata_tf_from_fis - Convert SATA FIS to ATA taskfile
 *      @fis: Buffer from which data will be input
 *      @tf: Taskfile to output
 *
 *      Converts a serial ATA FIS structure to a standard ATA taskfile.
 *
 *      LOCKING:
 *      Inherited from caller.
 */

void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
{
        tf->command     = fis[2];       /* status */
        tf->feature     = fis[3];       /* error */

        tf->lbal        = fis[4];
        tf->lbam        = fis[5];
        tf->lbah        = fis[6];
        tf->device      = fis[7];

        tf->hob_lbal    = fis[8];
        tf->hob_lbam    = fis[9];
        tf->hob_lbah    = fis[10];

        tf->nsect       = fis[12];
        tf->hob_nsect   = fis[13];
}

static const u8 ata_rw_cmds[] = {
        /* pio multi */
        ATA_CMD_READ_MULTI,
        ATA_CMD_WRITE_MULTI,
        ATA_CMD_READ_MULTI_EXT,
        ATA_CMD_WRITE_MULTI_EXT,
        0,
        0,
        0,
        ATA_CMD_WRITE_MULTI_FUA_EXT,
        /* pio */
        ATA_CMD_PIO_READ,
        ATA_CMD_PIO_WRITE,
        ATA_CMD_PIO_READ_EXT,
        ATA_CMD_PIO_WRITE_EXT,
        0,
        0,
        0,
        0,
        /* dma */
        ATA_CMD_READ,
        ATA_CMD_WRITE,
        ATA_CMD_READ_EXT,
        ATA_CMD_WRITE_EXT,
        0,
        0,
        0,
        ATA_CMD_WRITE_FUA_EXT
};

/**
 *      ata_rwcmd_protocol - set taskfile r/w commands and protocol
 *      @tf: command to examine and configure
 *      @dev: device tf belongs to
 *
 *      Examine the device configuration and tf->flags to calculate
 *      the proper read/write commands and protocol to use.
 *
 *      LOCKING:
 *      caller.
 */
static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev)
{
        u8 cmd;

        int index, fua, lba48, write;

        fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
        lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
        write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;

        if (dev->flags & ATA_DFLAG_PIO) {
                tf->protocol = ATA_PROT_PIO;
                index = dev->multi_count ? 0 : 8;
        } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
                /* Unable to use DMA due to host limitation */
                tf->protocol = ATA_PROT_PIO;
                index = dev->multi_count ? 0 : 8;
        } else {
                tf->protocol = ATA_PROT_DMA;
                index = 16;
        }

        cmd = ata_rw_cmds[index + fua + lba48 + write];
        if (cmd) {
                tf->command = cmd;
                return 0;
        }
        return -1;
}

/**
 *      ata_tf_read_block - Read block address from ATA taskfile
 *      @tf: ATA taskfile of interest
 *      @dev: ATA device @tf belongs to
 *
 *      LOCKING:
 *      None.
 *
 *      Read block address from @tf.  This function can handle all
 *      three address formats - LBA, LBA48 and CHS.  tf->protocol and
 *      flags select the address format to use.
 *
 *      RETURNS:
 *      Block address read from @tf.
 */
u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev)
{
        u64 block = 0;

        if (tf->flags & ATA_TFLAG_LBA) {
                if (tf->flags & ATA_TFLAG_LBA48) {
                        block |= (u64)tf->hob_lbah << 40;
                        block |= (u64)tf->hob_lbam << 32;
                        block |= (u64)tf->hob_lbal << 24;
                } else
                        block |= (tf->device & 0xf) << 24;

                block |= tf->lbah << 16;
                block |= tf->lbam << 8;
                block |= tf->lbal;
        } else {
                u32 cyl, head, sect;

                cyl = tf->lbam | (tf->lbah << 8);
                head = tf->device & 0xf;
                sect = tf->lbal;

                block = (cyl * dev->heads + head) * dev->sectors + sect;
        }

        return block;
}

/**
 *      ata_build_rw_tf - Build ATA taskfile for given read/write request
 *      @tf: Target ATA taskfile
 *      @dev: ATA device @tf belongs to
 *      @block: Block address
 *      @n_block: Number of blocks
 *      @tf_flags: RW/FUA etc...
 *      @tag: tag
 *
 *      LOCKING:
 *      None.
 *
 *      Build ATA taskfile @tf for read/write request described by
 *      @block, @n_block, @tf_flags and @tag on @dev.
 *
 *      RETURNS:
 *
 *      0 on success, -ERANGE if the request is too large for @dev,
 *      -EINVAL if the request is invalid.
 */
int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev,
                    u64 block, u32 n_block, unsigned int tf_flags,
                    unsigned int tag)
{
        tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
        tf->flags |= tf_flags;

        if (ata_ncq_enabled(dev) && likely(tag != ATA_TAG_INTERNAL)) {
                /* yay, NCQ */
                if (!lba_48_ok(block, n_block))
                        return -ERANGE;

                tf->protocol = ATA_PROT_NCQ;
                tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;

                if (tf->flags & ATA_TFLAG_WRITE)
                        tf->command = ATA_CMD_FPDMA_WRITE;
                else
                        tf->command = ATA_CMD_FPDMA_READ;

                tf->nsect = tag << 3;
                tf->hob_feature = (n_block >> 8) & 0xff;
                tf->feature = n_block & 0xff;

                tf->hob_lbah = (block >> 40) & 0xff;
                tf->hob_lbam = (block >> 32) & 0xff;
                tf->hob_lbal = (block >> 24) & 0xff;
                tf->lbah = (block >> 16) & 0xff;
                tf->lbam = (block >> 8) & 0xff;
                tf->lbal = block & 0xff;

                tf->device = 1 << 6;
                if (tf->flags & ATA_TFLAG_FUA)
                        tf->device |= 1 << 7;
        } else if (dev->flags & ATA_DFLAG_LBA) {
                tf->flags |= ATA_TFLAG_LBA;

                if (lba_28_ok(block, n_block)) {
                        /* use LBA28 */
                        tf->device |= (block >> 24) & 0xf;
                } else if (lba_48_ok(block, n_block)) {
                        if (!(dev->flags & ATA_DFLAG_LBA48))
                                return -ERANGE;

                        /* use LBA48 */
                        tf->flags |= ATA_TFLAG_LBA48;

                        tf->hob_nsect = (n_block >> 8) & 0xff;

                        tf->hob_lbah = (block >> 40) & 0xff;
                        tf->hob_lbam = (block >> 32) & 0xff;
                        tf->hob_lbal = (block >> 24) & 0xff;
                } else
                        /* request too large even for LBA48 */
                        return -ERANGE;

                if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
                        return -EINVAL;

                tf->nsect = n_block & 0xff;

                tf->lbah = (block >> 16) & 0xff;
                tf->lbam = (block >> 8) & 0xff;
                tf->lbal = block & 0xff;

                tf->device |= ATA_LBA;
        } else {
                /* CHS */
                u32 sect, head, cyl, track;

                /* The request -may- be too large for CHS addressing. */
                if (!lba_28_ok(block, n_block))
                        return -ERANGE;

                if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
                        return -EINVAL;

                /* Convert LBA to CHS */
                track = (u32)block / dev->sectors;
                cyl   = track / dev->heads;
                head  = track % dev->heads;
                sect  = (u32)block % dev->sectors + 1;

                DPRINTK("block %u track %u cyl %u head %u sect %u\n",
                        (u32)block, track, cyl, head, sect);

                /* Check whether the converted CHS can fit.
                   Cylinder: 0-65535
                   Head: 0-15
                   Sector: 1-255*/
                if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
                        return -ERANGE;

                tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
                tf->lbal = sect;
                tf->lbam = cyl;
                tf->lbah = cyl >> 8;
                tf->device |= head;
        }

        return 0;
}

/**
 *      ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
 *      @pio_mask: pio_mask
 *      @mwdma_mask: mwdma_mask
 *      @udma_mask: udma_mask
 *
 *      Pack @pio_mask, @mwdma_mask and @udma_mask into a single
 *      unsigned int xfer_mask.
 *
 *      LOCKING:
 *      None.
 *
 *      RETURNS:
 *      Packed xfer_mask.
 */
unsigned long ata_pack_xfermask(unsigned long pio_mask,
                                unsigned long mwdma_mask,
                                unsigned long udma_mask)
{
        return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
                ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
                ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
}

/**
 *      ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
 *      @xfer_mask: xfer_mask to unpack
 *      @pio_mask: resulting pio_mask
 *      @mwdma_mask: resulting mwdma_mask
 *      @udma_mask: resulting udma_mask
 *
 *      Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
 *      Any NULL distination masks will be ignored.
 */
void ata_unpack_xfermask(unsigned long xfer_mask, unsigned long *pio_mask,
                         unsigned long *mwdma_mask, unsigned long *udma_mask)
{
        if (pio_mask)
                *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
        if (mwdma_mask)
                *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
        if (udma_mask)
                *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
}

static const struct ata_xfer_ent {
        int shift, bits;
        u8 base;
} ata_xfer_tbl[] = {
        { ATA_SHIFT_PIO, ATA_NR_PIO_MODES, XFER_PIO_0 },
        { ATA_SHIFT_MWDMA, ATA_NR_MWDMA_MODES, XFER_MW_DMA_0 },
        { ATA_SHIFT_UDMA, ATA_NR_UDMA_MODES, XFER_UDMA_0 },
        { -1, },
};

/**
 *      ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
 *      @xfer_mask: xfer_mask of interest
 *
 *      Return matching XFER_* value for @xfer_mask.  Only the highest
 *      bit of @xfer_mask is considered.
 *
 *      LOCKING:
 *      None.
 *
 *      RETURNS:
 *      Matching XFER_* value, 0xff if no match found.
 */
u8 ata_xfer_mask2mode(unsigned long xfer_mask)
{
        int highbit = fls(xfer_mask) - 1;
        const struct ata_xfer_ent *ent;

        for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
                if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
                        return ent->base + highbit - ent->shift;
        return 0xff;
}

/**
 *      ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
 *      @xfer_mode: XFER_* of interest
 *
 *      Return matching xfer_mask for @xfer_mode.
 *
 *      LOCKING:
 *      None.
 *
 *      RETURNS:
 *      Matching xfer_mask, 0 if no match found.
 */
unsigned long ata_xfer_mode2mask(u8 xfer_mode)
{
        const struct ata_xfer_ent *ent;

        for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
                if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
                        return ((2 << (ent->shift + xfer_mode - ent->base)) - 1)
                                & ~((1 << ent->shift) - 1);
        return 0;
}

/**
 *      ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
 *      @xfer_mode: XFER_* of interest
 *
 *      Return matching xfer_shift for @xfer_mode.
 *
 *      LOCKING:
 *      None.
 *
 *      RETURNS:
 *      Matching xfer_shift, -1 if no match found.
 */
int ata_xfer_mode2shift(unsigned long xfer_mode)
{
        const struct ata_xfer_ent *ent;

        for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
                if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
                        return ent->shift;
        return -1;
}

/**
 *      ata_mode_string - convert xfer_mask to string
 *      @xfer_mask: mask of bits supported; only highest bit counts.
 *
 *      Determine string which represents the highest speed
 *      (highest bit in @modemask).
 *
 *      LOCKING:
 *      None.
 *
 *      RETURNS:
 *      Constant C string representing highest speed listed in
 *      @mode_mask, or the constant C string "<n/a>".
 */
const char *ata_mode_string(unsigned long xfer_mask)
{
        static const char * const xfer_mode_str[] = {
                "PIO0",
                "PIO1",
                "PIO2",
                "PIO3",
                "PIO4",
                "PIO5",
                "PIO6",
                "MWDMA0",
                "MWDMA1",
                "MWDMA2",
                "MWDMA3",
                "MWDMA4",
                "UDMA/16",
                "UDMA/25",
                "UDMA/33",
                "UDMA/44",
                "UDMA/66",
                "UDMA/100",
                "UDMA/133",

                "UDMA7",
        };
        int highbit;

        highbit = fls(xfer_mask) - 1;
        if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
                return xfer_mode_str[highbit];
        return "<n/a>";
}

static const char *sata_spd_string(unsigned int spd)
{
        static const char * const spd_str[] = {
                "1.5 Gbps",
                "3.0 Gbps",
                "6.0 Gbps",
        };

        if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
                return "<unknown>";
        return spd_str[spd - 1];
}

static int ata_dev_set_dipm(struct ata_device *dev, enum link_pm policy)
{
        struct ata_link *link = dev->link;
        struct ata_port *ap = link->ap;
        u32 scontrol;
        unsigned int err_mask;
        int rc;

        /*
         * disallow DIPM for drivers which haven't set
         * ATA_FLAG_IPM.  This is because when DIPM is enabled,
         * phy ready will be set in the interrupt status on
         * state changes, which will cause some drivers to
         * think there are errors - additionally drivers will
         * need to disable hot plug.
         */
        if (!(ap->flags & ATA_FLAG_IPM) || !ata_dev_enabled(dev)) {
                ap->pm_policy = NOT_AVAILABLE;
                return -EINVAL;
        }

        /*
         * For DIPM, we will only enable it for the
         * min_power setting.
         *
         * Why?  Because Disks are too stupid to know that
         * If the host rejects a request to go to SLUMBER
         * they should retry at PARTIAL, and instead it
         * just would give up.  So, for medium_power to
         * work at all, we need to only allow HIPM.
         */
        rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
        if (rc)
                return rc;

        switch (policy) {
        case MIN_POWER:
                /* no restrictions on IPM transitions */
                scontrol &= ~(0x3 << 8);
                rc = sata_scr_write(link, SCR_CONTROL, scontrol);
                if (rc)
                        return rc;

                /* enable DIPM */
                if (dev->flags & ATA_DFLAG_DIPM)
                        err_mask = ata_dev_set_feature(dev,
                                        SETFEATURES_SATA_ENABLE, SATA_DIPM);
                break;
        case MEDIUM_POWER:
                /* allow IPM to PARTIAL */
                scontrol &= ~(0x1 << 8);
                scontrol |= (0x2 << 8);
                rc = sata_scr_write(link, SCR_CONTROL, scontrol);
                if (rc)
                        return rc;

                /*
                 * we don't have to disable DIPM since IPM flags
                 * disallow transitions to SLUMBER, which effectively
                 * disable DIPM if it does not support PARTIAL
                 */
                break;
        case NOT_AVAILABLE:
        case MAX_PERFORMANCE:
                /* disable all IPM transitions */
                scontrol |= (0x3 << 8);
                rc = sata_scr_write(link, SCR_CONTROL, scontrol);
                if (rc)
                        return rc;

                /*
                 * we don't have to disable DIPM since IPM flags
                 * disallow all transitions which effectively
                 * disable DIPM anyway.
                 */
                break;
        }

        /* FIXME: handle SET FEATURES failure */
        (void) err_mask;

        return 0;
}

/**
 *      ata_dev_enable_pm - enable SATA interface power management
 *      @dev:  device to enable power management
 *      @policy: the link power management policy
 *
 *      Enable SATA Interface power management.  This will enable
 *      Device Interface Power Management (DIPM) for min_power
 *      policy, and then call driver specific callbacks for
 *      enabling Host Initiated Power management.
 *
 *      Locking: Caller.
 *      Returns: -EINVAL if IPM is not supported, 0 otherwise.
 */
void ata_dev_enable_pm(struct ata_device *dev, enum link_pm policy)
{
        int rc = 0;
        struct ata_port *ap = dev->link->ap;

        /* set HIPM first, then DIPM */
        if (ap->ops->enable_pm)
                rc = ap->ops->enable_pm(ap, policy);
        if (rc)
                goto enable_pm_out;
        rc = ata_dev_set_dipm(dev, policy);

enable_pm_out:
        if (rc)
                ap->pm_policy = MAX_PERFORMANCE;
        else
                ap->pm_policy = policy;
        return /* rc */;        /* hopefully we can use 'rc' eventually */
}

#ifdef CONFIG_PM
/**
 *      ata_dev_disable_pm - disable SATA interface power management
 *      @dev: device to disable power management
 *
 *      Disable SATA Interface power management.  This will disable
 *      Device Interface Power Management (DIPM) without changing
 *      policy,  call driver specific callbacks for disabling Host
 *      Initiated Power management.
 *
 *      Locking: Caller.
 *      Returns: void
 */
static void ata_dev_disable_pm(struct ata_device *dev)
{
        struct ata_port *ap = dev->link->ap;

        ata_dev_set_dipm(dev, MAX_PERFORMANCE);
        if (ap->ops->disable_pm)
                ap->ops->disable_pm(ap);
}
#endif  /* CONFIG_PM */

void ata_lpm_schedule(struct ata_port *ap, enum link_pm policy)
{
        ap->pm_policy = policy;
        ap->link.eh_info.action |= ATA_EH_LPM;
        ap->link.eh_info.flags |= ATA_EHI_NO_AUTOPSY;
        ata_port_schedule_eh(ap);
}

#ifdef CONFIG_PM
static void ata_lpm_enable(struct ata_host *host)
{
        struct ata_link *link;
        struct ata_port *ap;
        struct ata_device *dev;
        int i;

        for (i = 0; i < host->n_ports; i++) {
                ap = host->ports[i];
                ata_for_each_link(link, ap, EDGE) {
                        ata_for_each_dev(dev, link, ALL)
                                ata_dev_disable_pm(dev);
                }
        }
}

static void ata_lpm_disable(struct ata_host *host)
{
        int i;

        for (i = 0; i < host->n_ports; i++) {
                struct ata_port *ap = host->ports[i];
                ata_lpm_schedule(ap, ap->pm_policy);
        }
}
#endif  /* CONFIG_PM */

/**
 *      ata_dev_classify - determine device type based on ATA-spec signature
 *      @tf: ATA taskfile register set for device to be identified
 *
 *      Determine from taskfile register contents whether a device is
 *      ATA or ATAPI, as per "Signature and persistence" section
 *      of ATA/PI spec (volume 1, sect 5.14).
 *
 *      LOCKING:
 *      None.
 *
 *      RETURNS:
 *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP or
 *      %ATA_DEV_UNKNOWN the event of failure.
 */
unsigned int ata_dev_classify(const struct ata_taskfile *tf)
{
        /* Apple's open source Darwin code hints that some devices only
         * put a proper signature into the LBA mid/high registers,
         * So, we only check those.  It's sufficient for uniqueness.
         *
         * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate
         * signatures for ATA and ATAPI devices attached on SerialATA,
         * 0x3c/0xc3 and 0x69/0x96 respectively.  However, SerialATA
         * spec has never mentioned about using different signatures
         * for ATA/ATAPI devices.  Then, Serial ATA II: Port
         * Multiplier specification began to use 0x69/0x96 to identify
         * port multpliers and 0x3c/0xc3 to identify SEMB device.
         * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and
         * 0x69/0x96 shortly and described them as reserved for
         * SerialATA.
         *
         * We follow the current spec and consider that 0x69/0x96
         * identifies a port multiplier and 0x3c/0xc3 a SEMB device.
         * Unfortunately, WDC WD1600JS-62MHB5 (a hard drive) reports
         * SEMB signature.  This is worked around in
         * ata_dev_read_id().
         */
        if ((tf->lbam == 0) && (tf->lbah == 0)) {
                DPRINTK("found ATA device by sig\n");
                return ATA_DEV_ATA;
        }

        if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) {
                DPRINTK("found ATAPI device by sig\n");
                return ATA_DEV_ATAPI;
        }

        if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) {
                DPRINTK("found PMP device by sig\n");
                return ATA_DEV_PMP;
        }

        if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) {
                DPRINTK("found SEMB device by sig (could be ATA device)\n");
                return ATA_DEV_SEMB;
        }

        DPRINTK("unknown device\n");
        return ATA_DEV_UNKNOWN;
}

/**
 *      ata_id_string - Convert IDENTIFY DEVICE page into string
 *      @id: IDENTIFY DEVICE results we will examine
 *      @s: string into which data is output
 *      @ofs: offset into identify device page
 *      @len: length of string to return. must be an even number.
 *
 *      The strings in the IDENTIFY DEVICE page are broken up into
 *      16-bit chunks.  Run through the string, and output each
 *      8-bit chunk linearly, regardless of platform.
 *
 *      LOCKING:
 *      caller.
 */

void ata_id_string(const u16 *id, unsigned char *s,
                   unsigned int ofs, unsigned int len)
{
        unsigned int c;

        BUG_ON(len & 1);

        while (len > 0) {
                c = id[ofs] >> 8;
                *s = c;
                s++;

                c = id[ofs] & 0xff;
                *s = c;
                s++;

                ofs++;
                len -= 2;
        }
}

/**
 *      ata_id_c_string - Convert IDENTIFY DEVICE page into C string
 *      @id: IDENTIFY DEVICE results we will examine
 *      @s: string into which data is output
 *      @ofs: offset into identify device page
 *      @len: length of string to return. must be an odd number.
 *
 *      This function is identical to ata_id_string except that it
 *      trims trailing spaces and terminates the resulting string with
 *      null.  @len must be actual maximum length (even number) + 1.
 *
 *      LOCKING:
 *      caller.
 */
void ata_id_c_string(const u16 *id, unsigned char *s,
                     unsigned int ofs, unsigned int len)
{
        unsigned char *p;

        ata_id_string(id, s, ofs, len - 1);

        p = s + strnlen(s, len - 1);
        while (p > s && p[-1] == ' ')
                p--;
        *p = '\0';
}

static u64 ata_id_n_sectors(const u16 *id)
{
        if (ata_id_has_lba(id)) {
                if (ata_id_has_lba48(id))
                        return ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
                else
                        return ata_id_u32(id, ATA_ID_LBA_CAPACITY);
        } else {
                if (ata_id_current_chs_valid(id))
                        return id[ATA_ID_CUR_CYLS] * id[ATA_ID_CUR_HEADS] *
                               id[ATA_ID_CUR_SECTORS];
                else
                        return id[ATA_ID_CYLS] * id[ATA_ID_HEADS] *
                               id[ATA_ID_SECTORS];
        }
}

u64 ata_tf_to_lba48(const struct ata_taskfile *tf)
{
        u64 sectors = 0;

        sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40;
        sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32;
        sectors |= ((u64)(tf->hob_lbal & 0xff)) << 24;
        sectors |= (tf->lbah & 0xff) << 16;
        sectors |= (tf->lbam & 0xff) << 8;
        sectors |= (tf->lbal & 0xff);

        return sectors;
}

u64 ata_tf_to_lba(const struct ata_taskfile *tf)
{
        u64 sectors = 0;

        sectors |= (tf->device & 0x0f) << 24;
        sectors |= (tf->lbah & 0xff) << 16;
        sectors |= (tf->lbam & 0xff) << 8;
        sectors |= (tf->lbal & 0xff);

        return sectors;
}

/**
 *      ata_read_native_max_address - Read native max address
 *      @dev: target device
 *      @max_sectors: out parameter for the result native max address
 *
 *      Perform an LBA48 or LBA28 native size query upon the device in
 *      question.
 *
 *      RETURNS:
 *      0 on success, -EACCES if command is aborted by the drive.
 *      -EIO on other errors.
 */
static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
{
        unsigned int err_mask;
        struct ata_taskfile tf;
        int lba48 = ata_id_has_lba48(dev->id);

        ata_tf_init(dev, &tf);

        /* always clear all address registers */
        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;

        if (lba48) {
                tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
                tf.flags |= ATA_TFLAG_LBA48;
        } else
                tf.command = ATA_CMD_READ_NATIVE_MAX;

        tf.protocol |= ATA_PROT_NODATA;
        tf.device |= ATA_LBA;

        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
        if (err_mask) {
                ata_dev_printk(dev, KERN_WARNING, "failed to read native "
                               "max address (err_mask=0x%x)\n", err_mask);
                if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
                        return -EACCES;
                return -EIO;
        }

        if (lba48)
                *max_sectors = ata_tf_to_lba48(&tf) + 1;
        else
                *max_sectors = ata_tf_to_lba(&tf) + 1;
        if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
                (*max_sectors)--;
        return 0;
}

/**
 *      ata_set_max_sectors - Set max sectors
 *      @dev: target device
 *      @new_sectors: new max sectors value to set for the device
 *
 *      Set max sectors of @dev to @new_sectors.
 *
 *      RETURNS:
 *      0 on success, -EACCES if command is aborted or denied (due to
 *      previous non-volatile SET_MAX) by the drive.  -EIO on other
 *      errors.
 */
static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors)
{
        unsigned int err_mask;
        struct ata_taskfile tf;
        int lba48 = ata_id_has_lba48(dev->id);

        new_sectors--;

        ata_tf_init(dev, &tf);

        tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;

        if (lba48) {
                tf.command = ATA_CMD_SET_MAX_EXT;
                tf.flags |= ATA_TFLAG_LBA48;

                tf.hob_lbal = (new_sectors >> 24) & 0xff;
                tf.hob_lbam = (new_sectors >> 32) & 0xff;
                tf.hob_lbah = (new_sectors >> 40) & 0xff;
        } else {
                tf.command = ATA_CMD_SET_MAX;

                tf.device |= (new_sectors >> 24) & 0xf;
        }

        tf.protocol |= ATA_PROT_NODATA;
        tf.device |= ATA_LBA;

        tf.lbal = (new_sectors >> 0) & 0xff;
        tf.lbam = (new_sectors >> 8) & 0xff;
        tf.lbah = (new_sectors >> 16) & 0xff;

        err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
        if (err_mask) {
                ata_dev_printk(dev, KERN_WARNING, "failed to set "
                               "max address (err_mask=0x%x)\n", err_mask);
                if (err_mask == AC_ERR_DEV &&
                    (tf.feature & (ATA_ABORTED | ATA_IDNF)))
                        return -EACCES;
                return -EIO;
        }

        return 0;
}

/**
 *      ata_hpa_resize          -       Resize a device with an HPA set
 *      @dev: Device to resize
 *
 *      Read the size of an LBA28 or LBA48 disk with HPA features and resize
 *      it if required to the full size of the media. The caller must check
 *      the drive has the HPA feature set enabled.
 *
 *      RETURNS:
 *      0 on success, -errno on failure.
 */
static int ata_hpa_resize(struct ata_device *dev)
{
        struct ata_eh_context *ehc = &dev->link->eh_context;
        int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
        u64 sectors = ata_id_n_sectors(dev->id);
        u64 native_sectors;
        int rc;

        /* do we need to do it? */
        if (dev->class != ATA_DEV_ATA ||
            !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) ||
            (dev->horkage & ATA_HORKAGE_BROKEN_HPA))
                return 0;

        /* read native max address */
        rc = ata_read_native_max_address(dev, &native_sectors);
        if (rc) {
                /* If device aborted the command or HPA isn't going to
                 * be unlocked, skip HPA resizing.
                 */
                if (rc == -EACCES || !ata_ignore_hpa) {
                        ata_dev_printk(dev, KERN_WARNING, "HPA support seems "
                                       "broken, skipping HPA handling\n");
                        dev->horkage |= ATA_HORKAGE_BROKEN_HPA;

                        /* we can continue if device aborted the command */
                        if (rc == -EACCES)
                                rc = 0;
                }

                return rc;
        }

        /* nothing to do? */
        if (native_sectors <= sectors || !ata_ignore_hpa) {
                if (!print_info || native_sectors == sectors)
                        return 0;

                if (native_sectors > sectors)
                        ata_dev_printk(dev, KERN_INFO,
                                "HPA detected: current %llu, native %llu\n",
                                (unsigned long long)sectors,
                                (unsigned long long)native_sectors);
                else if (native_sectors < sectors)
                        ata_dev_printk(dev, KERN_WARNING,
                                "native sectors (%llu) is smaller than "
                                "sectors (%llu)\n",
                                (unsigned long long)native_sectors,
                                (unsigned long long)sectors);
                return 0;
        }

        /* let's unlock HPA */
        rc = ata_set_max_sectors(dev, native_sectors);
        if (rc == -EACCES) {
                /* if device aborted the command, skip HPA resizing */
                ata_dev_printk(dev, KERN_WARNING, "device aborted resize "
                               "(%llu -> %llu), skipping HPA handling\n",
                               (unsigned long long)sectors,
                               (unsigned long long)native_sectors);
                dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
                return 0;
        } else if (rc)
                return rc;

        /* re-read IDENTIFY data */
        rc = ata_dev_reread_id(dev, 0);
        if (rc) {
                ata_dev_printk(dev, KERN_ERR, "failed to re-read IDENTIFY "
                               "data after HPA resizing\n");
                return rc;
        }

        if (print_info) {
                u64 new_sectors = ata_id_n_sectors(dev->id);
                ata_dev_printk(dev, KERN_INFO,
                        "HPA unlocked: %llu -> %llu, native %llu\n",
                        (unsigned long long)sectors,
                        (unsigned long long)new_sectors,
                        (unsigned long long)native_sectors);
        }

        return 0;
}

/**
 *      ata_dump_id - IDENTIFY DEVICE info debugging output
 *      @id: IDENTIFY DEVICE page to dump
 *
 *      Dump selected 16-bit words from the given IDENTIFY DEVICE
 *      page.
 *
 *      LOCKING:
 *      caller.
 */

static inline void ata_dump_id(const u16 *id)
{
        DPRINTK("49==0x%04x  "
                "53==0x%04x  "
                "63==0x%04x  "
                "64==0x%04x  "
                "75==0x%04x  \n",
                id[49],
                id[53],
                id[63],
                id[64],
                id[75]);
        DPRINTK("80==0x%04x  "
                "81==0x%04x  "
                "82==0x%04x  "
                "83==0x%04x  "
                "84==0x%04x  \n",
                id[80],
                id[81],
                id[82],
                id[83],
                id[84]);
        DPRINTK("88==0x%04x  "
                "93==0x%04x\n",
                id[88],
                id[93]);
}

/**
 *      ata_id_xfermask - Compute xfermask from the given IDENTIFY data
 *      @id: IDENTIFY data to compute xfer mask from
 *
 *      Compute the xfermask for this device. This is not as trivial
 *      as it seems if we must consider early devices correctly.
 *
 *      FIXME: pre IDE drive timing (do we care ?).
 *
 *      LOCKING:
 *      None.
 *
 *      RETURNS:
 *      Computed xfermask
 */
unsigned long ata_id_xfermask(const u16 *id)
{
        unsigned long pio_mask, mwdma_mask, udma_mask;

        /* Usual case. Word 53 indicates word 64 is valid */
        if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
                pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
                pio_mask <<= 3;
                pio_mask |= 0x7;
        } else {
                /* If word 64 isn't valid then Word 51 high byte holds
                 * the PIO timing number for the maximum. Turn it into
                 * a mask.
                 */
                u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
                if (mode < 5)   /* Valid PIO range */
                        pio_mask = (2 << mode) - 1;
                else
                        pio_mask = 1;

                /* But wait.. there's more. Design your standards by
                 * committee and you too can get a free iordy field to
                 * process. However its the speeds not the modes that
                 * are supported... Note drivers using the timing API
                 * will get this right anyway
                 */
        }

        mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;

        if (ata_id_is_cfa(id)) {
                /*
                 *      Process compact flash extended modes
                 */
                int pio = (id[ATA_ID_CFA_MODES] >> 0) & 0x7;
                int dma = (id[ATA_ID_CFA_MODES] >> 3) & 0x7;

                if (pio)
                        pio_mask |= (1 << 5);
                if (pio > 1)
                        pio_mask |= (1 << 6);
                if (dma)
                        mwdma_mask |= (1 << 3);
                if (dma > 1)
                        mwdma_mask |= (1 << 4);
        }

        udma_mask = 0;
        if (id[ATA_ID_FIELD_VALID] & (1 << 2))
                udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;

        return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
}

/**
 *      ata_pio_queue_task - Queue port_task
 *      @ap: The ata_port to queue port_task for
 *      @data: data for @fn to use
 *      @delay: delay time in msecs for workqueue function
 *
 *      Schedule @fn(@data) for execution after @delay jiffies using
 *      port_task.  There is one port_task per port and it's the
 *      user(low level driver)'s responsibility to make sure that only
 *      one task is active at any given time.
 *
 *      libata core layer takes care of synchronization between
 *      port_task and EH.  ata_pio_queue_task() may be ignored for EH
 *      synchronization.
 *
 *      LOCKING:
 *      Inherited from caller.
 */
void ata_pio_queue_task(struct ata_port *ap, void *data, unsigned long delay)
{
        ap->port_task_data = data;

        /* may fail if ata_port_flush_task() in progress */
        queue_delayed_work(ata_wq, &ap->port_task, msecs_to_jiffies(delay));
}

/**
 *      ata_port_flush_task - Flush port_task
 *      @ap: The ata_port to flush port_task for
 *
 *      After this function completes, port_task is guranteed not to
 *      be running or scheduled.
 *
 *      LOCKING:
 *      Kernel thread context (may sleep)
 */
void ata_port_flush_task(struct ata_port *ap)
{
        DPRINTK("ENTER\n");

        cancel_rearming_delayed_work(&ap->port_task);

        if (ata_msg_ctl(ap))
                ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __func__);
}

static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
{
        struct completion *waiting = qc->private_data;

        complete(waiting);
}

/**
 *      ata_exec_internal_sg - execute libata internal command
 *      @dev: Device to which the command is sent
 *      @tf: Taskfile registers for the command and the result
 *      @cdb: CDB for packet command
 *      @dma_dir: Data tranfer direction of the command
 *      @sgl: sg list for the data buffer of the command
 *      @n_elem: Number of sg entries
 *      @timeout: Timeout in msecs (0 for default)
 *
 *      Executes libata internal command with timeout.  @tf contains
 *      command on entry and result on return.  Timeout and error
 *      conditions are reported via return value.  No recovery action
 *      is taken after a command times out.  It's caller's duty to
 *      clean up after timeout.
 *
 *      LOCKING:
 *      None.  Should be called with kernel context, might sleep.
 *
 *      RETURNS:
 *      Zero on success, AC_ERR_* mask on failure
 */
unsigned ata_exec_internal_sg(struct ata_device *dev,
                              struct ata_taskfile *tf, const u8 *cdb,
                              int dma_dir, struct scatterlist *sgl,
                              unsigned int n_elem, unsigned long timeout)
{
        struct ata_link *link = dev->link;
        struct ata_port *ap = link->ap;
        u8 command = tf->command;
        int auto_timeout = 0;
        struct ata_queued_cmd *qc;
        unsigned int tag, preempted_tag;
        u32 preempted_sactive, preempted_qc_active;
        int preempted_nr_active_links;
        DECLARE_COMPLETION_ONSTACK(wait);
        unsigned long flags;
        unsigned int err_mask;
        int rc;

        spin_lock_irqsave(ap->lock, flags);

        /* no internal command while frozen */
        if (ap->pflags & ATA_PFLAG_FROZEN) {
                spin_unlock_irqrestore(ap->lock, flags);
                return AC_ERR_SYSTEM;
        }

        /* initialize internal qc */

        /* XXX: Tag 0 is used for drivers with legacy EH as some
         * drivers choke if any other tag is given.  This breaks
         * ata_tag_internal() test for those drivers.  Don't use new
         * EH stuff without converting to it.
         */
        if (ap->ops->error_handler)
                tag = ATA_TAG_INTERNAL;
        else
                tag = 0;

        if (test_and_set_bit(tag, &ap->qc_allocated))
                BUG();
        qc = __ata_qc_from_tag(ap, tag);

        qc->tag = tag;
        qc->scsicmd = NULL;
        qc->ap = ap;
        qc->dev = dev;
        ata_qc_reinit(qc);

        preempted_tag = link->active_tag;
        preempted_sactive = link->sactive;
        preempted_qc_active = ap->qc_active;
        preempted_nr_active_links = ap->nr_active_links;
        link->active_tag = ATA_TAG_POISON;
        link->sactive = 0;
        ap->qc_active = 0;
        ap->nr_active_links = 0;

        /* prepare & issue qc */
        qc->tf = *tf;
        if (cdb)
                memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
        qc->flags |= ATA_QCFLAG_RESULT_TF;
        qc->dma_dir = dma_dir;
        if (dma_dir != DMA_NONE) {
                unsigned int i, buflen = 0;
                struct scatterlist *sg;

                for_each_sg(sgl, sg, n_elem, i)
                        buflen += sg->length;

                ata_sg_init(qc, sgl, n_elem);
                qc->nbytes = buflen;
        }

        qc->private_data = &wait;
        qc->complete_fn = ata_qc_complete_internal;

        ata_qc_issue(qc);

        spin_unlock_irqrestore(ap->lock, flags);

        if (!timeout) {
                if (ata_probe_timeout)
                        timeout = ata_probe_timeout * 1000;
                else {
                        timeout = ata_internal_cmd_timeout(dev, command);
                        auto_timeout = 1;
                }
        }

        rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));

        ata_port_flush_task(ap);

        if (!rc) {
                spin_lock_irqsave(ap->lock, flags);

                /* We're racing with irq here.  If we lose, the
                 * following test prevents us from completing the qc
                 * twice.  If we win, the port is frozen and will be
                 * cleaned up by ->post_internal_cmd().
                 */
                if (qc->flags & ATA_QCFLAG_ACTIVE) {
                        qc->err_mask |= AC_ERR_TIMEOUT;

                        if (ap->ops->error_handler)
                                ata_port_freeze(ap);
                        else
                                ata_qc_complete(qc);

                        if (ata_msg_warn(ap))
                                ata_dev_printk(dev, KERN_WARNING,
                                        "qc timeout (cmd 0x%x)\n", command);
                }

                spin_unlock_irqrestore(ap->lock, flags);
        }

        /* do post_internal_cmd */
        if (ap->ops->post_internal_cmd)
                ap->ops->post_internal_cmd(qc);

        /* perform minimal error analysis */
        if (qc->flags & ATA_QCFLAG_FAILED) {
                if (qc->result_tf.command & (ATA_ERR | ATA_DF))
                        qc->err_mask |= AC_ERR_DEV;

                if (!qc->err_mask)
                        qc->err_mask |= AC_ERR_OTHER;

                if (qc->err_mask & ~AC_ERR_OTHER)
                        qc->err_mask &= ~AC_ERR_OTHER;
        }

        /* finish up */
        spin_lock_irqsave(ap->lock, flags);

        *tf = qc->result_tf;
        err_mask = qc->err_mask;

        ata_qc_free(qc);
        link->active_tag = preempted_tag;
        link->sactive = preempted_sactive;
        ap->qc_active = preempted_qc_active;
        ap->nr_active_links = preempted_nr_active_links;

        /* XXX - Some LLDDs (sata_mv) disable port on command failure.
         * Until those drivers are fixed, we detect the condition
         * here, fail the command with AC_ERR_SYSTEM and reenable the
         * port.
         *
         * Note that this doesn't change any behavior as internal
         * command failure results in disabling the device in the
         * higher layer for LLDDs without new reset/EH callbacks.
         *
         * Kill the following code as soon as those drivers are fixed.
         */
        if (ap->flags & ATA_FLAG_DISABLED) {
                err_mask |= AC_ERR_SYSTEM;
                ata_port_probe(ap);
        }

        spin_unlock_irqrestore(ap->lock, flags);

        if ((err_mask & AC_ERR_TIMEOUT) && auto_timeout)
                ata_internal_cmd_timed_out(dev, command);

        return err_mask;
}

/**
 *      ata_exec_internal - execute libata internal command
 *      @dev: Device to which the command is sent
 *      @tf: Taskfile registers for the command and the result
 *      @cdb: CDB for packet command
 *      @dma_dir: Data tranfer direction of the command
 *      @buf: Data buffer of the command
 *      @buflen: Length of data buffer
 *      @timeout: Timeout in msecs (0 for default)
 *
 *      Wrapper around ata_exec_internal_sg() which takes simple
 *      buffer instead of sg list.
 *
 *      LOCKING:
 *      None.  Should be called with kernel context, might sleep.
 *
 *      RETURNS:
 *      Zero on success, AC_ERR_* mask on failure
 */
unsigned ata_exec_internal(struct ata_device *dev,
                           struct ata_taskfile *tf, const u8 *cdb,
                           int dma_dir, void *buf, unsigned int buflen,
                           unsigned long timeout)
{
        struct scatterlist *psg = NULL, sg;
        unsigned int n_elem = 0;

        if (dma_dir != DMA_NONE) {
                WARN_ON(!buf);
                sg_init_one(&sg, buf, buflen);
                psg = &sg;
                n_elem++;
        }

        return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem,
                                    timeout);
}

/**
 *      ata_do_simple_cmd - execute simple internal command
 *      @dev: Device to which the command is sent
 *      @cmd: Opcode to execute
 *
 *      Execute a 'simple' command, that only consists of the opcode
 *      'cmd' itself, without filling any other registers
 *
 *      LOCKING:
 *      Kernel thread context (may sleep).
 *
 *      RETURNS:
 *      Zero on success, AC_ERR_* mask on failure
 */
unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
{
        struct ata_taskfile tf;

        ata_tf_init(dev, &tf);

        tf.command = cmd;
        tf.flags |= ATA_TFLAG_DEVICE;
        tf.protocol = ATA_PROT_NODATA;

        return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
}

/**
 *      ata_pio_need_iordy      -       check if iordy needed
 *      @adev: ATA device
 *
 *      Check if the current speed of the device requires IORDY. Used
 *      by various controllers for chip configuration.
 */

unsigned int ata_pio_need_iordy(const struct ata_device *adev)
{
        /* Controller doesn't support  IORDY. Probably a pointless check
           as the caller should know this */