[deliverable/linux.git] / drivers / i2c / busses / i2c-scmi.c

/*
 * SMBus driver for ACPI SMBus CMI
 *
 * Copyright (C) 2009 Crane Cai <crane.cai@amd.com>
 *
 * 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 version 2.
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/stddef.h>
#include <linux/i2c.h>
#include <linux/acpi.h>

#define ACPI_SMBUS_HC_CLASS		"smbus"
#define ACPI_SMBUS_HC_DEVICE_NAME	"cmi"

ACPI_MODULE_NAME("smbus_cmi");

struct smbus_methods_t {
	char *mt_info;
	char *mt_sbr;
	char *mt_sbw;
};

struct acpi_smbus_cmi {
	acpi_handle handle;
	struct i2c_adapter adapter;
	u8 cap_info:1;
	u8 cap_read:1;
	u8 cap_write:1;
	struct smbus_methods_t *methods;
};

static const struct smbus_methods_t smbus_methods = {
	.mt_info = "_SBI",
	.mt_sbr  = "_SBR",
	.mt_sbw  = "_SBW",
};

/* Some IBM BIOSes omit the leading underscore */
static const struct smbus_methods_t ibm_smbus_methods = {
	.mt_info = "SBI_",
	.mt_sbr  = "SBR_",
	.mt_sbw  = "SBW_",
};

static const struct acpi_device_id acpi_smbus_cmi_ids[] = {
	{"SMBUS01", (kernel_ulong_t)&smbus_methods},
	{ACPI_SMBUS_IBM_HID, (kernel_ulong_t)&ibm_smbus_methods},
	{"", 0}
};
MODULE_DEVICE_TABLE(acpi, acpi_smbus_cmi_ids);

#define ACPI_SMBUS_STATUS_OK			0x00
#define ACPI_SMBUS_STATUS_FAIL			0x07
#define ACPI_SMBUS_STATUS_DNAK			0x10
#define ACPI_SMBUS_STATUS_DERR			0x11
#define ACPI_SMBUS_STATUS_CMD_DENY		0x12
#define ACPI_SMBUS_STATUS_UNKNOWN		0x13
#define ACPI_SMBUS_STATUS_ACC_DENY		0x17
#define ACPI_SMBUS_STATUS_TIMEOUT		0x18
#define ACPI_SMBUS_STATUS_NOTSUP		0x19
#define ACPI_SMBUS_STATUS_BUSY			0x1a
#define ACPI_SMBUS_STATUS_PEC			0x1f

#define ACPI_SMBUS_PRTCL_WRITE			0x00
#define ACPI_SMBUS_PRTCL_READ			0x01
#define ACPI_SMBUS_PRTCL_QUICK			0x02
#define ACPI_SMBUS_PRTCL_BYTE			0x04
#define ACPI_SMBUS_PRTCL_BYTE_DATA		0x06
#define ACPI_SMBUS_PRTCL_WORD_DATA		0x08
#define ACPI_SMBUS_PRTCL_BLOCK_DATA		0x0a


static int
acpi_smbus_cmi_access(struct i2c_adapter *adap, u16 addr, unsigned short flags,
		   char read_write, u8 command, int size,
		   union i2c_smbus_data *data)
{
	int result = 0;
	struct acpi_smbus_cmi *smbus_cmi = adap->algo_data;
	unsigned char protocol;
	acpi_status status = 0;
	struct acpi_object_list input;
	union acpi_object mt_params[5];
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
	union acpi_object *pkg;
	char *method;
	int len = 0;

	dev_dbg(&adap->dev, "access size: %d %s\n", size,
		(read_write) ? "READ" : "WRITE");
	switch (size) {
	case I2C_SMBUS_QUICK:
		protocol = ACPI_SMBUS_PRTCL_QUICK;
		command = 0;
		if (read_write == I2C_SMBUS_WRITE) {
			mt_params[3].type = ACPI_TYPE_INTEGER;
			mt_params[3].integer.value = 0;
			mt_params[4].type = ACPI_TYPE_INTEGER;
			mt_params[4].integer.value = 0;
		}
		break;

	case I2C_SMBUS_BYTE:
		protocol = ACPI_SMBUS_PRTCL_BYTE;
		if (read_write == I2C_SMBUS_WRITE) {
			mt_params[3].type = ACPI_TYPE_INTEGER;
			mt_params[3].integer.value = 0;
			mt_params[4].type = ACPI_TYPE_INTEGER;
			mt_params[4].integer.value = 0;
		} else {
			command = 0;
		}
		break;

	case I2C_SMBUS_BYTE_DATA:
		protocol = ACPI_SMBUS_PRTCL_BYTE_DATA;
		if (read_write == I2C_SMBUS_WRITE) {
			mt_params[3].type = ACPI_TYPE_INTEGER;
			mt_params[3].integer.value = 1;
			mt_params[4].type = ACPI_TYPE_INTEGER;
			mt_params[4].integer.value = data->byte;
		}
		break;

	case I2C_SMBUS_WORD_DATA:
		protocol = ACPI_SMBUS_PRTCL_WORD_DATA;
		if (read_write == I2C_SMBUS_WRITE) {
			mt_params[3].type = ACPI_TYPE_INTEGER;
			mt_params[3].integer.value = 2;
			mt_params[4].type = ACPI_TYPE_INTEGER;
			mt_params[4].integer.value = data->word;
		}
		break;

	case I2C_SMBUS_BLOCK_DATA:
		protocol = ACPI_SMBUS_PRTCL_BLOCK_DATA;
		if (read_write == I2C_SMBUS_WRITE) {
			len = data->block[0];
			if (len == 0 || len > I2C_SMBUS_BLOCK_MAX)
				return -EINVAL;
			mt_params[3].type = ACPI_TYPE_INTEGER;
			mt_params[3].integer.value = len;
			mt_params[4].type = ACPI_TYPE_BUFFER;
			mt_params[4].buffer.pointer = data->block + 1;
		}
		break;

	default:
		dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
		return -EOPNOTSUPP;
	}

	if (read_write == I2C_SMBUS_READ) {
		protocol |= ACPI_SMBUS_PRTCL_READ;
		method = smbus_cmi->methods->mt_sbr;
		input.count = 3;
	} else {
		protocol |= ACPI_SMBUS_PRTCL_WRITE;
		method = smbus_cmi->methods->mt_sbw;
		input.count = 5;
	}

	input.pointer = mt_params;
	mt_params[0].type = ACPI_TYPE_INTEGER;
	mt_params[0].integer.value = protocol;
	mt_params[1].type = ACPI_TYPE_INTEGER;
	mt_params[1].integer.value = addr;
	mt_params[2].type = ACPI_TYPE_INTEGER;
	mt_params[2].integer.value = command;

	status = acpi_evaluate_object(smbus_cmi->handle, method, &input,
				      &buffer);
	if (ACPI_FAILURE(status)) {
		ACPI_ERROR((AE_INFO, "Evaluating %s: %i", method, status));
		return -EIO;
	}

	pkg = buffer.pointer;
	if (pkg && pkg->type == ACPI_TYPE_PACKAGE)
		obj = pkg->package.elements;
	else {
		ACPI_ERROR((AE_INFO, "Invalid argument type"));
		result = -EIO;
		goto out;
	}
	if (obj == NULL || obj->type != ACPI_TYPE_INTEGER) {
		ACPI_ERROR((AE_INFO, "Invalid argument type"));
		result = -EIO;
		goto out;
	}

	result = obj->integer.value;
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s return status: %i\n",
			  method, result));

	switch (result) {
	case ACPI_SMBUS_STATUS_OK:
		result = 0;
		break;
	case ACPI_SMBUS_STATUS_BUSY:
		result = -EBUSY;
		goto out;
	case ACPI_SMBUS_STATUS_TIMEOUT:
		result = -ETIMEDOUT;
		goto out;
	case ACPI_SMBUS_STATUS_DNAK:
		result = -ENXIO;
		goto out;
	default:
		result = -EIO;
		goto out;
	}

	if (read_write == I2C_SMBUS_WRITE || size == I2C_SMBUS_QUICK)
		goto out;

	obj = pkg->package.elements + 1;
	if (obj->type != ACPI_TYPE_INTEGER) {
		ACPI_ERROR((AE_INFO, "Invalid argument type"));
		result = -EIO;
		goto out;
	}

	len = obj->integer.value;
	obj = pkg->package.elements + 2;
	switch (size) {
	case I2C_SMBUS_BYTE:
	case I2C_SMBUS_BYTE_DATA:
	case I2C_SMBUS_WORD_DATA:
		if (obj->type != ACPI_TYPE_INTEGER) {
			ACPI_ERROR((AE_INFO, "Invalid argument type"));
			result = -EIO;
			goto out;
		}
		if (len == 2)
			data->word = obj->integer.value;
		else
			data->byte = obj->integer.value;
		break;
	case I2C_SMBUS_BLOCK_DATA:
		if (obj->type != ACPI_TYPE_BUFFER) {
			ACPI_ERROR((AE_INFO, "Invalid argument type"));
			result = -EIO;
			goto out;
		}
		if (len == 0 || len > I2C_SMBUS_BLOCK_MAX)
			return -EPROTO;
		data->block[0] = len;
		memcpy(data->block + 1, obj->buffer.pointer, len);
		break;
	}

out:
	kfree(buffer.pointer);
	dev_dbg(&adap->dev, "Transaction status: %i\n", result);
	return result;
}

static u32 acpi_smbus_cmi_func(struct i2c_adapter *adapter)
{
	struct acpi_smbus_cmi *smbus_cmi = adapter->algo_data;
	u32 ret;

	ret = smbus_cmi->cap_read | smbus_cmi->cap_write ?
		I2C_FUNC_SMBUS_QUICK : 0;

	ret |= smbus_cmi->cap_read ?
		(I2C_FUNC_SMBUS_READ_BYTE |
		I2C_FUNC_SMBUS_READ_BYTE_DATA |
		I2C_FUNC_SMBUS_READ_WORD_DATA |
		I2C_FUNC_SMBUS_READ_BLOCK_DATA) : 0;

	ret |= smbus_cmi->cap_write ?
		(I2C_FUNC_SMBUS_WRITE_BYTE |
		I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
		I2C_FUNC_SMBUS_WRITE_WORD_DATA |
		I2C_FUNC_SMBUS_WRITE_BLOCK_DATA) : 0;

	return ret;
}

static const struct i2c_algorithm acpi_smbus_cmi_algorithm = {
	.smbus_xfer = acpi_smbus_cmi_access,
	.functionality = acpi_smbus_cmi_func,
};


static int acpi_smbus_cmi_add_cap(struct acpi_smbus_cmi *smbus_cmi,
				  const char *name)
{
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
	acpi_status status;

	if (!strcmp(name, smbus_cmi->methods->mt_info)) {
		status = acpi_evaluate_object(smbus_cmi->handle,
					smbus_cmi->methods->mt_info,
					NULL, &buffer);
		if (ACPI_FAILURE(status)) {
			ACPI_ERROR((AE_INFO, "Evaluating %s: %i",
				   smbus_cmi->methods->mt_info, status));
			return -EIO;
		}

		obj = buffer.pointer;
		if (obj && obj->type == ACPI_TYPE_PACKAGE)
			obj = obj->package.elements;
		else {
			ACPI_ERROR((AE_INFO, "Invalid argument type"));
			kfree(buffer.pointer);
			return -EIO;
		}

		if (obj->type != ACPI_TYPE_INTEGER) {
			ACPI_ERROR((AE_INFO, "Invalid argument type"));
			kfree(buffer.pointer);
			return -EIO;
		} else
			ACPI_DEBUG_PRINT((ACPI_DB_INFO, "SMBus CMI Version %x"
					  "\n", (int)obj->integer.value));

		kfree(buffer.pointer);
		smbus_cmi->cap_info = 1;
	} else if (!strcmp(name, smbus_cmi->methods->mt_sbr))
		smbus_cmi->cap_read = 1;
	else if (!strcmp(name, smbus_cmi->methods->mt_sbw))
		smbus_cmi->cap_write = 1;
	else
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Unsupported CMI method: %s\n",
				 name));

	return 0;
}

static acpi_status acpi_smbus_cmi_query_methods(acpi_handle handle, u32 level,
			void *context, void **return_value)
{
	char node_name[5];
	struct acpi_buffer buffer = { sizeof(node_name), node_name };
	struct acpi_smbus_cmi *smbus_cmi = context;
	acpi_status status;

	status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);

	if (ACPI_SUCCESS(status))
		acpi_smbus_cmi_add_cap(smbus_cmi, node_name);

	return AE_OK;
}

static int acpi_smbus_cmi_add(struct acpi_device *device)
{
	struct acpi_smbus_cmi *smbus_cmi;
	const struct acpi_device_id *id;

	smbus_cmi = kzalloc(sizeof(struct acpi_smbus_cmi), GFP_KERNEL);
	if (!smbus_cmi)
		return -ENOMEM;

	smbus_cmi->handle = device->handle;
	strcpy(acpi_device_name(device), ACPI_SMBUS_HC_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_SMBUS_HC_CLASS);
	device->driver_data = smbus_cmi;
	smbus_cmi->cap_info = 0;
	smbus_cmi->cap_read = 0;
	smbus_cmi->cap_write = 0;

	for (id = acpi_smbus_cmi_ids; id->id[0]; id++)
		if (!strcmp(id->id, acpi_device_hid(device)))
			smbus_cmi->methods =
				(struct smbus_methods_t *) id->driver_data;

	acpi_walk_namespace(ACPI_TYPE_METHOD, smbus_cmi->handle, 1,
			    acpi_smbus_cmi_query_methods, NULL, smbus_cmi, NULL);

	if (smbus_cmi->cap_info == 0)
		goto err;

	snprintf(smbus_cmi->adapter.name, sizeof(smbus_cmi->adapter.name),
		"SMBus CMI adapter %s",
		acpi_device_name(device));
	smbus_cmi->adapter.owner = THIS_MODULE;
	smbus_cmi->adapter.algo = &acpi_smbus_cmi_algorithm;
	smbus_cmi->adapter.algo_data = smbus_cmi;
	smbus_cmi->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
	smbus_cmi->adapter.dev.parent = &device->dev;

	if (i2c_add_adapter(&smbus_cmi->adapter)) {
		dev_err(&device->dev, "Couldn't register adapter!\n");
		goto err;
	}

	return 0;

err:
	kfree(smbus_cmi);
	device->driver_data = NULL;
	return -EIO;
}

static int acpi_smbus_cmi_remove(struct acpi_device *device)
{
	struct acpi_smbus_cmi *smbus_cmi = acpi_driver_data(device);

	i2c_del_adapter(&smbus_cmi->adapter);
	kfree(smbus_cmi);
	device->driver_data = NULL;

	return 0;
}

static struct acpi_driver acpi_smbus_cmi_driver = {
	.name = ACPI_SMBUS_HC_DEVICE_NAME,
	.class = ACPI_SMBUS_HC_CLASS,
	.ids = acpi_smbus_cmi_ids,
	.ops = {
		.add = acpi_smbus_cmi_add,
		.remove = acpi_smbus_cmi_remove,
	},
};
module_acpi_driver(acpi_smbus_cmi_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Crane Cai <crane.cai@amd.com>");
MODULE_DESCRIPTION("ACPI SMBus CMI driver");
Commit	Line	Data
dc985421 CC	1	/*
	2	* SMBus driver for ACPI SMBus CMI
	3	*
	4	* Copyright (C) 2009 Crane Cai <crane.cai@amd.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation version 2.
	9	*/
	10
	11	#include <linux/module.h>
	12	#include <linux/slab.h>
	13	#include <linux/kernel.h>
	14	#include <linux/stddef.h>
dc985421 CC	15	#include <linux/i2c.h>
	16	#include <linux/acpi.h>
	17
	18	#define ACPI_SMBUS_HC_CLASS "smbus"
	19	#define ACPI_SMBUS_HC_DEVICE_NAME "cmi"
	20
	21	ACPI_MODULE_NAME("smbus_cmi");
	22
	23	struct smbus_methods_t {
	24	char *mt_info;
	25	char *mt_sbr;
	26	char *mt_sbw;
	27	};
	28
	29	struct acpi_smbus_cmi {
	30	acpi_handle handle;
	31	struct i2c_adapter adapter;
	32	u8 cap_info:1;
	33	u8 cap_read:1;
	34	u8 cap_write:1;
e82e15dd	35	struct smbus_methods_t *methods;
dc985421 CC	36	};
	37
	38	static const struct smbus_methods_t smbus_methods = {
	39	.mt_info = "_SBI",
	40	.mt_sbr = "_SBR",
	41	.mt_sbw = "_SBW",
	42	};
	43
e82e15dd CC	44	/* Some IBM BIOSes omit the leading underscore */
	45	static const struct smbus_methods_t ibm_smbus_methods = {
	46	.mt_info = "SBI_",
	47	.mt_sbr = "SBR_",
	48	.mt_sbw = "SBW_",
	49	};
	50
dc985421	51	static const struct acpi_device_id acpi_smbus_cmi_ids[] = {
e82e15dd CC	52	{"SMBUS01", (kernel_ulong_t)&smbus_methods},
e82e15dd CC	53	{ACPI_SMBUS_IBM_HID, (kernel_ulong_t)&ibm_smbus_methods},
dc985421 CC	54	{"", 0}
dc985421 CC	55	};
0f5ed04c	56	MODULE_DEVICE_TABLE(acpi, acpi_smbus_cmi_ids);
dc985421 CC	57
	58	#define ACPI_SMBUS_STATUS_OK 0x00
	59	#define ACPI_SMBUS_STATUS_FAIL 0x07
	60	#define ACPI_SMBUS_STATUS_DNAK 0x10
	61	#define ACPI_SMBUS_STATUS_DERR 0x11
	62	#define ACPI_SMBUS_STATUS_CMD_DENY 0x12
	63	#define ACPI_SMBUS_STATUS_UNKNOWN 0x13
	64	#define ACPI_SMBUS_STATUS_ACC_DENY 0x17
	65	#define ACPI_SMBUS_STATUS_TIMEOUT 0x18
	66	#define ACPI_SMBUS_STATUS_NOTSUP 0x19
	67	#define ACPI_SMBUS_STATUS_BUSY 0x1a
	68	#define ACPI_SMBUS_STATUS_PEC 0x1f
	69
	70	#define ACPI_SMBUS_PRTCL_WRITE 0x00
	71	#define ACPI_SMBUS_PRTCL_READ 0x01
	72	#define ACPI_SMBUS_PRTCL_QUICK 0x02
	73	#define ACPI_SMBUS_PRTCL_BYTE 0x04
	74	#define ACPI_SMBUS_PRTCL_BYTE_DATA 0x06
	75	#define ACPI_SMBUS_PRTCL_WORD_DATA 0x08
	76	#define ACPI_SMBUS_PRTCL_BLOCK_DATA 0x0a
	77
	78
	79	static int
	80	acpi_smbus_cmi_access(struct i2c_adapter *adap, u16 addr, unsigned short flags,
	81	char read_write, u8 command, int size,
	82	union i2c_smbus_data *data)
	83	{
	84	int result = 0;
	85	struct acpi_smbus_cmi *smbus_cmi = adap->algo_data;
	86	unsigned char protocol;
	87	acpi_status status = 0;
	88	struct acpi_object_list input;
	89	union acpi_object mt_params[5];
	90	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	91	union acpi_object *obj;
	92	union acpi_object *pkg;
	93	char *method;
	94	int len = 0;
	95
	96	dev_dbg(&adap->dev, "access size: %d %s\n", size,
	97	(read_write) ? "READ" : "WRITE");
	98	switch (size) {
	99	case I2C_SMBUS_QUICK:
	100	protocol = ACPI_SMBUS_PRTCL_QUICK;
	101	command = 0;
	102	if (read_write == I2C_SMBUS_WRITE) {
	103	mt_params[3].type = ACPI_TYPE_INTEGER;
	104	mt_params[3].integer.value = 0;
	105	mt_params[4].type = ACPI_TYPE_INTEGER;
	106	mt_params[4].integer.value = 0;
	107	}
	108	break;
	109
	110	case I2C_SMBUS_BYTE:
	111	protocol = ACPI_SMBUS_PRTCL_BYTE;
	112	if (read_write == I2C_SMBUS_WRITE) {
	113	mt_params[3].type = ACPI_TYPE_INTEGER;
	114	mt_params[3].integer.value = 0;
	115	mt_params[4].type = ACPI_TYPE_INTEGER;
	116	mt_params[4].integer.value = 0;
	117	} else {
	118	command = 0;
	119	}
	120	break;
121
122	case I2C_SMBUS_BYTE_DATA:
123	protocol = ACPI_SMBUS_PRTCL_BYTE_DATA;
124	if (read_write == I2C_SMBUS_WRITE) {
125	mt_params[3].type = ACPI_TYPE_INTEGER;
126	mt_params[3].integer.value = 1;
127	mt_params[4].type = ACPI_TYPE_INTEGER;
128	mt_params[4].integer.value = data->byte;
129	}
130	break;
131
132	case I2C_SMBUS_WORD_DATA:
133	protocol = ACPI_SMBUS_PRTCL_WORD_DATA;
134	if (read_write == I2C_SMBUS_WRITE) {
135	mt_params[3].type = ACPI_TYPE_INTEGER;
136	mt_params[3].integer.value = 2;
137	mt_params[4].type = ACPI_TYPE_INTEGER;
138	mt_params[4].integer.value = data->word;
139	}
140	break;
141
142	case I2C_SMBUS_BLOCK_DATA:
143	protocol = ACPI_SMBUS_PRTCL_BLOCK_DATA;
144	if (read_write == I2C_SMBUS_WRITE) {
145	len = data->block[0];
146	if (len == 0 \|\| len > I2C_SMBUS_BLOCK_MAX)
147	return -EINVAL;
148	mt_params[3].type = ACPI_TYPE_INTEGER;
149	mt_params[3].integer.value = len;
150	mt_params[4].type = ACPI_TYPE_BUFFER;
151	mt_params[4].buffer.pointer = data->block + 1;
152	}
153	break;
154
155	default:
156	dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
157	return -EOPNOTSUPP;
158	}
159
160	if (read_write == I2C_SMBUS_READ) {
161	protocol \|= ACPI_SMBUS_PRTCL_READ;
e82e15dd	162	method = smbus_cmi->methods->mt_sbr;
dc985421 CC	163	input.count = 3;
	164	} else {
	165	protocol \|= ACPI_SMBUS_PRTCL_WRITE;
e82e15dd	166	method = smbus_cmi->methods->mt_sbw;
dc985421 CC	167	input.count = 5;
	168	}
	169
	170	input.pointer = mt_params;
	171	mt_params[0].type = ACPI_TYPE_INTEGER;
	172	mt_params[0].integer.value = protocol;
	173	mt_params[1].type = ACPI_TYPE_INTEGER;
	174	mt_params[1].integer.value = addr;
	175	mt_params[2].type = ACPI_TYPE_INTEGER;
	176	mt_params[2].integer.value = command;
	177
	178	status = acpi_evaluate_object(smbus_cmi->handle, method, &input,
	179	&buffer);
	180	if (ACPI_FAILURE(status)) {
	181	ACPI_ERROR((AE_INFO, "Evaluating %s: %i", method, status));
	182	return -EIO;
	183	}
	184
	185	pkg = buffer.pointer;
	186	if (pkg && pkg->type == ACPI_TYPE_PACKAGE)
	187	obj = pkg->package.elements;
	188	else {
	189	ACPI_ERROR((AE_INFO, "Invalid argument type"));
	190	result = -EIO;
	191	goto out;
	192	}
	193	if (obj == NULL \|\| obj->type != ACPI_TYPE_INTEGER) {
	194	ACPI_ERROR((AE_INFO, "Invalid argument type"));
	195	result = -EIO;
	196	goto out;
	197	}
	198
	199	result = obj->integer.value;
	200	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s return status: %i\n",
	201	method, result));
	202
	203	switch (result) {
	204	case ACPI_SMBUS_STATUS_OK:
	205	result = 0;
	206	break;
	207	case ACPI_SMBUS_STATUS_BUSY:
	208	result = -EBUSY;
	209	goto out;
	210	case ACPI_SMBUS_STATUS_TIMEOUT:
	211	result = -ETIMEDOUT;
	212	goto out;
	213	case ACPI_SMBUS_STATUS_DNAK:
	214	result = -ENXIO;
	215	goto out;
	216	default:
	217	result = -EIO;
	218	goto out;
	219	}
	220
	221	if (read_write == I2C_SMBUS_WRITE \|\| size == I2C_SMBUS_QUICK)
	222	goto out;
	223
	224	obj = pkg->package.elements + 1;
e55fea0c	225	if (obj->type != ACPI_TYPE_INTEGER) {
dc985421 CC	226	ACPI_ERROR((AE_INFO, "Invalid argument type"));
	227	result = -EIO;
	228	goto out;
	229	}
	230
	231	len = obj->integer.value;
	232	obj = pkg->package.elements + 2;
	233	switch (size) {
	234	case I2C_SMBUS_BYTE:
	235	case I2C_SMBUS_BYTE_DATA:
	236	case I2C_SMBUS_WORD_DATA:
e55fea0c	237	if (obj->type != ACPI_TYPE_INTEGER) {
dc985421 CC	238	ACPI_ERROR((AE_INFO, "Invalid argument type"));
	239	result = -EIO;
	240	goto out;
	241	}
	242	if (len == 2)
	243	data->word = obj->integer.value;
	244	else
	245	data->byte = obj->integer.value;
	246	break;
	247	case I2C_SMBUS_BLOCK_DATA:
e55fea0c	248	if (obj->type != ACPI_TYPE_BUFFER) {
dc985421 CC	249	ACPI_ERROR((AE_INFO, "Invalid argument type"));
	250	result = -EIO;
	251	goto out;
	252	}
	253	if (len == 0 \|\| len > I2C_SMBUS_BLOCK_MAX)
	254	return -EPROTO;
	255	data->block[0] = len;
	256	memcpy(data->block + 1, obj->buffer.pointer, len);
	257	break;
	258	}
	259
	260	out:
	261	kfree(buffer.pointer);
	262	dev_dbg(&adap->dev, "Transaction status: %i\n", result);
	263	return result;
	264	}
	265
	266	static u32 acpi_smbus_cmi_func(struct i2c_adapter *adapter)
	267	{
	268	struct acpi_smbus_cmi *smbus_cmi = adapter->algo_data;
	269	u32 ret;
	270
	271	ret = smbus_cmi->cap_read \| smbus_cmi->cap_write ?
	272	I2C_FUNC_SMBUS_QUICK : 0;
	273
	274	ret \|= smbus_cmi->cap_read ?
	275	(I2C_FUNC_SMBUS_READ_BYTE \|
	276	I2C_FUNC_SMBUS_READ_BYTE_DATA \|
	277	I2C_FUNC_SMBUS_READ_WORD_DATA \|
	278	I2C_FUNC_SMBUS_READ_BLOCK_DATA) : 0;
	279
	280	ret \|= smbus_cmi->cap_write ?
	281	(I2C_FUNC_SMBUS_WRITE_BYTE \|
	282	I2C_FUNC_SMBUS_WRITE_BYTE_DATA \|
	283	I2C_FUNC_SMBUS_WRITE_WORD_DATA \|
	284	I2C_FUNC_SMBUS_WRITE_BLOCK_DATA) : 0;
	285
	286	return ret;
	287	}
	288
	289	static const struct i2c_algorithm acpi_smbus_cmi_algorithm = {
	290	.smbus_xfer = acpi_smbus_cmi_access,
	291	.functionality = acpi_smbus_cmi_func,
	292	};
	293
	294
	295	static int acpi_smbus_cmi_add_cap(struct acpi_smbus_cmi *smbus_cmi,
	296	const char *name)
	297	{
	298	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	299	union acpi_object *obj;
	300	acpi_status status;
	301
e82e15dd	302	if (!strcmp(name, smbus_cmi->methods->mt_info)) {
dc985421	303	status = acpi_evaluate_object(smbus_cmi->handle,
e82e15dd	304	smbus_cmi->methods->mt_info,
dc985421 CC	305	NULL, &buffer);
	306	if (ACPI_FAILURE(status)) {
	307	ACPI_ERROR((AE_INFO, "Evaluating %s: %i",
e82e15dd	308	smbus_cmi->methods->mt_info, status));
dc985421 CC	309	return -EIO;
	310	}
	311
	312	obj = buffer.pointer;
	313	if (obj && obj->type == ACPI_TYPE_PACKAGE)
	314	obj = obj->package.elements;
	315	else {
	316	ACPI_ERROR((AE_INFO, "Invalid argument type"));
	317	kfree(buffer.pointer);
	318	return -EIO;
	319	}
	320
	321	if (obj->type != ACPI_TYPE_INTEGER) {
	322	ACPI_ERROR((AE_INFO, "Invalid argument type"));
	323	kfree(buffer.pointer);
	324	return -EIO;
	325	} else
	326	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "SMBus CMI Version %x"
	327	"\n", (int)obj->integer.value));
	328
	329	kfree(buffer.pointer);
	330	smbus_cmi->cap_info = 1;
e82e15dd	331	} else if (!strcmp(name, smbus_cmi->methods->mt_sbr))
dc985421	332	smbus_cmi->cap_read = 1;
e82e15dd	333	else if (!strcmp(name, smbus_cmi->methods->mt_sbw))
dc985421 CC	334	smbus_cmi->cap_write = 1;
	335	else
	336	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Unsupported CMI method: %s\n",
	337	name));
	338
	339	return 0;
	340	}
	341
	342	static acpi_status acpi_smbus_cmi_query_methods(acpi_handle handle, u32 level,
	343	void context, void *return_value)
	344	{
	345	char node_name[5];
	346	struct acpi_buffer buffer = { sizeof(node_name), node_name };
	347	struct acpi_smbus_cmi *smbus_cmi = context;
	348	acpi_status status;
	349
	350	status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
	351
	352	if (ACPI_SUCCESS(status))
	353	acpi_smbus_cmi_add_cap(smbus_cmi, node_name);
	354
	355	return AE_OK;
	356	}
	357
	358	static int acpi_smbus_cmi_add(struct acpi_device *device)
	359	{
	360	struct acpi_smbus_cmi *smbus_cmi;
e82e15dd	361	const struct acpi_device_id *id;
dc985421 CC	362
	363	smbus_cmi = kzalloc(sizeof(struct acpi_smbus_cmi), GFP_KERNEL);
	364	if (!smbus_cmi)
	365	return -ENOMEM;
	366
	367	smbus_cmi->handle = device->handle;
	368	strcpy(acpi_device_name(device), ACPI_SMBUS_HC_DEVICE_NAME);
	369	strcpy(acpi_device_class(device), ACPI_SMBUS_HC_CLASS);
	370	device->driver_data = smbus_cmi;
	371	smbus_cmi->cap_info = 0;
	372	smbus_cmi->cap_read = 0;
	373	smbus_cmi->cap_write = 0;
	374
e82e15dd CC	375	for (id = acpi_smbus_cmi_ids; id->id[0]; id++)
	376	if (!strcmp(id->id, acpi_device_hid(device)))
	377	smbus_cmi->methods =
	378	(struct smbus_methods_t *) id->driver_data;
	379
dc985421	380	acpi_walk_namespace(ACPI_TYPE_METHOD, smbus_cmi->handle, 1,
2263576c	381	acpi_smbus_cmi_query_methods, NULL, smbus_cmi, NULL);
dc985421 CC	382
	383	if (smbus_cmi->cap_info == 0)
	384	goto err;
	385
	386	snprintf(smbus_cmi->adapter.name, sizeof(smbus_cmi->adapter.name),
e96c9284 BH	387	"SMBus CMI adapter %s",
e96c9284 BH	388	acpi_device_name(device));
dc985421 CC	389	smbus_cmi->adapter.owner = THIS_MODULE;
	390	smbus_cmi->adapter.algo = &acpi_smbus_cmi_algorithm;
	391	smbus_cmi->adapter.algo_data = smbus_cmi;
	392	smbus_cmi->adapter.class = I2C_CLASS_HWMON \| I2C_CLASS_SPD;
	393	smbus_cmi->adapter.dev.parent = &device->dev;
	394
	395	if (i2c_add_adapter(&smbus_cmi->adapter)) {
	396	dev_err(&device->dev, "Couldn't register adapter!\n");
	397	goto err;
	398	}
	399
	400	return 0;
	401
	402	err:
	403	kfree(smbus_cmi);
	404	device->driver_data = NULL;
	405	return -EIO;
	406	}
	407
51fac838	408	static int acpi_smbus_cmi_remove(struct acpi_device *device)
dc985421 CC	409	{
	410	struct acpi_smbus_cmi *smbus_cmi = acpi_driver_data(device);
	411
	412	i2c_del_adapter(&smbus_cmi->adapter);
	413	kfree(smbus_cmi);
	414	device->driver_data = NULL;
	415
	416	return 0;
	417	}
	418
	419	static struct acpi_driver acpi_smbus_cmi_driver = {
	420	.name = ACPI_SMBUS_HC_DEVICE_NAME,
	421	.class = ACPI_SMBUS_HC_CLASS,
	422	.ids = acpi_smbus_cmi_ids,
	423	.ops = {
	424	.add = acpi_smbus_cmi_add,
	425	.remove = acpi_smbus_cmi_remove,
	426	},
	427	};
20420500	428	module_acpi_driver(acpi_smbus_cmi_driver);
dc985421 CC	429
	430	MODULE_LICENSE("GPL");
	431	MODULE_AUTHOR("Crane Cai <crane.cai@amd.com>");
	432	MODULE_DESCRIPTION("ACPI SMBus CMI driver");