[mirror_ubuntu-bionic-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 (ata_msg_probe(ap))
		ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
			       __FUNCTION__, ap->port_no);

	/* _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_acpi_exec_tfs - get then write drive taskfile settings
 * @dev: target ATA device
 *
 * Evaluate _GTF and excute returned taskfiles.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * Number of executed taskfiles on success, 0 if _GTF doesn't exist or
 * doesn't contain valid data.  -errno on other errors.
 */
static int ata_acpi_exec_tfs(struct ata_device *dev)
{
	struct ata_acpi_gtf *gtf = NULL;
	void *ptr_to_free = NULL;
	int gtf_count, i, rc;

	/* get taskfiles */
	rc = ata_dev_get_GTF(dev, &gtf, &ptr_to_free);
	if (rc < 0)
		return rc;
	gtf_count = rc;

	/* execute them */
	for (i = 0, rc = 0; i < gtf_count; i++) {
		int tmp;

		/* ACPI errors are eventually ignored.  Run till the
		 * end even after errors.
		 */
		tmp = taskfile_load_raw(dev, gtf++);
		if (!rc)
			rc = tmp;
	}

	kfree(ptr_to_free);

	if (rc == 0)
		return gtf_count;
	return rc;
}

/**
 * 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.
 */
static 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 (ata_msg_probe(ap))
		ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
			       __FUNCTION__, dev->devno, ap->port_no);

	/* 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);

	return err;
}

/**
 * ata_acpi_on_resume - ATA ACPI hook called on resume
 * @ap: target ATA port
 *
 * This function is called when @ap is resumed - right after port
 * itself is resumed but before any EH action is taken.
 *
 * LOCKING:
 * EH context.
 */
void ata_acpi_on_resume(struct ata_port *ap)
{
	int i;

	/* schedule _GTF */
	for (i = 0; i < ATA_MAX_DEVICES; i++)
		ap->device[i].flags |= ATA_DFLAG_ACPI_PENDING;
}

/**
 * ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
 * @dev: target ATA device
 *
 * This function is called when @dev is about to be configured.
 * IDENTIFY data might have been modified after this hook is run.
 *
 * LOCKING:
 * EH context.
 *
 * RETURNS:
 * Positive number if IDENTIFY data needs to be refreshed, 0 if not,
 * -errno on failure.
 */
int ata_acpi_on_devcfg(struct ata_device *dev)
{
	struct ata_port *ap = dev->ap;
	struct ata_eh_context *ehc = &ap->eh_context;
	int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
	int rc;

	/* XXX: _STM isn't implemented yet, skip if IDE for now */
	if (!acpi_sata)
		return 0;

	if (!dev->acpi_handle)
		return 0;

	/* do we need to do _GTF? */
	if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) &&
	    !(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET)))
		return 0;

	/* do _SDD if SATA */
	if (acpi_sata) {
		rc = ata_acpi_push_id(dev);
		if (rc)
			goto acpi_err;
	}

	/* do _GTF */
	rc = ata_acpi_exec_tfs(dev);
	if (rc < 0)
		goto acpi_err;

	dev->flags &= ~ATA_DFLAG_ACPI_PENDING;

	/* refresh IDENTIFY page if any _GTF command has been executed */
	if (rc > 0) {
		rc = ata_dev_reread_id(dev, 0);
		if (rc < 0) {
			ata_dev_printk(dev, KERN_ERR, "failed to IDENTIFY "
				       "after ACPI commands\n");
			return rc;
		}
	}

	return 0;

 acpi_err:
	/* let EH retry on the first failure, disable ACPI on the second */
	if (dev->flags & ATA_DFLAG_ACPI_FAILED) {
		ata_dev_printk(dev, KERN_WARNING, "ACPI on devcfg failed the "
			       "second time, disabling (errno=%d)\n", rc);

		dev->acpi_handle = NULL;

		/* if port is working, request IDENTIFY reload and continue */
		if (!(ap->pflags & ATA_PFLAG_FROZEN))
			rc = 1;
	}
	dev->flags |= ATA_DFLAG_ACPI_FAILED;
	return rc;
}
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
11ef697b	137	if (ata_msg_probe(ap))
3a32a8e9	138	ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER: port#: %d\n",
878d4fed	139	__FUNCTION__, ap->port_no);
11ef697b	140
11ef697b	141	/* _GTF has no input parameters */
4700c4bc TH	142	status = acpi_evaluate_object(dev->acpi_handle, "_GTF", NULL, &output);
4700c4bc TH	143
11ef697b	144	if (ACPI_FAILURE(status)) {
4700c4bc TH	145	if (status != AE_NOT_FOUND) {
	146	ata_dev_printk(dev, KERN_WARNING,
	147	"_GTF evaluation failed (AE 0x%x)\n",
	148	status);
	149	rc = -EIO;
	150	}
	151	goto out_free;
11ef697b KCA	152	}
	153
	154	if (!output.length \|\| !output.pointer) {
	155	if (ata_msg_probe(ap))
3a32a8e9	156	ata_dev_printk(dev, KERN_DEBUG, "%s: Run _GTF: "
11ef697b KCA	157	"length or ptr is NULL (0x%llx, 0x%p)\n",
	158	__FUNCTION__,
	159	(unsigned long long)output.length,
	160	output.pointer);
4700c4bc	161	goto out_free;
11ef697b KCA	162	}
	163
	164	out_obj = output.pointer;
	165	if (out_obj->type != ACPI_TYPE_BUFFER) {
69b16a5f TH	166	ata_dev_printk(dev, KERN_WARNING,
	167	"_GTF unexpected object type 0x%x\n",
	168	out_obj->type);
4700c4bc TH	169	rc = -EINVAL;
4700c4bc TH	170	goto out_free;
11ef697b KCA	171	}
11ef697b KCA	172
4700c4bc	173	if (out_obj->buffer.length % REGS_PER_GTF) {
69b16a5f TH	174	ata_dev_printk(dev, KERN_WARNING,
	175	"unexpected _GTF length (%d)\n",
	176	out_obj->buffer.length);
4700c4bc TH	177	rc = -EINVAL;
4700c4bc TH	178	goto out_free;
11ef697b KCA	179	}
11ef697b KCA	180
4700c4bc TH	181	*ptr_to_free = out_obj;
	182	gtf = (void )out_obj->buffer.pointer;
	183	rc = out_obj->buffer.length / REGS_PER_GTF;
	184
11ef697b	185	if (ata_msg_probe(ap))
3a32a8e9	186	ata_dev_printk(dev, KERN_DEBUG, "%s: returning "
4700c4bc TH	187	"gtf=%p, gtf_count=%d, ptr_to_free=%p\n",
	188	__FUNCTION__, gtf, rc, ptr_to_free);
	189	return rc;
	190
	191	out_free:
	192	kfree(output.pointer);
	193	return rc;
11ef697b KCA	194	}
	195
	196	/**
	197	* taskfile_load_raw - send taskfile registers to host controller
3a32a8e9	198	* @dev: target ATA device
11ef697b KCA	199	* @gtf: raw ATA taskfile register set (0x1f1 - 0x1f7)
	200	*
	201	* Outputs ATA taskfile to standard ATA host controller using MMIO
	202	* or PIO as indicated by the ATA_FLAG_MMIO flag.
	203	* Writes the control, feature, nsect, lbal, lbam, and lbah registers.
	204	* Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
	205	* hob_lbal, hob_lbam, and hob_lbah.
	206	*
	207	* This function waits for idle (!BUSY and !DRQ) after writing
	208	* registers. If the control register has a new value, this
	209	* function also waits for idle after writing control and before
	210	* writing the remaining registers.
	211	*
4700c4bc TH	212	* LOCKING:
	213	* EH context.
	214	*
	215	* RETURNS:
	216	* 0 on success, -errno on failure.
11ef697b	217	*/
4700c4bc TH	218	static int taskfile_load_raw(struct ata_device *dev,
4700c4bc TH	219	const struct ata_acpi_gtf *gtf)
11ef697b	220	{
3a32a8e9	221	struct ata_port *ap = dev->ap;
4700c4bc TH	222	struct ata_taskfile tf, rtf;
4700c4bc TH	223	unsigned int err_mask;
fc16c25f	224
4700c4bc TH	225	if ((gtf->tf[0] == 0) && (gtf->tf[1] == 0) && (gtf->tf[2] == 0)
	226	&& (gtf->tf[3] == 0) && (gtf->tf[4] == 0) && (gtf->tf[5] == 0)
	227	&& (gtf->tf[6] == 0))
	228	return 0;
11ef697b	229
3a32a8e9	230	ata_tf_init(dev, &tf);
fc16c25f JG	231
	232	/* convert gtf to tf */
	233	tf.flags \|= ATA_TFLAG_ISADDR \| ATA_TFLAG_DEVICE; /* TBD */
48be6b18	234	tf.protocol = ATA_PROT_NODATA;
4700c4bc TH	235	tf.feature = gtf->tf[0]; /* 0x1f1 */
	236	tf.nsect = gtf->tf[1]; /* 0x1f2 */
	237	tf.lbal = gtf->tf[2]; /* 0x1f3 */
	238	tf.lbam = gtf->tf[3]; /* 0x1f4 */
	239	tf.lbah = gtf->tf[4]; /* 0x1f5 */
	240	tf.device = gtf->tf[5]; /* 0x1f6 */
	241	tf.command = gtf->tf[6]; /* 0x1f7 */
	242
	243	if (ata_msg_probe(ap))
	244	ata_dev_printk(dev, KERN_DEBUG, "executing ACPI cmd "
	245	"%02x/%02x:%02x:%02x:%02x:%02x:%02x\n",
	246	tf.command, tf.feature, tf.nsect,
	247	tf.lbal, tf.lbam, tf.lbah, tf.device);
	248
	249	rtf = tf;
	250	err_mask = ata_exec_internal(dev, &rtf, NULL, DMA_NONE, NULL, 0);
	251	if (err_mask) {
3a32a8e9	252	ata_dev_printk(dev, KERN_ERR,
4700c4bc TH	253	"ACPI cmd %02x/%02x:%02x:%02x:%02x:%02x:%02x failed "
	254	"(Emask=0x%x Stat=0x%02x Err=0x%02x)\n",
	255	tf.command, tf.feature, tf.nsect, tf.lbal, tf.lbam,
	256	tf.lbah, tf.device, err_mask, rtf.command, rtf.feature);
	257	return -EIO;
	258	}
	259
	260	return 0;
11ef697b KCA	261	}
11ef697b KCA	262
11ef697b KCA	263	/**
11ef697b KCA	264	* ata_acpi_exec_tfs - get then write drive taskfile settings
6746544c	265	* @dev: target ATA device
11ef697b	266	*
6746544c	267	* Evaluate _GTF and excute returned taskfiles.
69b16a5f TH	268	*
	269	* LOCKING:
	270	* EH context.
	271	*
	272	* RETURNS:
6746544c TH	273	* Number of executed taskfiles on success, 0 if _GTF doesn't exist or
6746544c TH	274	* doesn't contain valid data. -errno on other errors.
11ef697b	275	*/
6746544c	276	static int ata_acpi_exec_tfs(struct ata_device *dev)
11ef697b	277	{
6746544c TH	278	struct ata_acpi_gtf *gtf = NULL;
	279	void *ptr_to_free = NULL;
	280	int gtf_count, i, rc;
	281
	282	/* get taskfiles */
	283	rc = ata_dev_get_GTF(dev, &gtf, &ptr_to_free);
	284	if (rc < 0)
	285	return rc;
	286	gtf_count = rc;
	287
	288	/* execute them */
	289	for (i = 0, rc = 0; i < gtf_count; i++) {
	290	int tmp;
	291
	292	/* ACPI errors are eventually ignored. Run till the
	293	* end even after errors.
	294	*/
	295	tmp = taskfile_load_raw(dev, gtf++);
	296	if (!rc)
	297	rc = tmp;
11ef697b KCA	298	}
11ef697b KCA	299
6746544c TH	300	kfree(ptr_to_free);
	301
	302	if (rc == 0)
	303	return gtf_count;
	304	return rc;
11ef697b KCA	305	}
11ef697b KCA	306
7ea1fbc2 KCA	307	/**
7ea1fbc2 KCA	308	* ata_acpi_push_id - send Identify data to drive
3a32a8e9	309	* @dev: target ATA device
7ea1fbc2 KCA	310	*
	311	* _SDD ACPI object: for SATA mode only
	312	* Must be after Identify (Packet) Device -- uses its data
	313	* ATM this function never returns a failure. It is an optional
	314	* method and if it fails for whatever reason, we should still
	315	* just keep going.
69b16a5f TH	316	*
	317	* LOCKING:
	318	* EH context.
	319	*
	320	* RETURNS:
	321	* 0 on success, -errno on failure.
7ea1fbc2	322	*/
6746544c	323	static int ata_acpi_push_id(struct ata_device *dev)
7ea1fbc2	324	{
3a32a8e9	325	struct ata_port *ap = dev->ap;
3a32a8e9	326	int err;
3a32a8e9 TH	327	acpi_status status;
	328	struct acpi_object_list input;
	329	union acpi_object in_params[1];
7ea1fbc2	330
7ea1fbc2	331	if (ata_msg_probe(ap))
3a32a8e9 TH	332	ata_dev_printk(dev, KERN_DEBUG, "%s: ix = %d, port#: %d\n",
3a32a8e9 TH	333	__FUNCTION__, dev->devno, ap->port_no);
7ea1fbc2	334
7ea1fbc2 KCA	335	/* Give the drive Identify data to the drive via the _SDD method */
	336	/* _SDD: set up input parameters */
	337	input.count = 1;
	338	input.pointer = in_params;
	339	in_params[0].type = ACPI_TYPE_BUFFER;
3a32a8e9 TH	340	in_params[0].buffer.length = sizeof(dev->id[0]) * ATA_ID_WORDS;
3a32a8e9 TH	341	in_params[0].buffer.pointer = (u8 *)dev->id;
7ea1fbc2 KCA	342	/* Output buffer: _SDD has no output */
	343
	344	/* It's OK for _SDD to be missing too. */
3a32a8e9	345	swap_buf_le16(dev->id, ATA_ID_WORDS);
fafbae87	346	status = acpi_evaluate_object(dev->acpi_handle, "_SDD", &input, NULL);
3a32a8e9	347	swap_buf_le16(dev->id, ATA_ID_WORDS);
7ea1fbc2 KCA	348
7ea1fbc2 KCA	349	err = ACPI_FAILURE(status) ? -EIO : 0;
69b16a5f TH	350	if (err < 0)
	351	ata_dev_printk(dev, KERN_WARNING,
	352	"ACPI _SDD failed (AE 0x%x)\n", status);
7ea1fbc2	353
6746544c TH	354	return err;
	355	}
	356
	357	/**
	358	* ata_acpi_on_resume - ATA ACPI hook called on resume
	359	* @ap: target ATA port
	360	*
	361	* This function is called when @ap is resumed - right after port
	362	* itself is resumed but before any EH action is taken.
	363	*
	364	* LOCKING:
	365	* EH context.
	366	*/
	367	void ata_acpi_on_resume(struct ata_port *ap)
	368	{
	369	int i;
	370
	371	/* schedule _GTF */
	372	for (i = 0; i < ATA_MAX_DEVICES; i++)
	373	ap->device[i].flags \|= ATA_DFLAG_ACPI_PENDING;
7ea1fbc2 KCA	374	}
7ea1fbc2 KCA	375
6746544c TH	376	/**
	377	* ata_acpi_on_devcfg - ATA ACPI hook called on device donfiguration
	378	* @dev: target ATA device
	379	*
	380	* This function is called when @dev is about to be configured.
	381	* IDENTIFY data might have been modified after this hook is run.
	382	*
	383	* LOCKING:
	384	* EH context.
	385	*
	386	* RETURNS:
	387	* Positive number if IDENTIFY data needs to be refreshed, 0 if not,
	388	* -errno on failure.
	389	*/
	390	int ata_acpi_on_devcfg(struct ata_device *dev)
	391	{
	392	struct ata_port *ap = dev->ap;
	393	struct ata_eh_context *ehc = &ap->eh_context;
	394	int acpi_sata = ap->flags & ATA_FLAG_ACPI_SATA;
	395	int rc;
	396
	397	/* XXX: _STM isn't implemented yet, skip if IDE for now */
	398	if (!acpi_sata)
	399	return 0;
7ea1fbc2	400
6746544c TH	401	if (!dev->acpi_handle)
	402	return 0;
	403
	404	/* do we need to do _GTF? */
	405	if (!(dev->flags & ATA_DFLAG_ACPI_PENDING) &&
	406	!(acpi_sata && (ehc->i.flags & ATA_EHI_DID_HARDRESET)))
	407	return 0;
	408
	409	/* do _SDD if SATA */
	410	if (acpi_sata) {
	411	rc = ata_acpi_push_id(dev);
	412	if (rc)
	413	goto acpi_err;
	414	}
	415
	416	/* do _GTF */
	417	rc = ata_acpi_exec_tfs(dev);
	418	if (rc < 0)
	419	goto acpi_err;
	420
	421	dev->flags &= ~ATA_DFLAG_ACPI_PENDING;
	422
	423	/* refresh IDENTIFY page if any _GTF command has been executed */
	424	if (rc > 0) {
	425	rc = ata_dev_reread_id(dev, 0);
	426	if (rc < 0) {
	427	ata_dev_printk(dev, KERN_ERR, "failed to IDENTIFY "
	428	"after ACPI commands\n");
	429	return rc;
	430	}
	431	}
	432
	433	return 0;
	434
	435	acpi_err:
	436	/* let EH retry on the first failure, disable ACPI on the second */
	437	if (dev->flags & ATA_DFLAG_ACPI_FAILED) {
	438	ata_dev_printk(dev, KERN_WARNING, "ACPI on devcfg failed the "
	439	"second time, disabling (errno=%d)\n", rc);
	440
	441	dev->acpi_handle = NULL;
	442
	443	/* if port is working, request IDENTIFY reload and continue */
	444	if (!(ap->pflags & ATA_PFLAG_FROZEN))
	445	rc = 1;
	446	}
	447	dev->flags \|= ATA_DFLAG_ACPI_FAILED;
	448	return rc;
	449	}