/*

   *  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 <linux/slab.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 <linux/ratelimit.h>

  #include <linux/pm_runtime.h>

  
  #include "libata.h"

  #include "libata-transport.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 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;

  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 [default])");

  static int atapi_dmadir = 0;

  module_param(atapi_dmadir, int, 0444);

  MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off [default], 1=on)");

  int atapi_passthru16 = 1;
  module_param(atapi_passthru16, int, 0444);

  MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices (0=off, 1=on [default])");

  int libata_fua = 0;
  module_param_named(fua, libata_fua, int, 0444);

  MODULE_PARM_DESC(fua, "FUA support (0=off [default], 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, "Disable the use of ACPI in probe/suspend/resume (0=off [default], 1=on)");

  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 (0=off [default], 1=on)");

  static int atapi_an;
  module_param(atapi_an, int, 0444);
  MODULE_PARM_DESC(atapi_an, "Enable ATAPI AN media presence notification (0=0ff [default], 1=on)");

  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_notice(ap, "FORCE: cable set to %s
  ", 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_notice(link, "FORCE: PHY spd limit set to %s
  ",

  					fe->param.name);
  			did_spd = true;
  		}

  		/* let lflags stack */
  		if (fe->param.lflags) {
  			link->flags |= fe->param.lflags;

  			ata_link_notice(link,

  					"FORCE: link flag 0x%x forced -> 0x%x
  ",
  					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_notice(dev, "FORCE: xfer_mask set to %s
  ",
  			       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_notice(dev, "FORCE: horkage modified (%s)
  ",
  			       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;

  		if (!sect) {

  			ata_dev_warn(dev,
  				     "device reported invalid CHS sector 0
  ");

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

  	}
  
  	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
  ",
  			(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>";

  }

  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];
  }

  /**

   *	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
  ");
  		return ATA_DEV_ATA;
  	}

  	if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) {

  		DPRINTK("found ATAPI device by sig
  ");
  		return ATA_DEV_ATAPI;
  	}

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

  		DPRINTK("found SEMB device by sig (could be ATA device)
  ");
  		return ATA_DEV_SEMB;

  	}

  	DPRINTK("unknown device
  ");
  	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_warn(dev,
  			     "failed to read native max address (err_mask=0x%x)
  ",
  			     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_warn(dev,
  			     "failed to set max address (err_mask=0x%x)
  ",
  			     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;

  	bool unlock_hpa = ata_ignore_hpa || dev->flags & ATA_DFLAG_UNLOCK_HPA;

  	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 || !unlock_hpa) {

  			ata_dev_warn(dev,
  				     "HPA support seems broken, skipping HPA handling
  ");

  			dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
  
  			/* we can continue if device aborted the command */
  			if (rc == -EACCES)
  				rc = 0;

  		}

  		return rc;
  	}

  	dev->n_native_sectors = native_sectors;

  
  	/* nothing to do? */

  	if (native_sectors <= sectors || !unlock_hpa) {

  		if (!print_info || native_sectors == sectors)
  			return 0;
  
  		if (native_sectors > sectors)

  			ata_dev_info(dev,

  				"HPA detected: current %llu, native %llu
  ",
  				(unsigned long long)sectors,
  				(unsigned long long)native_sectors);
  		else if (native_sectors < sectors)

  			ata_dev_warn(dev,
  				"native sectors (%llu) is smaller than sectors (%llu)
  ",

  				(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_warn(dev,
  			     "device aborted resize (%llu -> %llu), skipping HPA handling
  ",
  			     (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_err(dev,
  			    "failed to re-read IDENTIFY data after HPA resizing
  ");

  		return rc;
  	}
  
  	if (print_info) {
  		u64 new_sectors = ata_id_n_sectors(dev->id);

  		ata_dev_info(dev,

  			"HPA unlocked: %llu -> %llu, native %llu
  ",
  			(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  
  ",

  		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  
  ",

  		id[80],
  		id[81],
  		id[82],
  		id[83],
  		id[84]);

  	DPRINTK("88==0x%04x  "
  		"93==0x%04x
  ",

  		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);
  }

  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;
  		}
  	}

  	if (ap->ops->error_handler)
  		ata_eh_release(ap);

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

  	if (ap->ops->error_handler)
  		ata_eh_acquire(ap);

  	ata_sff_flush_pio_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_warn(dev, "qc timeout (cmd 0x%x)
  ",
  					     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;

  	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)
  {

  	/* Don't set IORDY if we're preparing for reset.  IORDY may
  	 * lead to controller lock up on certain controllers if the
  	 * port is not occupied.  See bko#11703 for details.
  	 */
  	if (adev->link->ap->pflags & ATA_PFLAG_RESETTING)
  		return 0;
  	/* Controller doesn't support IORDY.  Probably a pointless
  	 * check as the caller should know this.
  	 */

  	if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)

  		return 0;

  	/* CF spec. r4.1 Table 22 says no iordy on PIO5 and PIO6.  */
  	if (ata_id_is_cfa(adev->id)
  	    && (adev->pio_mode == XFER_PIO_5 || adev->pio_mode == XFER_PIO_6))
  		return 0;

  	/* PIO3 and higher it is mandatory */
  	if (adev->pio_mode > XFER_PIO_2)
  		return 1;
  	/* We turn it on when possible */
  	if (ata_id_has_iordy(adev->id))

  		return 1;

  	return 0;
  }

  /**
   *	ata_pio_mask_no_iordy	-	Return the non IORDY mask
   *	@adev: ATA device
   *
   *	Compute the highest mode possible if we are not using iordy. Return
   *	-1 if no iordy mode is available.
   */

  static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
  {

  	/* If we have no drive specific rule, then PIO 2 is non IORDY */

  	if (adev->id[ATA_ID_FIELD_VALID] & 2) {	/* EIDE */

  		u16 pio = adev->id[ATA_ID_EIDE_PIO];

  		/* Is the speed faster than the drive allows non IORDY ? */
  		if (pio) {
  			/* This is cycle times not frequency - watch the logic! */
  			if (pio > 240)	/* PIO2 is 240nS per cycle */

  				return 3 << ATA_SHIFT_PIO;
  			return 7 << ATA_SHIFT_PIO;

  		}
  	}

  	return 3 << ATA_SHIFT_PIO;

  }
  
  /**

   *	ata_do_dev_read_id		-	default ID read method
   *	@dev: device
   *	@tf: proposed taskfile
   *	@id: data buffer
   *
   *	Issue the identify taskfile and hand back the buffer containing
   *	identify data. For some RAID controllers and for pre ATA devices
   *	this function is wrapped or replaced by the driver
   */
  unsigned int ata_do_dev_read_id(struct ata_device *dev,
  					struct ata_taskfile *tf, u16 *id)
  {
  	return ata_exec_internal(dev, tf, NULL, DMA_FROM_DEVICE,
  				     id, sizeof(id[0]) * ATA_ID_WORDS, 0);
  }
  
  /**

   *	ata_dev_read_id - Read ID data from the specified device

   *	@dev: target device
   *	@p_class: pointer to class of the target device (may be changed)

   *	@flags: ATA_READID_* flags

   *	@id: buffer to read IDENTIFY data into

   *

   *	Read ID data from the specified device.  ATA_CMD_ID_ATA is
   *	performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI

   *	devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
   *	for pre-ATA4 drives.

   *

   *	FIXME: ATA_CMD_ID_ATA is optional for early drives and right

   *	now we abort if we hit that case.

   *

   *	LOCKING:

   *	Kernel thread context (may sleep)
   *
   *	RETURNS:
   *	0 on success, -errno otherwise.

   */

  int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,

  		    unsigned int flags, u16 *id)

  {

  	struct ata_port *ap = dev->link->ap;

  	unsigned int class = *p_class;

  	struct ata_taskfile tf;

  	unsigned int err_mask = 0;
  	const char *reason;

  	bool is_semb = class == ATA_DEV_SEMB;

  	int may_fallback = 1, tried_spinup = 0;

  	int rc;

  	if (ata_msg_ctl(ap))

  		ata_dev_dbg(dev, "%s: ENTER
  ", __func__);

  retry:

  	ata_tf_init(dev, &tf);

  	switch (class) {

  	case ATA_DEV_SEMB:
  		class = ATA_DEV_ATA;	/* some hard drives report SEMB sig */

  	case ATA_DEV_ATA:

  		tf.command = ATA_CMD_ID_ATA;

  		break;
  	case ATA_DEV_ATAPI:

  		tf.command = ATA_CMD_ID_ATAPI;

  		break;
  	default:
  		rc = -ENODEV;
  		reason = "unsupported class";
  		goto err_out;

  	}

  	tf.protocol = ATA_PROT_PIO;

  
  	/* Some devices choke if TF registers contain garbage.  Make
  	 * sure those are properly initialized.
  	 */
  	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
  
  	/* Device presence detection is unreliable on some
  	 * controllers.  Always poll IDENTIFY if available.
  	 */
  	tf.flags |= ATA_TFLAG_POLLING;

  	if (ap->ops->read_id)
  		err_mask = ap->ops->read_id(dev, &tf, id);
  	else
  		err_mask = ata_do_dev_read_id(dev, &tf, id);

  	if (err_mask) {

  		if (err_mask & AC_ERR_NODEV_HINT) {

  			ata_dev_dbg(dev, "NODEV after polling detection
  ");

  			return -ENOENT;
  		}

  		if (is_semb) {

  			ata_dev_info(dev,
  		     "IDENTIFY failed on device w/ SEMB sig, disabled
  ");

  			/* SEMB is not supported yet */
  			*p_class = ATA_DEV_SEMB_UNSUP;
  			return 0;
  		}

  		if ((err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) {
  			/* Device or controller might have reported
  			 * the wrong device class.  Give a shot at the
  			 * other IDENTIFY if the current one is
  			 * aborted by the device.
  			 */
  			if (may_fallback) {
  				may_fallback = 0;
  
  				if (class == ATA_DEV_ATA)
  					class = ATA_DEV_ATAPI;
  				else
  					class = ATA_DEV_ATA;
  				goto retry;
  			}
  
  			/* Control reaches here iff the device aborted
  			 * both flavors of IDENTIFYs which happens
  			 * sometimes with phantom devices.
  			 */

  			ata_dev_dbg(dev,
  				    "both IDENTIFYs aborted, assuming NODEV
  ");

  			return -ENOENT;

  		}

  		rc = -EIO;
  		reason = "I/O error";

  		goto err_out;
  	}

  	if (dev->horkage & ATA_HORKAGE_DUMP_ID) {

  		ata_dev_dbg(dev, "dumping IDENTIFY data, "
  			    "class=%d may_fallback=%d tried_spinup=%d
  ",
  			    class, may_fallback, tried_spinup);

  		print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,
  			       16, 2, id, ATA_ID_WORDS * sizeof(*id), true);
  	}

  	/* Falling back doesn't make sense if ID data was read
  	 * successfully at least once.
  	 */
  	may_fallback = 0;

  	swap_buf_le16(id, ATA_ID_WORDS);

  	/* sanity check */

  	rc = -EINVAL;

  	reason = "device reports invalid type";

  
  	if (class == ATA_DEV_ATA) {
  		if (!ata_id_is_ata(id) && !ata_id_is_cfa(id))
  			goto err_out;
  	} else {
  		if (ata_id_is_ata(id))
  			goto err_out;

  	}

  	if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) {
  		tried_spinup = 1;
  		/*
  		 * Drive powered-up in standby mode, and requires a specific
  		 * SET_FEATURES spin-up subcommand before it will accept
  		 * anything other than the original IDENTIFY command.
  		 */

  		err_mask = ata_dev_set_feature(dev, SETFEATURES_SPINUP, 0);

  		if (err_mask && id[2] != 0x738c) {

  			rc = -EIO;
  			reason = "SPINUP failed";
  			goto err_out;
  		}
  		/*
  		 * If the drive initially returned incomplete IDENTIFY info,
  		 * we now must reissue the IDENTIFY command.
  		 */
  		if (id[2] == 0x37c8)
  			goto retry;
  	}

  	if ((flags & ATA_READID_POSTRESET) && class == ATA_DEV_ATA) {

  		/*
  		 * The exact sequence expected by certain pre-ATA4 drives is:
  		 * SRST RESET

  		 * IDENTIFY (optional in early ATA)
  		 * INITIALIZE DEVICE PARAMETERS (later IDE and ATA)

  		 * anything else..
  		 * Some drives were very specific about that exact sequence.

  		 *
  		 * Note that ATA4 says lba is mandatory so the second check

  		 * should never trigger.

  		 */
  		if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {

  			err_mask = ata_dev_init_params(dev, id[3], id[6]);

  			if (err_mask) {
  				rc = -EIO;
  				reason = "INIT_DEV_PARAMS failed";
  				goto err_out;
  			}
  
  			/* current CHS translation info (id[53-58]) might be
  			 * changed. reread the identify device info.
  			 */

  			flags &= ~ATA_READID_POSTRESET;

  			goto retry;
  		}
  	}
  
  	*p_class = class;

  	return 0;
  
   err_out:

  	if (ata_msg_warn(ap))

  		ata_dev_warn(dev, "failed to IDENTIFY (%s, err_mask=0x%x)
  ",
  			     reason, err_mask);

  	return rc;
  }

  static int ata_do_link_spd_horkage(struct ata_device *dev)
  {
  	struct ata_link *plink = ata_dev_phys_link(dev);
  	u32 target, target_limit;
  
  	if (!sata_scr_valid(plink))
  		return 0;
  
  	if (dev->horkage & ATA_HORKAGE_1_5_GBPS)
  		target = 1;
  	else
  		return 0;
  
  	target_limit = (1 << target) - 1;
  
  	/* if already on stricter limit, no need to push further */
  	if (plink->sata_spd_limit <= target_limit)
  		return 0;
  
  	plink->sata_spd_limit = target_limit;
  
  	/* Request another EH round by returning -EAGAIN if link is
  	 * going faster than the target speed.  Forward progress is
  	 * guaranteed by setting sata_spd_limit to target_limit above.
  	 */
  	if (plink->sata_spd > target) {

  		ata_dev_info(dev, "applying link speed limit horkage to %s
  ",
  			     sata_spd_string(target));

  		return -EAGAIN;
  	}
  	return 0;
  }

  static inline u8 ata_dev_knobble(struct ata_device *dev)

  {

  	struct ata_port *ap = dev->link->ap;

  
  	if (ata_dev_blacklisted(dev) & ATA_HORKAGE_BRIDGE_OK)
  		return 0;

  	return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));

  }

  static int ata_dev_config_ncq(struct ata_device *dev,

  			       char *desc, size_t desc_sz)
  {

  	struct ata_port *ap = dev->link->ap;

  	int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);

  	unsigned int err_mask;
  	char *aa_desc = "";

  
  	if (!ata_id_has_ncq(dev->id)) {
  		desc[0] = '\0';

  		return 0;

  	}