[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / acpi / i2c_ec.c

/*
 * SMBus driver for ACPI Embedded Controller ($Revision: 1.3 $)
 *
 * Copyright (c) 2002, 2005 Ducrot Bruno
 * Copyright (c) 2005 Rich Townsend (tiny hacks & tweaks)
 *
 * 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/version.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/stddef.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/acpi.h>
#include <linux/delay.h>

#include "i2c_ec.h"

#define	xudelay(t)	udelay(t)
#define	xmsleep(t)	msleep(t)

#define ACPI_EC_HC_COMPONENT	0x00080000
#define ACPI_EC_HC_CLASS	"ec_hc_smbus"
#define ACPI_EC_HC_HID		"ACPI0001"
#define ACPI_EC_HC_DRIVER_NAME	"ACPI EC HC smbus driver"
#define ACPI_EC_HC_DEVICE_NAME	"EC HC smbus"

#define _COMPONENT		ACPI_EC_HC_COMPONENT

ACPI_MODULE_NAME("acpi_smbus")

static int acpi_ec_hc_add(struct acpi_device *device);
static int acpi_ec_hc_remove(struct acpi_device *device, int type);

static struct acpi_driver acpi_ec_hc_driver = {
	.name = ACPI_EC_HC_DRIVER_NAME,
	.class = ACPI_EC_HC_CLASS,
	.ids = ACPI_EC_HC_HID,
	.ops = {
		.add = acpi_ec_hc_add,
		.remove = acpi_ec_hc_remove,
		},
};

/* Various bit mask for EC_SC (R) */
#define OBF		0x01
#define IBF		0x02
#define CMD		0x08
#define BURST		0x10
#define SCI_EVT		0x20
#define SMI_EVT		0x40

/* Commands for EC_SC (W) */
#define RD_EC		0x80
#define WR_EC		0x81
#define BE_EC		0x82
#define BD_EC		0x83
#define QR_EC		0x84

/*
 * ACPI 2.0 chapter 13 SMBus 2.0 EC register model
 */

#define ACPI_EC_SMB_PRTCL	0x00	/* protocol, PEC */
#define ACPI_EC_SMB_STS		0x01	/* status */
#define ACPI_EC_SMB_ADDR	0x02	/* address */
#define ACPI_EC_SMB_CMD		0x03	/* command */
#define ACPI_EC_SMB_DATA	0x04	/* 32 data registers */
#define ACPI_EC_SMB_BCNT	0x24	/* number of data bytes */
#define ACPI_EC_SMB_ALRM_A	0x25	/* alarm address */
#define ACPI_EC_SMB_ALRM_D	0x26	/* 2 bytes alarm data */

#define ACPI_EC_SMB_STS_DONE	0x80
#define ACPI_EC_SMB_STS_ALRM	0x40
#define ACPI_EC_SMB_STS_RES	0x20
#define ACPI_EC_SMB_STS_STATUS	0x1f

#define ACPI_EC_SMB_STATUS_OK		0x00
#define ACPI_EC_SMB_STATUS_FAIL		0x07
#define ACPI_EC_SMB_STATUS_DNAK		0x10
#define ACPI_EC_SMB_STATUS_DERR		0x11
#define ACPI_EC_SMB_STATUS_CMD_DENY	0x12
#define ACPI_EC_SMB_STATUS_UNKNOWN	0x13
#define ACPI_EC_SMB_STATUS_ACC_DENY	0x17
#define ACPI_EC_SMB_STATUS_TIMEOUT	0x18
#define ACPI_EC_SMB_STATUS_NOTSUP	0x19
#define ACPI_EC_SMB_STATUS_BUSY		0x1A
#define ACPI_EC_SMB_STATUS_PEC		0x1F

#define ACPI_EC_SMB_PRTCL_WRITE			0x00
#define ACPI_EC_SMB_PRTCL_READ			0x01
#define ACPI_EC_SMB_PRTCL_QUICK			0x02
#define ACPI_EC_SMB_PRTCL_BYTE			0x04
#define ACPI_EC_SMB_PRTCL_BYTE_DATA		0x06
#define ACPI_EC_SMB_PRTCL_WORD_DATA		0x08
#define ACPI_EC_SMB_PRTCL_BLOCK_DATA		0x0a
#define ACPI_EC_SMB_PRTCL_PROC_CALL		0x0c
#define ACPI_EC_SMB_PRTCL_BLOCK_PROC_CALL	0x0d
#define ACPI_EC_SMB_PRTCL_I2C_BLOCK_DATA	0x4a
#define ACPI_EC_SMB_PRTCL_PEC			0x80

/* Length of pre/post transaction sleep (msec) */
#define ACPI_EC_SMB_TRANSACTION_SLEEP		1
#define ACPI_EC_SMB_ACCESS_SLEEP1		1
#define ACPI_EC_SMB_ACCESS_SLEEP2		10

static int acpi_ec_smb_read(struct acpi_ec_smbus *smbus, u8 address, u8 * data)
{
	u8 val;
	int err;

	err = ec_read(smbus->base + address, &val);
	if (!err) {
		*data = val;
	}
	xmsleep(ACPI_EC_SMB_TRANSACTION_SLEEP);
	return (err);
}

static int acpi_ec_smb_write(struct acpi_ec_smbus *smbus, u8 address, u8 data)
{
	int err;

	err = ec_write(smbus->base + address, data);
	return (err);
}

static int
acpi_ec_smb_access(struct i2c_adapter *adap, u16 addr, unsigned short flags,
		   char read_write, u8 command, int size,
		   union i2c_smbus_data *data)
{
	struct acpi_ec_smbus *smbus = adap->algo_data;
	unsigned char protocol, len = 0, pec, temp[2] = { 0, 0 };
	int i;

	if (read_write == I2C_SMBUS_READ) {
		protocol = ACPI_EC_SMB_PRTCL_READ;
	} else {
		protocol = ACPI_EC_SMB_PRTCL_WRITE;
	}
	pec = (flags & I2C_CLIENT_PEC) ? ACPI_EC_SMB_PRTCL_PEC : 0;

	switch (size) {

	case I2C_SMBUS_QUICK:
		protocol |= ACPI_EC_SMB_PRTCL_QUICK;
		read_write = I2C_SMBUS_WRITE;
		break;

	case I2C_SMBUS_BYTE:
		if (read_write == I2C_SMBUS_WRITE) {
			acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->byte);
		}
		protocol |= ACPI_EC_SMB_PRTCL_BYTE;
		break;

	case I2C_SMBUS_BYTE_DATA:
		acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
		if (read_write == I2C_SMBUS_WRITE) {
			acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->byte);
		}
		protocol |= ACPI_EC_SMB_PRTCL_BYTE_DATA;
		break;

	case I2C_SMBUS_WORD_DATA:
		acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
		if (read_write == I2C_SMBUS_WRITE) {
			acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->word);
			acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + 1,
					  data->word >> 8);
		}
		protocol |= ACPI_EC_SMB_PRTCL_WORD_DATA | pec;
		break;

	case I2C_SMBUS_BLOCK_DATA:
		acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
		if (read_write == I2C_SMBUS_WRITE) {
			len = min_t(u8, data->block[0], 32);
			acpi_ec_smb_write(smbus, ACPI_EC_SMB_BCNT, len);
			for (i = 0; i < len; i++)
				acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + i,
						  data->block[i + 1]);
		}
		protocol |= ACPI_EC_SMB_PRTCL_BLOCK_DATA | pec;
		break;

	case I2C_SMBUS_I2C_BLOCK_DATA:
		len = min_t(u8, data->block[0], 32);
		acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
		acpi_ec_smb_write(smbus, ACPI_EC_SMB_BCNT, len);
		if (read_write == I2C_SMBUS_WRITE) {
			for (i = 0; i < len; i++) {
				acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + i,
						  data->block[i + 1]);
			}
		}
		protocol |= ACPI_EC_SMB_PRTCL_I2C_BLOCK_DATA;
		break;

	case I2C_SMBUS_PROC_CALL:
		acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
		acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->word);
		acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + 1, data->word >> 8);
		protocol = ACPI_EC_SMB_PRTCL_PROC_CALL | pec;
		read_write = I2C_SMBUS_READ;
		break;

	case I2C_SMBUS_BLOCK_PROC_CALL:
		protocol |= pec;
		len = min_t(u8, data->block[0], 31);
		acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
		acpi_ec_smb_write(smbus, ACPI_EC_SMB_BCNT, len);
		for (i = 0; i < len; i++)
			acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + i,
					  data->block[i + 1]);
		protocol = ACPI_EC_SMB_PRTCL_BLOCK_PROC_CALL | pec;
		read_write = I2C_SMBUS_READ;
		break;

	default:
		ACPI_DEBUG_PRINT((ACPI_DB_WARN, "EC SMBus adapter: "
				  "Unsupported transaction %d\n", size));
		return (-1);
	}

	acpi_ec_smb_write(smbus, ACPI_EC_SMB_ADDR, addr << 1);
	acpi_ec_smb_write(smbus, ACPI_EC_SMB_PRTCL, protocol);

	acpi_ec_smb_read(smbus, ACPI_EC_SMB_STS, temp + 0);

	if (~temp[0] & ACPI_EC_SMB_STS_DONE) {
		xudelay(500);
		acpi_ec_smb_read(smbus, ACPI_EC_SMB_STS, temp + 0);
	}
	if (~temp[0] & ACPI_EC_SMB_STS_DONE) {
		xmsleep(ACPI_EC_SMB_ACCESS_SLEEP2);
		acpi_ec_smb_read(smbus, ACPI_EC_SMB_STS, temp + 0);
	}
	if ((~temp[0] & ACPI_EC_SMB_STS_DONE)
	    || (temp[0] & ACPI_EC_SMB_STS_STATUS)) {
		return (-1);
	}

	if (read_write == I2C_SMBUS_WRITE) {
		return (0);
	}

	switch (size) {

	case I2C_SMBUS_BYTE:
	case I2C_SMBUS_BYTE_DATA:
		acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA, &data->byte);
		break;

	case I2C_SMBUS_WORD_DATA:
	case I2C_SMBUS_PROC_CALL:
		acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA, temp + 0);
		acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA + 1, temp + 1);
		data->word = (temp[1] << 8) | temp[0];
		break;

	case I2C_SMBUS_BLOCK_DATA:
	case I2C_SMBUS_BLOCK_PROC_CALL:
		len = 0;
		acpi_ec_smb_read(smbus, ACPI_EC_SMB_BCNT, &len);
		len = min_t(u8, len, 32);
	case I2C_SMBUS_I2C_BLOCK_DATA:
		for (i = 0; i < len; i++)
			acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA + i,
					 data->block + i + 1);
		data->block[0] = len;
		break;
	}

	return (0);
}

static u32 acpi_ec_smb_func(struct i2c_adapter *adapter)
{

	return (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
		I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
		I2C_FUNC_SMBUS_BLOCK_DATA |
		I2C_FUNC_SMBUS_PROC_CALL |
		I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
		I2C_FUNC_SMBUS_I2C_BLOCK | I2C_FUNC_SMBUS_HWPEC_CALC);
}

static const struct i2c_algorithm acpi_ec_smbus_algorithm = {
	.smbus_xfer = acpi_ec_smb_access,
	.functionality = acpi_ec_smb_func,
};

static int acpi_ec_hc_add(struct acpi_device *device)
{
	int status;
	unsigned long val;
	struct acpi_ec_hc *ec_hc;
	struct acpi_ec_smbus *smbus;

	if (!device) {
		return -EINVAL;
	}

	ec_hc = kmalloc(sizeof(struct acpi_ec_hc), GFP_KERNEL);
	if (!ec_hc) {
		return -ENOMEM;
	}
	memset(ec_hc, 0, sizeof(struct acpi_ec_hc));

	smbus = kmalloc(sizeof(struct acpi_ec_smbus), GFP_KERNEL);
	if (!smbus) {
		kfree(ec_hc);
		return -ENOMEM;
	}
	memset(smbus, 0, sizeof(struct acpi_ec_smbus));

	ec_hc->handle = device->handle;
	strcpy(acpi_device_name(device), ACPI_EC_HC_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_EC_HC_CLASS);
	acpi_driver_data(device) = ec_hc;

	status = acpi_evaluate_integer(ec_hc->handle, "_EC", NULL, &val);
	if (ACPI_FAILURE(status)) {
		ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error obtaining _EC\n"));
		kfree(ec_hc);
		kfree(smbus);
		return -EIO;
	}

	smbus->ec = acpi_driver_data(device->parent);
	smbus->base = (val & 0xff00ull) >> 8;
	smbus->alert = val & 0xffull;

	smbus->adapter.owner = THIS_MODULE;
	smbus->adapter.algo = &acpi_ec_smbus_algorithm;
	smbus->adapter.algo_data = smbus;

	if (i2c_add_adapter(&smbus->adapter)) {
		ACPI_DEBUG_PRINT((ACPI_DB_WARN,
				  "EC SMBus adapter: Failed to register adapter\n"));
		kfree(smbus);
		kfree(ec_hc);
		return -EIO;
	}

	ec_hc->smbus = smbus;

	printk(KERN_INFO PREFIX "%s [%s]\n",
	       acpi_device_name(device), acpi_device_bid(device));

	return AE_OK;
}

static int acpi_ec_hc_remove(struct acpi_device *device, int type)
{
	struct acpi_ec_hc *ec_hc;

	if (!device) {
		return -EINVAL;
	}
	ec_hc = acpi_driver_data(device);

	i2c_del_adapter(&ec_hc->smbus->adapter);
	kfree(ec_hc->smbus);
	kfree(ec_hc);

	return AE_OK;
}

static int __init acpi_ec_hc_init(void)
{
	int result;

	result = acpi_bus_register_driver(&acpi_ec_hc_driver);
	if (result < 0) {
		return -ENODEV;
	}
	return 0;
}

static void __exit acpi_ec_hc_exit(void)
{
	acpi_bus_unregister_driver(&acpi_ec_hc_driver);
}

struct acpi_ec_hc *acpi_get_ec_hc(struct acpi_device *device)
{
	return ((struct acpi_ec_hc *)acpi_driver_data(device->parent));
}

EXPORT_SYMBOL(acpi_get_ec_hc);

module_init(acpi_ec_hc_init);
module_exit(acpi_ec_hc_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Ducrot Bruno");
MODULE_DESCRIPTION("ACPI EC SMBus driver");
Commit	Line	Data
3f86b832 RT	1	/*
	2	* SMBus driver for ACPI Embedded Controller ($Revision: 1.3 $)
	3	*
	4	* Copyright (c) 2002, 2005 Ducrot Bruno
	5	* Copyright (c) 2005 Rich Townsend (tiny hacks & tweaks)
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation version 2.
	10	*/
	11
	12	#include <linux/version.h>
	13	#include <linux/module.h>
	14	#include <linux/slab.h>
	15	#include <linux/kernel.h>
	16	#include <linux/stddef.h>
	17	#include <linux/sched.h>
	18	#include <linux/init.h>
	19	#include <linux/i2c.h>
	20	#include <linux/acpi.h>
	21	#include <linux/delay.h>
	22
	23	#include "i2c_ec.h"
	24
	25	#define xudelay(t) udelay(t)
	26	#define xmsleep(t) msleep(t)
	27
	28	#define ACPI_EC_HC_COMPONENT 0x00080000
	29	#define ACPI_EC_HC_CLASS "ec_hc_smbus"
	30	#define ACPI_EC_HC_HID "ACPI0001"
	31	#define ACPI_EC_HC_DRIVER_NAME "ACPI EC HC smbus driver"
	32	#define ACPI_EC_HC_DEVICE_NAME "EC HC smbus"
	33
	34	#define _COMPONENT ACPI_EC_HC_COMPONENT
	35
	36	ACPI_MODULE_NAME("acpi_smbus")
	37
	38	static int acpi_ec_hc_add(struct acpi_device *device);
	39	static int acpi_ec_hc_remove(struct acpi_device *device, int type);
	40
	41	static struct acpi_driver acpi_ec_hc_driver = {
	42	.name = ACPI_EC_HC_DRIVER_NAME,
	43	.class = ACPI_EC_HC_CLASS,
	44	.ids = ACPI_EC_HC_HID,
	45	.ops = {
	46	.add = acpi_ec_hc_add,
	47	.remove = acpi_ec_hc_remove,
	48	},
	49	};
	50
	51	/* Various bit mask for EC_SC (R) */
	52	#define OBF 0x01
	53	#define IBF 0x02
	54	#define CMD 0x08
	55	#define BURST 0x10
	56	#define SCI_EVT 0x20
	57	#define SMI_EVT 0x40
	58
	59	/* Commands for EC_SC (W) */
	60	#define RD_EC 0x80
	61	#define WR_EC 0x81
	62	#define BE_EC 0x82
	63	#define BD_EC 0x83
	64	#define QR_EC 0x84
65
66	/*
67	* ACPI 2.0 chapter 13 SMBus 2.0 EC register model
68	*/
69
70	#define ACPI_EC_SMB_PRTCL 0x00 /* protocol, PEC */
71	#define ACPI_EC_SMB_STS 0x01 /* status */
72	#define ACPI_EC_SMB_ADDR 0x02 /* address */
73	#define ACPI_EC_SMB_CMD 0x03 /* command */
74	#define ACPI_EC_SMB_DATA 0x04 /* 32 data registers */
75	#define ACPI_EC_SMB_BCNT 0x24 /* number of data bytes */
76	#define ACPI_EC_SMB_ALRM_A 0x25 /* alarm address */
77	#define ACPI_EC_SMB_ALRM_D 0x26 /* 2 bytes alarm data */
78
79	#define ACPI_EC_SMB_STS_DONE 0x80
80	#define ACPI_EC_SMB_STS_ALRM 0x40
81	#define ACPI_EC_SMB_STS_RES 0x20
82	#define ACPI_EC_SMB_STS_STATUS 0x1f
83
84	#define ACPI_EC_SMB_STATUS_OK 0x00
85	#define ACPI_EC_SMB_STATUS_FAIL 0x07
86	#define ACPI_EC_SMB_STATUS_DNAK 0x10
87	#define ACPI_EC_SMB_STATUS_DERR 0x11
88	#define ACPI_EC_SMB_STATUS_CMD_DENY 0x12
89	#define ACPI_EC_SMB_STATUS_UNKNOWN 0x13
90	#define ACPI_EC_SMB_STATUS_ACC_DENY 0x17
91	#define ACPI_EC_SMB_STATUS_TIMEOUT 0x18
92	#define ACPI_EC_SMB_STATUS_NOTSUP 0x19
93	#define ACPI_EC_SMB_STATUS_BUSY 0x1A
94	#define ACPI_EC_SMB_STATUS_PEC 0x1F
95
96	#define ACPI_EC_SMB_PRTCL_WRITE 0x00
97	#define ACPI_EC_SMB_PRTCL_READ 0x01
98	#define ACPI_EC_SMB_PRTCL_QUICK 0x02
99	#define ACPI_EC_SMB_PRTCL_BYTE 0x04
100	#define ACPI_EC_SMB_PRTCL_BYTE_DATA 0x06
101	#define ACPI_EC_SMB_PRTCL_WORD_DATA 0x08
102	#define ACPI_EC_SMB_PRTCL_BLOCK_DATA 0x0a
103	#define ACPI_EC_SMB_PRTCL_PROC_CALL 0x0c
104	#define ACPI_EC_SMB_PRTCL_BLOCK_PROC_CALL 0x0d
105	#define ACPI_EC_SMB_PRTCL_I2C_BLOCK_DATA 0x4a
106	#define ACPI_EC_SMB_PRTCL_PEC 0x80
107
108	/* Length of pre/post transaction sleep (msec) */
109	#define ACPI_EC_SMB_TRANSACTION_SLEEP 1
110	#define ACPI_EC_SMB_ACCESS_SLEEP1 1
111	#define ACPI_EC_SMB_ACCESS_SLEEP2 10
112
113	static int acpi_ec_smb_read(struct acpi_ec_smbus smbus, u8 address, u8 data)
114	{
115	u8 val;
116	int err;
117
3f86b832 RT	118	err = ec_read(smbus->base + address, &val);
	119	if (!err) {
	120	*data = val;
	121	}
	122	xmsleep(ACPI_EC_SMB_TRANSACTION_SLEEP);
	123	return (err);
	124	}
	125
	126	static int acpi_ec_smb_write(struct acpi_ec_smbus *smbus, u8 address, u8 data)
	127	{
	128	int err;
	129
3f86b832 RT	130	err = ec_write(smbus->base + address, data);
	131	return (err);
	132	}
	133
	134	static int
	135	acpi_ec_smb_access(struct i2c_adapter *adap, u16 addr, unsigned short flags,
	136	char read_write, u8 command, int size,
	137	union i2c_smbus_data *data)
	138	{
	139	struct acpi_ec_smbus *smbus = adap->algo_data;
	140	unsigned char protocol, len = 0, pec, temp[2] = { 0, 0 };
	141	int i;
	142
3f86b832 RT	143	if (read_write == I2C_SMBUS_READ) {
	144	protocol = ACPI_EC_SMB_PRTCL_READ;
	145	} else {
	146	protocol = ACPI_EC_SMB_PRTCL_WRITE;
	147	}
	148	pec = (flags & I2C_CLIENT_PEC) ? ACPI_EC_SMB_PRTCL_PEC : 0;
	149
	150	switch (size) {
	151
	152	case I2C_SMBUS_QUICK:
	153	protocol \|= ACPI_EC_SMB_PRTCL_QUICK;
	154	read_write = I2C_SMBUS_WRITE;
	155	break;
	156
	157	case I2C_SMBUS_BYTE:
	158	if (read_write == I2C_SMBUS_WRITE) {
	159	acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->byte);
	160	}
	161	protocol \|= ACPI_EC_SMB_PRTCL_BYTE;
	162	break;
	163
	164	case I2C_SMBUS_BYTE_DATA:
	165	acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
	166	if (read_write == I2C_SMBUS_WRITE) {
	167	acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->byte);
	168	}
	169	protocol \|= ACPI_EC_SMB_PRTCL_BYTE_DATA;
	170	break;
	171
	172	case I2C_SMBUS_WORD_DATA:
	173	acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
	174	if (read_write == I2C_SMBUS_WRITE) {
	175	acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->word);
	176	acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + 1,
	177	data->word >> 8);
	178	}
	179	protocol \|= ACPI_EC_SMB_PRTCL_WORD_DATA \| pec;
	180	break;
	181
	182	case I2C_SMBUS_BLOCK_DATA:
	183	acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
	184	if (read_write == I2C_SMBUS_WRITE) {
	185	len = min_t(u8, data->block[0], 32);
	186	acpi_ec_smb_write(smbus, ACPI_EC_SMB_BCNT, len);
	187	for (i = 0; i < len; i++)
	188	acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + i,
	189	data->block[i + 1]);
	190	}
	191	protocol \|= ACPI_EC_SMB_PRTCL_BLOCK_DATA \| pec;
	192	break;
	193
	194	case I2C_SMBUS_I2C_BLOCK_DATA:
	195	len = min_t(u8, data->block[0], 32);
	196	acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
	197	acpi_ec_smb_write(smbus, ACPI_EC_SMB_BCNT, len);
	198	if (read_write == I2C_SMBUS_WRITE) {
	199	for (i = 0; i < len; i++) {
	200	acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + i,
	201	data->block[i + 1]);
	202	}
	203	}
	204	protocol \|= ACPI_EC_SMB_PRTCL_I2C_BLOCK_DATA;
	205	break;
	206
207	case I2C_SMBUS_PROC_CALL:
208	acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
209	acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->word);
210	acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + 1, data->word >> 8);
211	protocol = ACPI_EC_SMB_PRTCL_PROC_CALL \| pec;
212	read_write = I2C_SMBUS_READ;
213	break;
214
215	case I2C_SMBUS_BLOCK_PROC_CALL:
216	protocol \|= pec;
217	len = min_t(u8, data->block[0], 31);
218	acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
219	acpi_ec_smb_write(smbus, ACPI_EC_SMB_BCNT, len);
220	for (i = 0; i < len; i++)
221	acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + i,
222	data->block[i + 1]);
223	protocol = ACPI_EC_SMB_PRTCL_BLOCK_PROC_CALL \| pec;
224	read_write = I2C_SMBUS_READ;
225	break;
226
227	default:
228	ACPI_DEBUG_PRINT((ACPI_DB_WARN, "EC SMBus adapter: "
229	"Unsupported transaction %d\n", size));
230	return (-1);
231	}
232
233	acpi_ec_smb_write(smbus, ACPI_EC_SMB_ADDR, addr << 1);
234	acpi_ec_smb_write(smbus, ACPI_EC_SMB_PRTCL, protocol);
235
236	acpi_ec_smb_read(smbus, ACPI_EC_SMB_STS, temp + 0);
237
238	if (~temp[0] & ACPI_EC_SMB_STS_DONE) {
239	xudelay(500);
240	acpi_ec_smb_read(smbus, ACPI_EC_SMB_STS, temp + 0);
241	}
242	if (~temp[0] & ACPI_EC_SMB_STS_DONE) {
243	xmsleep(ACPI_EC_SMB_ACCESS_SLEEP2);
244	acpi_ec_smb_read(smbus, ACPI_EC_SMB_STS, temp + 0);
245	}
246	if ((~temp[0] & ACPI_EC_SMB_STS_DONE)
247	\|\| (temp[0] & ACPI_EC_SMB_STS_STATUS)) {
248	return (-1);
249	}
250
251	if (read_write == I2C_SMBUS_WRITE) {
252	return (0);
253	}
254
255	switch (size) {
256
257	case I2C_SMBUS_BYTE:
258	case I2C_SMBUS_BYTE_DATA:
259	acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA, &data->byte);
260	break;
261
262	case I2C_SMBUS_WORD_DATA:
263	case I2C_SMBUS_PROC_CALL:
264	acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA, temp + 0);
265	acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA + 1, temp + 1);
266	data->word = (temp[1] << 8) \| temp[0];
267	break;
268
269	case I2C_SMBUS_BLOCK_DATA:
270	case I2C_SMBUS_BLOCK_PROC_CALL:
271	len = 0;
272	acpi_ec_smb_read(smbus, ACPI_EC_SMB_BCNT, &len);
273	len = min_t(u8, len, 32);
274	case I2C_SMBUS_I2C_BLOCK_DATA:
275	for (i = 0; i < len; i++)
276	acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA + i,
277	data->block + i + 1);
278	data->block[0] = len;
279	break;
280	}
281
282	return (0);
283	}
284
285	static u32 acpi_ec_smb_func(struct i2c_adapter *adapter)
286	{
3f86b832 RT	287
	288	return (I2C_FUNC_SMBUS_QUICK \| I2C_FUNC_SMBUS_BYTE \|
	289	I2C_FUNC_SMBUS_BYTE_DATA \| I2C_FUNC_SMBUS_WORD_DATA \|
	290	I2C_FUNC_SMBUS_BLOCK_DATA \|
	291	I2C_FUNC_SMBUS_PROC_CALL \|
	292	I2C_FUNC_SMBUS_BLOCK_PROC_CALL \|
	293	I2C_FUNC_SMBUS_I2C_BLOCK \| I2C_FUNC_SMBUS_HWPEC_CALC);
	294	}
	295
8f9082c5	296	static const struct i2c_algorithm acpi_ec_smbus_algorithm = {
3f86b832 RT	297	.smbus_xfer = acpi_ec_smb_access,
	298	.functionality = acpi_ec_smb_func,
	299	};
	300
	301	static int acpi_ec_hc_add(struct acpi_device *device)
	302	{
	303	int status;
	304	unsigned long val;
	305	struct acpi_ec_hc *ec_hc;
	306	struct acpi_ec_smbus *smbus;
	307
3f86b832	308	if (!device) {
635227ee	309	return -EINVAL;
3f86b832 RT	310	}
	311
	312	ec_hc = kmalloc(sizeof(struct acpi_ec_hc), GFP_KERNEL);
	313	if (!ec_hc) {
635227ee	314	return -ENOMEM;
3f86b832 RT	315	}
	316	memset(ec_hc, 0, sizeof(struct acpi_ec_hc));
	317
	318	smbus = kmalloc(sizeof(struct acpi_ec_smbus), GFP_KERNEL);
	319	if (!smbus) {
	320	kfree(ec_hc);
635227ee	321	return -ENOMEM;
3f86b832 RT	322	}
	323	memset(smbus, 0, sizeof(struct acpi_ec_smbus));
	324
	325	ec_hc->handle = device->handle;
	326	strcpy(acpi_device_name(device), ACPI_EC_HC_DEVICE_NAME);
	327	strcpy(acpi_device_class(device), ACPI_EC_HC_CLASS);
	328	acpi_driver_data(device) = ec_hc;
	329
	330	status = acpi_evaluate_integer(ec_hc->handle, "_EC", NULL, &val);
	331	if (ACPI_FAILURE(status)) {
	332	ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error obtaining _EC\n"));
0ee6a173	333	kfree(ec_hc);
3f86b832	334	kfree(smbus);
635227ee	335	return -EIO;
3f86b832 RT	336	}
	337
	338	smbus->ec = acpi_driver_data(device->parent);
	339	smbus->base = (val & 0xff00ull) >> 8;
	340	smbus->alert = val & 0xffull;
	341
	342	smbus->adapter.owner = THIS_MODULE;
	343	smbus->adapter.algo = &acpi_ec_smbus_algorithm;
	344	smbus->adapter.algo_data = smbus;
	345
	346	if (i2c_add_adapter(&smbus->adapter)) {
	347	ACPI_DEBUG_PRINT((ACPI_DB_WARN,
	348	"EC SMBus adapter: Failed to register adapter\n"));
	349	kfree(smbus);
	350	kfree(ec_hc);
635227ee	351	return -EIO;
3f86b832 RT	352	}
	353
	354	ec_hc->smbus = smbus;
	355
	356	printk(KERN_INFO PREFIX "%s [%s]\n",
	357	acpi_device_name(device), acpi_device_bid(device));
	358
635227ee	359	return AE_OK;
3f86b832 RT	360	}
	361
	362	static int acpi_ec_hc_remove(struct acpi_device *device, int type)
	363	{
	364	struct acpi_ec_hc *ec_hc;
	365
3f86b832	366	if (!device) {
635227ee	367	return -EINVAL;
3f86b832 RT	368	}
	369	ec_hc = acpi_driver_data(device);
	370
	371	i2c_del_adapter(&ec_hc->smbus->adapter);
	372	kfree(ec_hc->smbus);
	373	kfree(ec_hc);
	374
635227ee	375	return AE_OK;
3f86b832 RT	376	}
	377
	378	static int __init acpi_ec_hc_init(void)
	379	{
	380	int result;
	381
3f86b832 RT	382	result = acpi_bus_register_driver(&acpi_ec_hc_driver);
3f86b832 RT	383	if (result < 0) {
635227ee	384	return -ENODEV;
3f86b832	385	}
635227ee	386	return 0;
3f86b832 RT	387	}
	388
	389	static void __exit acpi_ec_hc_exit(void)
	390	{
3f86b832 RT	391	acpi_bus_unregister_driver(&acpi_ec_hc_driver);
	392	}
	393
	394	struct acpi_ec_hc acpi_get_ec_hc(struct acpi_device device)
	395	{
3f86b832 RT	396	return ((struct acpi_ec_hc *)acpi_driver_data(device->parent));
	397	}
	398
	399	EXPORT_SYMBOL(acpi_get_ec_hc);
	400
	401	module_init(acpi_ec_hc_init);
	402	module_exit(acpi_ec_hc_exit);
	403
	404	MODULE_LICENSE("GPL");
	405	MODULE_AUTHOR("Ducrot Bruno");
	406	MODULE_DESCRIPTION("ACPI EC SMBus driver");