[mirror_ubuntu-hirsute-kernel.git] / drivers / ata / libata-acpi.c

/*
 * libata-acpi.c
 * Provides ACPI support for PATA/SATA.
 *
 * Copyright (C) 2006 Intel Corp.
 * Copyright (C) 2006 Randy Dunlap
 */

#include <linux/ata.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/acpi.h>
#include <linux/libata.h>
#include <linux/pci.h>
#include "libata.h"

#include <acpi/acpi_bus.h>
#include <acpi/acnames.h>
#include <acpi/acnamesp.h>
#include <acpi/acparser.h>
#include <acpi/acexcep.h>
#include <acpi/acmacros.h>
#include <acpi/actypes.h>

#define NO_PORT_MULT		0xffff
#define SATA_ADR(root,pmp)	(((root) << 16) | (pmp))

#define REGS_PER_GTF		7
struct ata_acpi_gtf {
	u8	tf[REGS_PER_GTF];	/* regs. 0x1f1 - 0x1f7 */
} __packed;

/*
 *	Helper - belongs in the PCI layer somewhere eventually
 */
static int is_pci_dev(struct device *dev)
{
	return (dev->bus == &pci_bus_type);
}

static void ata_acpi_associate_sata_port(struct ata_port *ap)
{
	acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);

	ap->device->acpi_handle = acpi_get_child(ap->host->acpi_handle, adr);
}

static void ata_acpi_associate_ide_port(struct ata_port *ap)
{
	int max_devices, i;

	ap->acpi_handle = acpi_get_child(ap->host->acpi_handle, ap->port_no);
	if (!ap->acpi_handle)
		return;

	max_devices = 1;
	if (ap->flags & ATA_FLAG_SLAVE_POSS)
		max_devices++;

	for (i = 0; i < max_devices; i++) {
		struct ata_device *dev = &ap->device[i];

		dev->acpi_handle = acpi_get_child(ap->acpi_handle, i);
	}
}

/**
 * ata_acpi_associate - associate ATA host with ACPI objects
 * @host: target ATA host
 *
 * Look up ACPI objects associated with @host and initialize
 * acpi_handle fields of @host, its ports and devices accordingly.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
void ata_acpi_associate(struct ata_host *host)
{
	int i;

	if (!is_pci_dev(host->dev) || libata_noacpi)
		return;

	host->acpi_handle = DEVICE_ACPI_HANDLE(host->dev);
	if (!host->acpi_handle)
		return;

	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];

		if (host->ports[0]->flags & ATA_FLAG_ACPI_SATA)
			ata_acpi_associate_sata_port(ap);
		else
			ata_acpi_associate_ide_port(ap);
	}
}

/**
 * ata_dev_get_GTF - get the drive bootup default taskfile settings
 * @dev: target ATA device
 * @gtf: output parameter for buffer containing _GTF taskfile arrays
 * @ptr_to_free: pointer which should be freed
 *
 * This applies to both PATA and SATA drives.
 *
 * The _GTF method has no input parameters.
 * It returns a variable number of register set values (registers
 * hex 1F1..1F7, taskfiles).
 * The <variable number> is not known in advance, so have ACPI-CA
 * allocate the buffer as needed and return it, then free it later.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * Number of taskfiles on success, 0 if _GTF doesn't exist or doesn't
 * contain valid data.  -errno on other errors.
 */
static int ata_dev_get_GTF(struct ata_device *dev, struct ata_acpi_gtf **gtf,
			   void **ptr_to_free)
{
	struct ata_port *ap = dev->ap;
	acpi_status status;
	struct acpi_buffer output;
	union acpi_object *out_obj;
	int rc = 0;

	/* set up output buffer */
	output.length = ACPI_ALLOCATE_BUFFER;
	output.pointer = NULL;	/* ACPI-CA sets this; save/free it later */

	if (!dev->acpi_handle)
		goto out_free;

	if (ata_msg_probe(ap))
		ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
			       __FUNCTION__, ap->port_no);

	if (!ata_dev_enabled(dev) || (ap->flags & ATA_FLAG_DISABLED)) {
		if (ata_msg_probe(ap))
			ata_dev_printk(dev, KERN_DEBUG, "%s: ERR: "
				"ata_dev_present: %d, PORT_DISABLED: %lu\n",
				__FUNCTION__, ata_dev_enabled(dev),
				ap->flags & ATA_FLAG_DISABLED);
		goto out_free;
	}

	/* _GTF has no input parameters */
	status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output);

	if (ACPI_FAILURE(status)) {
		if (status != AE_NOT_FOUND) {
			ata_dev_printk(dev, KERN_WARNING,
				       "_GTF evaluation failed (AE 0x%x)\n",
				       status);
			rc = -EIO;
		}
		goto out_free;
	}

	if (!output.length || !output.pointer) {
		if (ata_msg_probe(ap))
			ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: "
				"length or ptr is NULL (0x%llx, 0x%p)\n",
				__FUNCTION__,
				(unsigned long long)output.length,
				output.pointer);
		goto out_free;
	}

	out_obj = output.pointer;
	if (out_obj->type != ACPI_TYPE_BUFFER) {
		ata_dev_printk(dev, KERN_WARNING,
			       "_GTF unexpected object type 0x%x\n",
			       out_obj->type);
		rc = -EINVAL;
		goto out_free;
	}

	if (out_obj->buffer.length % REGS_PER_GTF) {
		ata_dev_printk(dev, KERN_WARNING,
			       "unexpected _GTF length (%d)\n",
			       out_obj->buffer.length);
		rc = -EINVAL;
		goto out_free;
	}

	*ptr_to_free = out_obj;
	*gtf = (void *)out_obj->buffer.pointer;
	rc = out_obj->buffer.length / REGS_PER_GTF;

	if (ata_msg_probe(ap))
		ata_dev_printk(dev, KERN_DEBUG, "%s: returning "
			"gtf=%p, gtf_count=%d, ptr_to_free=%p\n",
			__FUNCTION__, *gtf, rc, *ptr_to_free);
	return rc;

 out_free:
	kfree(output.pointer);
	return rc;
}

/**
 * taskfile_load_raw - send taskfile registers to host controller
 * @dev: target ATA device
 * @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
 *
 * Outputs ATA taskfile to standard ATA host controller using MMIO
 * or PIO as indicated by the ATA_FLAG_MMIO flag.
 * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
 * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
 * hob_lbal, hob_lbam, and hob_lbah.
 *
 * This function waits for idle (!BUSY and !DRQ) after writing
 * registers.  If the control register has a new value, this
 * function also waits for idle after writing control and before
 * writing the remaining registers.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
static int taskfile_load_raw(struct ata_device *dev,
			      const struct ata_acpi_gtf *gtf)
{
	struct ata_port *ap = dev->ap;
	struct ata_taskfile tf, rtf;
	unsigned int err_mask;

	if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
	    && (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
	    && (gtf->tf[6] == 0))
		return 0;

	ata_tf_init(dev, &tf);

	/* convert gtf to tf */
	tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; /* TBD */
	tf.protocol = ATA_PROT_NODATA;
	tf.feature = gtf->tf[0];	/* 0x1f1 */
	tf.nsect   = gtf->tf[1];	/* 0x1f2 */
	tf.lbal    = gtf->tf[2];	/* 0x1f3 */
	tf.lbam    = gtf->tf[3];	/* 0x1f4 */
	tf.lbah    = gtf->tf[4];	/* 0x1f5 */
	tf.device  = gtf->tf[5];	/* 0x1f6 */
	tf.command = gtf->tf[6];	/* 0x1f7 */

	if (ata_msg_probe(ap))
		ata_dev_printk(dev, KERN_DEBUG, "executing ACPI cmd "
			       "%02x/%02x:%02x:%02x:%02x:%02x:%02x\n",
			       tf.command, tf.feature, tf.nsect,
			       tf.lbal, tf.lbam, tf.lbah, tf.device);

	rtf = tf;
	err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0);
	if (err_mask) {
		ata_dev_printk(dev, KERN_ERR,
			"ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x failed "
			"(Emask=0x%x Stat=0x%02x Err=0x%02x)\n",
			tf.command, tf.feature, tf.nsect, tf.lbal, tf.lbam,
			tf.lbah, tf.device, err_mask, rtf.command, rtf.feature);
		return -EIO;
	}

	return 0;
}

/**
 * ata_dev_set_taskfiles - write the drive taskfile settings from _GTF
 * @dev: target ATA device
 * @gtf: pointer to array of _GTF taskfiles to execute
 * @gtf_count: number of taskfiles
 *
 * This applies to both PATA and SATA drives.
 *
 * Execute taskfiles in @gtf.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
static int ata_dev_set_taskfiles(struct ata_device *dev,
				 struct ata_acpi_gtf *gtf, int gtf_count)
{
	struct ata_port *ap = dev->ap;
	int ix;

	if (ata_msg_probe(ap))
		ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
			       __FUNCTION__, ap->port_no);

	if (!(ap->flags & ATA_FLAG_ACPI_SATA))
		return 0;

	if (!ata_dev_enabled(dev) || (ap->flags & ATA_FLAG_DISABLED))
		return -ENODEV;

	/* send all TaskFile registers (0x1f1-0x1f7) *in*that*order* */
	for (ix = 0; ix < gtf_count; ix++)
		 taskfile_load_raw(dev, gtf++);

	return 0;
}

/**
 * ata_acpi_exec_tfs - get then write drive taskfile settings
 * @ap: the ata_port for the drive
 *
 * This applies to both PATA and SATA drives.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
int ata_acpi_exec_tfs(struct ata_port *ap)
{
	int ix, ret = 0;

	/*
	 * TBD - implement PATA support.  For now,
	 * we should not run GTF on PATA devices since some
	 * PATA require execution of GTM/STM before GTF.
	 */
	if (!(ap->flags & ATA_FLAG_ACPI_SATA))
		return 0;

	for (ix = 0; ix < ATA_MAX_DEVICES; ix++) {
		struct ata_device *dev = &ap->device[ix];
		struct ata_acpi_gtf *gtf = NULL;
		int gtf_count;
		void *ptr_to_free = NULL;

		if (!ata_dev_enabled(dev))
			continue;

		ret = ata_dev_get_GTF(dev, &gtf, &ptr_to_free);
		if (ret == 0)
			continue;
		if (ret < 0)
			break;
		gtf_count = ret;

		ret = ata_dev_set_taskfiles(dev, gtf, gtf_count);
		kfree(ptr_to_free);
		if (ret < 0)
			break;
	}

	return ret;
}

/**
 * ata_acpi_push_id - send Identify data to drive
 * @dev: target ATA device
 *
 * _SDD ACPI object: for SATA mode only
 * Must be after Identify (Packet) Device -- uses its data
 * ATM this function never returns a failure.  It is an optional
 * method and if it fails for whatever reason, we should still
 * just keep going.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
int ata_acpi_push_id(struct ata_device *dev)
{
	struct ata_port *ap = dev->ap;
	int err;
	acpi_status status;
	struct acpi_object_list input;
	union acpi_object in_params[1];

	if (!dev->acpi_handle)
		return 0;

	if (ata_msg_probe(ap))
		ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
			       __FUNCTION__, dev->devno, ap->port_no);

	/* Don't continue if not a SATA device. */
	if (!(ap->flags & ATA_FLAG_ACPI_SATA)) {
		if (ata_msg_probe(ap))
			ata_dev_printk(dev, KERN_DEBUG,
				"%s: Not a SATA device\n", __FUNCTION__);
		goto out;
	}

	/* Give the drive Identify data to the drive via the _SDD method */
	/* _SDD: set up input parameters */
	input.count = 1;
	input.pointer = in_params;
	in_params[0].type = ACPI_TYPE_BUFFER;
	in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
	in_params[0].buffer.pointer = (u8 *)dev->id;
	/* Output buffer: _SDD has no output */

	/* It's OK for _SDD to be missing too. */
	swap_buf_le16(dev->id, ATA_ID_WORDS);
	status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL);
	swap_buf_le16(dev->id, ATA_ID_WORDS);

	err = ACPI_FAILURE(status) ? -EIO : 0;
	if (err < 0)
		ata_dev_printk(dev, KERN_WARNING,
			       "ACPI _SDD failed (AE 0x%x)\n", status);

	/* always return success */
out:
	return 0;
}
Commit	Line	Data
11ef697b KCA	1	/*
	2	* libata-acpi.c
	3	* Provides ACPI support for PATA/SATA.
	4	*
	5	* Copyright (C) 2006 Intel Corp.
	6	* Copyright (C) 2006 Randy Dunlap
	7	*/
	8
	9	#include <linux/ata.h>
	10	#include <linux/delay.h>
	11	#include <linux/device.h>
	12	#include <linux/errno.h>
	13	#include <linux/kernel.h>
	14	#include <linux/acpi.h>
	15	#include <linux/libata.h>
	16	#include <linux/pci.h>
	17	#include "libata.h"
	18
	19	#include <acpi/acpi_bus.h>
	20	#include <acpi/acnames.h>
	21	#include <acpi/acnamesp.h>
	22	#include <acpi/acparser.h>
	23	#include <acpi/acexcep.h>
	24	#include <acpi/acmacros.h>
	25	#include <acpi/actypes.h>
	26
11ef697b	27	#define NO_PORT_MULT 0xffff
fafbae87	28	#define SATA_ADR(root,pmp) (((root) << 16) \| (pmp))
11ef697b KCA	29
11ef697b KCA	30	#define REGS_PER_GTF 7
4700c4bc TH	31	struct ata_acpi_gtf {
	32	u8 tf[REGS_PER_GTF]; /* regs. 0x1f1 - 0x1f7 */
	33	} __packed;
11ef697b	34
ca426635 AC	35	/*
	36	* Helper - belongs in the PCI layer somewhere eventually
	37	*/
	38	static int is_pci_dev(struct device *dev)
	39	{
	40	return (dev->bus == &pci_bus_type);
	41	}
11ef697b	42
fafbae87	43	static void ata_acpi_associate_sata_port(struct ata_port *ap)
11ef697b	44	{
fafbae87 TH	45	acpi_integer adr = SATA_ADR(ap->port_no, NO_PORT_MULT);
	46
	47	ap->device->acpi_handle = acpi_get_child(ap->host->acpi_handle, adr);
11ef697b KCA	48	}
11ef697b KCA	49
fafbae87	50	static void ata_acpi_associate_ide_port(struct ata_port *ap)
11ef697b	51	{
fafbae87	52	int max_devices, i;
11ef697b	53
fafbae87 TH	54	ap->acpi_handle = acpi_get_child(ap->host->acpi_handle, ap->port_no);
	55	if (!ap->acpi_handle)
	56	return;
11ef697b	57
fafbae87 TH	58	max_devices = 1;
	59	if (ap->flags & ATA_FLAG_SLAVE_POSS)
	60	max_devices++;
11ef697b	61
fafbae87 TH	62	for (i = 0; i < max_devices; i++) {
fafbae87 TH	63	struct ata_device *dev = &ap->device[i];
11ef697b	64
fafbae87	65	dev->acpi_handle = acpi_get_child(ap->acpi_handle, i);
11ef697b	66	}
11ef697b KCA	67	}
11ef697b KCA	68
fafbae87 TH	69	/**
	70	* ata_acpi_associate - associate ATA host with ACPI objects
	71	* @host: target ATA host
	72	*
	73	* Look up ACPI objects associated with @host and initialize
	74	* acpi_handle fields of @host, its ports and devices accordingly.
	75	*
	76	* LOCKING:
	77	* EH context.
	78	*
	79	* RETURNS:
	80	* 0 on success, -errno on failure.
	81	*/
	82	void ata_acpi_associate(struct ata_host *host)
11ef697b	83	{
fafbae87	84	int i;
11ef697b	85
fafbae87 TH	86	if (!is_pci_dev(host->dev) \|\| libata_noacpi)
fafbae87 TH	87	return;
11ef697b	88
fafbae87 TH	89	host->acpi_handle = DEVICE_ACPI_HANDLE(host->dev);
	90	if (!host->acpi_handle)
	91	return;
11ef697b	92
fafbae87 TH	93	for (i = 0; i < host->n_ports; i++) {
	94	struct ata_port *ap = host->ports[i];
	95
	96	if (host->ports[0]->flags & ATA_FLAG_ACPI_SATA)
	97	ata_acpi_associate_sata_port(ap);
	98	else
	99	ata_acpi_associate_ide_port(ap);
11ef697b	100	}
11ef697b KCA	101	}
	102
	103	/**
4700c4bc	104	* ata_dev_get_GTF - get the drive bootup default taskfile settings
3a32a8e9	105	* @dev: target ATA device
4700c4bc TH	106	* @gtf: output parameter for buffer containing _GTF taskfile arrays
4700c4bc TH	107	* @ptr_to_free: pointer which should be freed
11ef697b KCA	108	*
	109	* This applies to both PATA and SATA drives.
	110	*
	111	* The _GTF method has no input parameters.
	112	* It returns a variable number of register set values (registers
	113	* hex 1F1..1F7, taskfiles).
	114	* The <variable number> is not known in advance, so have ACPI-CA
	115	* allocate the buffer as needed and return it, then free it later.
	116	*
4700c4bc TH	117	* LOCKING:
	118	* EH context.
	119	*
	120	* RETURNS:
	121	* Number of taskfiles on success, 0 if _GTF doesn't exist or doesn't
	122	* contain valid data. -errno on other errors.
11ef697b	123	*/
4700c4bc TH	124	static int ata_dev_get_GTF(struct ata_device dev, struct ata_acpi_gtf *gtf,
4700c4bc TH	125	void **ptr_to_free)
11ef697b	126	{
3a32a8e9 TH	127	struct ata_port *ap = dev->ap;
3a32a8e9 TH	128	acpi_status status;
3a32a8e9 TH	129	struct acpi_buffer output;
3a32a8e9 TH	130	union acpi_object *out_obj;
4700c4bc	131	int rc = 0;
11ef697b	132
4700c4bc TH	133	/* set up output buffer */
	134	output.length = ACPI_ALLOCATE_BUFFER;
	135	output.pointer = NULL; /* ACPI-CA sets this; save/free it later */
11ef697b	136
fafbae87	137	if (!dev->acpi_handle)
4700c4bc	138	goto out_free;
11ef697b KCA	139
11ef697b KCA	140	if (ata_msg_probe(ap))
3a32a8e9	141	ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
878d4fed	142	__FUNCTION__, ap->port_no);
11ef697b	143
3a32a8e9	144	if (!ata_dev_enabled(dev) \|\| (ap->flags & ATA_FLAG_DISABLED)) {
11ef697b	145	if (ata_msg_probe(ap))
3a32a8e9	146	ata_dev_printk(dev, KERN_DEBUG, "%s: ERR: "
11ef697b	147	"ata_dev_present: %d, PORT_DISABLED: %lu\n",
3a32a8e9	148	__FUNCTION__, ata_dev_enabled(dev),
11ef697b	149	ap->flags & ATA_FLAG_DISABLED);
4700c4bc	150	goto out_free;
11ef697b KCA	151	}
11ef697b KCA	152
11ef697b	153	/* _GTF has no input parameters */
4700c4bc TH	154	status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output);
4700c4bc TH	155
11ef697b	156	if (ACPI_FAILURE(status)) {
4700c4bc TH	157	if (status != AE_NOT_FOUND) {
	158	ata_dev_printk(dev, KERN_WARNING,
	159	"_GTF evaluation failed (AE 0x%x)\n",
	160	status);
	161	rc = -EIO;
	162	}
	163	goto out_free;
11ef697b KCA	164	}
	165
	166	if (!output.length \|\| !output.pointer) {
	167	if (ata_msg_probe(ap))
3a32a8e9	168	ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: "
11ef697b KCA	169	"length or ptr is NULL (0x%llx, 0x%p)\n",
	170	__FUNCTION__,
	171	(unsigned long long)output.length,
	172	output.pointer);
4700c4bc	173	goto out_free;
11ef697b KCA	174	}
	175
	176	out_obj = output.pointer;
	177	if (out_obj->type != ACPI_TYPE_BUFFER) {
69b16a5f TH	178	ata_dev_printk(dev, KERN_WARNING,
	179	"_GTF unexpected object type 0x%x\n",
	180	out_obj->type);
4700c4bc TH	181	rc = -EINVAL;
4700c4bc TH	182	goto out_free;
11ef697b KCA	183	}
11ef697b KCA	184
4700c4bc	185	if (out_obj->buffer.length % REGS_PER_GTF) {
69b16a5f TH	186	ata_dev_printk(dev, KERN_WARNING,
	187	"unexpected _GTF length (%d)\n",
	188	out_obj->buffer.length);
4700c4bc TH	189	rc = -EINVAL;
4700c4bc TH	190	goto out_free;
11ef697b KCA	191	}
11ef697b KCA	192
4700c4bc TH	193	*ptr_to_free = out_obj;
	194	gtf = (void )out_obj->buffer.pointer;
	195	rc = out_obj->buffer.length / REGS_PER_GTF;
	196
11ef697b	197	if (ata_msg_probe(ap))
3a32a8e9	198	ata_dev_printk(dev, KERN_DEBUG, "%s: returning "
4700c4bc TH	199	"gtf=%p, gtf_count=%d, ptr_to_free=%p\n",
	200	__FUNCTION__, gtf, rc, ptr_to_free);
	201	return rc;
	202
	203	out_free:
	204	kfree(output.pointer);
	205	return rc;
11ef697b KCA	206	}
	207
	208	/**
	209	* taskfile_load_raw - send taskfile registers to host controller
3a32a8e9	210	* @dev: target ATA device
11ef697b KCA	211	* @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
	212	*
	213	* Outputs ATA taskfile to standard ATA host controller using MMIO
	214	* or PIO as indicated by the ATA_FLAG_MMIO flag.
	215	* Writes the control, feature, nsect, lbal, lbam, and lbah registers.
	216	* Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
	217	* hob_lbal, hob_lbam, and hob_lbah.
	218	*
	219	* This function waits for idle (!BUSY and !DRQ) after writing
	220	* registers. If the control register has a new value, this
	221	* function also waits for idle after writing control and before
	222	* writing the remaining registers.
	223	*
4700c4bc TH	224	* LOCKING:
	225	* EH context.
	226	*
	227	* RETURNS:
	228	* 0 on success, -errno on failure.
11ef697b	229	*/
4700c4bc TH	230	static int taskfile_load_raw(struct ata_device *dev,
4700c4bc TH	231	const struct ata_acpi_gtf *gtf)
11ef697b	232	{
3a32a8e9	233	struct ata_port *ap = dev->ap;
4700c4bc TH	234	struct ata_taskfile tf, rtf;
4700c4bc TH	235	unsigned int err_mask;
fc16c25f	236
4700c4bc TH	237	if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
	238	&& (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
	239	&& (gtf->tf[6] == 0))
	240	return 0;
11ef697b	241
3a32a8e9	242	ata_tf_init(dev, &tf);
fc16c25f JG	243
	244	/* convert gtf to tf */
	245	tf.flags \|= ATA_TFLAG_ISADDR \| ATA_TFLAG_DEVICE; /* TBD */
48be6b18	246	tf.protocol = ATA_PROT_NODATA;
4700c4bc TH	247	tf.feature = gtf->tf[0]; /* 0x1f1 */
	248	tf.nsect = gtf->tf[1]; /* 0x1f2 */
	249	tf.lbal = gtf->tf[2]; /* 0x1f3 */
	250	tf.lbam = gtf->tf[3]; /* 0x1f4 */
	251	tf.lbah = gtf->tf[4]; /* 0x1f5 */
	252	tf.device = gtf->tf[5]; /* 0x1f6 */
	253	tf.command = gtf->tf[6]; /* 0x1f7 */
	254
	255	if (ata_msg_probe(ap))
	256	ata_dev_printk(dev, KERN_DEBUG, "executing ACPI cmd "
	257	"%02x/%02x:%02x:%02x:%02x:%02x:%02x\n",
	258	tf.command, tf.feature, tf.nsect,
	259	tf.lbal, tf.lbam, tf.lbah, tf.device);
	260
	261	rtf = tf;
	262	err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0);
	263	if (err_mask) {
3a32a8e9	264	ata_dev_printk(dev, KERN_ERR,
4700c4bc TH	265	"ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x failed "
	266	"(Emask=0x%x Stat=0x%02x Err=0x%02x)\n",
	267	tf.command, tf.feature, tf.nsect, tf.lbal, tf.lbam,
	268	tf.lbah, tf.device, err_mask, rtf.command, rtf.feature);
	269	return -EIO;
	270	}
	271
	272	return 0;
11ef697b KCA	273	}
	274
	275	/**
4700c4bc	276	* ata_dev_set_taskfiles - write the drive taskfile settings from _GTF
3a32a8e9	277	* @dev: target ATA device
4700c4bc TH	278	* @gtf: pointer to array of _GTF taskfiles to execute
4700c4bc TH	279	* @gtf_count: number of taskfiles
11ef697b KCA	280	*
	281	* This applies to both PATA and SATA drives.
	282	*
4700c4bc TH	283	* Execute taskfiles in @gtf.
	284	*
	285	* LOCKING:
	286	* EH context.
	287	*
	288	* RETURNS:
	289	* 0 on success, -errno on failure.
11ef697b	290	*/
4700c4bc TH	291	static int ata_dev_set_taskfiles(struct ata_device *dev,
4700c4bc TH	292	struct ata_acpi_gtf *gtf, int gtf_count)
11ef697b	293	{
3a32a8e9	294	struct ata_port *ap = dev->ap;
3a32a8e9	295	int ix;
11ef697b KCA	296
11ef697b KCA	297	if (ata_msg_probe(ap))
3a32a8e9	298	ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
878d4fed	299	__FUNCTION__, ap->port_no);
11ef697b	300
fafbae87	301	if (!(ap->flags & ATA_FLAG_ACPI_SATA))
11ef697b KCA	302	return 0;
11ef697b KCA	303
3a32a8e9	304	if (!ata_dev_enabled(dev) \|\| (ap->flags & ATA_FLAG_DISABLED))
4700c4bc	305	return -ENODEV;
11ef697b	306
4700c4bc TH	307	/* send all TaskFile registers (0x1f1-0x1f7) inthatorder */
	308	for (ix = 0; ix < gtf_count; ix++)
	309	taskfile_load_raw(dev, gtf++);
11ef697b	310
4700c4bc	311	return 0;
11ef697b KCA	312	}
	313
	314	/**
	315	* ata_acpi_exec_tfs - get then write drive taskfile settings
	316	* @ap: the ata_port for the drive
	317	*
	318	* This applies to both PATA and SATA drives.
69b16a5f TH	319	*
	320	* LOCKING:
	321	* EH context.
	322	*
	323	* RETURNS:
	324	* 0 on success, -errno on failure.
11ef697b KCA	325	*/
	326	int ata_acpi_exec_tfs(struct ata_port *ap)
	327	{
4700c4bc	328	int ix, ret = 0;
11ef697b	329
df33c77e KA	330	/*
	331	* TBD - implement PATA support. For now,
	332	* we should not run GTF on PATA devices since some
	333	* PATA require execution of GTM/STM before GTF.
	334	*/
3cadbcc0	335	if (!(ap->flags & ATA_FLAG_ACPI_SATA))
df33c77e	336	return 0;
11ef697b KCA	337
11ef697b KCA	338	for (ix = 0; ix < ATA_MAX_DEVICES; ix++) {
3a32a8e9	339	struct ata_device *dev = &ap->device[ix];
4700c4bc TH	340	struct ata_acpi_gtf *gtf = NULL;
	341	int gtf_count;
	342	void *ptr_to_free = NULL;
3a32a8e9 TH	343
3a32a8e9 TH	344	if (!ata_dev_enabled(dev))
11ef697b KCA	345	continue;
11ef697b KCA	346
4700c4bc TH	347	ret = ata_dev_get_GTF(dev, &gtf, &ptr_to_free);
	348	if (ret == 0)
	349	continue;
69b16a5f	350	if (ret < 0)
11ef697b	351	break;
4700c4bc	352	gtf_count = ret;
11ef697b	353
4700c4bc TH	354	ret = ata_dev_set_taskfiles(dev, gtf, gtf_count);
4700c4bc TH	355	kfree(ptr_to_free);
69b16a5f	356	if (ret < 0)
11ef697b	357	break;
11ef697b KCA	358	}
	359
	360	return ret;
	361	}
	362
7ea1fbc2 KCA	363	/**
7ea1fbc2 KCA	364	* ata_acpi_push_id - send Identify data to drive
3a32a8e9	365	* @dev: target ATA device
7ea1fbc2 KCA	366	*
	367	* _SDD ACPI object: for SATA mode only
	368	* Must be after Identify (Packet) Device -- uses its data
	369	* ATM this function never returns a failure. It is an optional
	370	* method and if it fails for whatever reason, we should still
	371	* just keep going.
69b16a5f TH	372	*
	373	* LOCKING:
	374	* EH context.
	375	*
	376	* RETURNS:
	377	* 0 on success, -errno on failure.
7ea1fbc2	378	*/
3a32a8e9	379	int ata_acpi_push_id(struct ata_device *dev)
7ea1fbc2	380	{
3a32a8e9	381	struct ata_port *ap = dev->ap;
3a32a8e9	382	int err;
3a32a8e9 TH	383	acpi_status status;
	384	struct acpi_object_list input;
	385	union acpi_object in_params[1];
7ea1fbc2	386
fafbae87	387	if (!dev->acpi_handle)
7ea1fbc2 KCA	388	return 0;
	389
	390	if (ata_msg_probe(ap))
3a32a8e9 TH	391	ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
3a32a8e9 TH	392	__FUNCTION__, dev->devno, ap->port_no);
7ea1fbc2 KCA	393
7ea1fbc2 KCA	394	/* Don't continue if not a SATA device. */
3cadbcc0	395	if (!(ap->flags & ATA_FLAG_ACPI_SATA)) {
7ea1fbc2	396	if (ata_msg_probe(ap))
3a32a8e9	397	ata_dev_printk(dev, KERN_DEBUG,
7ea1fbc2 KCA	398	"%s: Not a SATA device\n", __FUNCTION__);
	399	goto out;
	400	}
	401
7ea1fbc2 KCA	402	/* Give the drive Identify data to the drive via the _SDD method */
	403	/* _SDD: set up input parameters */
	404	input.count = 1;
	405	input.pointer = in_params;
	406	in_params[0].type = ACPI_TYPE_BUFFER;
3a32a8e9 TH	407	in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
3a32a8e9 TH	408	in_params[0].buffer.pointer = (u8 *)dev->id;
7ea1fbc2 KCA	409	/* Output buffer: _SDD has no output */
	410
	411	/* It's OK for _SDD to be missing too. */
3a32a8e9	412	swap_buf_le16(dev->id, ATA_ID_WORDS);
fafbae87	413	status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL);
3a32a8e9	414	swap_buf_le16(dev->id, ATA_ID_WORDS);
7ea1fbc2 KCA	415
7ea1fbc2 KCA	416	err = ACPI_FAILURE(status) ? -EIO : 0;
69b16a5f TH	417	if (err < 0)
	418	ata_dev_printk(dev, KERN_WARNING,
	419	"ACPI _SDD failed (AE 0x%x)\n", status);
7ea1fbc2 KCA	420
	421	/* always return success */
	422	out:
	423	return 0;
	424	}
	425
	426