[deliverable/linux.git] / drivers / i2c / i2c-acpi.c

/*
 * I2C ACPI code
 *
 * Copyright (C) 2014 Intel Corp
 *
 * Author: Lan Tianyu <tianyu.lan@intel.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 */
#define pr_fmt(fmt) "I2C/ACPI : " fmt

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/acpi.h>

struct acpi_i2c_handler_data {
	struct acpi_connection_info info;
	struct i2c_adapter *adapter;
};

struct gsb_buffer {
	u8	status;
	u8	len;
	union {
		u16	wdata;
		u8	bdata;
		u8	data[0];
	};
} __packed;

static int acpi_i2c_add_resource(struct acpi_resource *ares, void *data)
{
	struct i2c_board_info *info = data;

	if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
		struct acpi_resource_i2c_serialbus *sb;

		sb = &ares->data.i2c_serial_bus;
		if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
			info->addr = sb->slave_address;
			if (sb->access_mode == ACPI_I2C_10BIT_MODE)
				info->flags |= I2C_CLIENT_TEN;
		}
	} else if (info->irq < 0) {
		struct resource r;

		if (acpi_dev_resource_interrupt(ares, 0, &r))
			info->irq = r.start;
	}

	/* Tell the ACPI core to skip this resource */
	return 1;
}

static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
				       void *data, void **return_value)
{
	struct i2c_adapter *adapter = data;
	struct list_head resource_list;
	struct i2c_board_info info;
	struct acpi_device *adev;
	int ret;

	if (acpi_bus_get_device(handle, &adev))
		return AE_OK;
	if (acpi_bus_get_status(adev) || !adev->status.present)
		return AE_OK;

	memset(&info, 0, sizeof(info));
	info.acpi_node.companion = adev;
	info.irq = -1;

	INIT_LIST_HEAD(&resource_list);
	ret = acpi_dev_get_resources(adev, &resource_list,
				     acpi_i2c_add_resource, &info);
	acpi_dev_free_resource_list(&resource_list);

	if (ret < 0 || !info.addr)
		return AE_OK;

	adev->power.flags.ignore_parent = true;
	strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
	if (!i2c_new_device(adapter, &info)) {
		adev->power.flags.ignore_parent = false;
		dev_err(&adapter->dev,
			"failed to add I2C device %s from ACPI\n",
			dev_name(&adev->dev));
	}

	return AE_OK;
}

/**
 * acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
 * @adap: pointer to adapter
 *
 * Enumerate all I2C slave devices behind this adapter by walking the ACPI
 * namespace. When a device is found it will be added to the Linux device
 * model and bound to the corresponding ACPI handle.
 */
void acpi_i2c_register_devices(struct i2c_adapter *adap)
{
	acpi_handle handle;
	acpi_status status;

	if (!adap->dev.parent)
		return;

	handle = ACPI_HANDLE(adap->dev.parent);
	if (!handle)
		return;

	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
				     acpi_i2c_add_device, NULL,
				     adap, NULL);
	if (ACPI_FAILURE(status))
		dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
}

#ifdef CONFIG_ACPI_I2C_OPREGION
static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
		u8 cmd, u8 *data, u8 data_len)
{

	struct i2c_msg msgs[2];
	int ret;
	u8 *buffer;

	buffer = kzalloc(data_len, GFP_KERNEL);
	if (!buffer)
		return AE_NO_MEMORY;

	msgs[0].addr = client->addr;
	msgs[0].flags = client->flags;
	msgs[0].len = 1;
	msgs[0].buf = &cmd;

	msgs[1].addr = client->addr;
	msgs[1].flags = client->flags | I2C_M_RD;
	msgs[1].len = data_len;
	msgs[1].buf = buffer;

	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	if (ret < 0)
		dev_err(&client->adapter->dev, "i2c read failed\n");
	else
		memcpy(data, buffer, data_len);

	kfree(buffer);
	return ret;
}

static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
		u8 cmd, u8 *data, u8 data_len)
{

	struct i2c_msg msgs[1];
	u8 *buffer;
	int ret = AE_OK;

	buffer = kzalloc(data_len + 1, GFP_KERNEL);
	if (!buffer)
		return AE_NO_MEMORY;

	buffer[0] = cmd;
	memcpy(buffer + 1, data, data_len);

	msgs[0].addr = client->addr;
	msgs[0].flags = client->flags;
	msgs[0].len = data_len + 1;
	msgs[0].buf = buffer;

	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	if (ret < 0)
		dev_err(&client->adapter->dev, "i2c write failed\n");

	kfree(buffer);
	return ret;
}

static acpi_status
acpi_i2c_space_handler(u32 function, acpi_physical_address command,
			u32 bits, u64 *value64,
			void *handler_context, void *region_context)
{
	struct gsb_buffer *gsb = (struct gsb_buffer *)value64;
	struct acpi_i2c_handler_data *data = handler_context;
	struct acpi_connection_info *info = &data->info;
	struct acpi_resource_i2c_serialbus *sb;
	struct i2c_adapter *adapter = data->adapter;
	struct i2c_client client;
	struct acpi_resource *ares;
	u32 accessor_type = function >> 16;
	u8 action = function & ACPI_IO_MASK;
	acpi_status ret = AE_OK;
	int status;

	ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
	if (ACPI_FAILURE(ret))
		return ret;

	if (!value64 || ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
		ret = AE_BAD_PARAMETER;
		goto err;
	}

	sb = &ares->data.i2c_serial_bus;
	if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
		ret = AE_BAD_PARAMETER;
		goto err;
	}

	memset(&client, 0, sizeof(client));
	client.adapter = adapter;
	client.addr = sb->slave_address;
	client.flags = 0;

	if (sb->access_mode == ACPI_I2C_10BIT_MODE)
		client.flags |= I2C_CLIENT_TEN;

	switch (accessor_type) {
	case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
		if (action == ACPI_READ) {
			status = i2c_smbus_read_byte(&client);
			if (status >= 0) {
				gsb->bdata = status;
				status = 0;
			}
		} else {
			status = i2c_smbus_write_byte(&client, gsb->bdata);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_BYTE:
		if (action == ACPI_READ) {
			status = i2c_smbus_read_byte_data(&client, command);
			if (status >= 0) {
				gsb->bdata = status;
				status = 0;
			}
		} else {
			status = i2c_smbus_write_byte_data(&client, command,
					gsb->bdata);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_WORD:
		if (action == ACPI_READ) {
			status = i2c_smbus_read_word_data(&client, command);
			if (status >= 0) {
				gsb->wdata = status;
				status = 0;
			}
		} else {
			status = i2c_smbus_write_word_data(&client, command,
					gsb->wdata);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
		if (action == ACPI_READ) {
			status = i2c_smbus_read_block_data(&client, command,
					gsb->data);
			if (status >= 0) {
				gsb->len = status;
				status = 0;
			}
		} else {
			status = i2c_smbus_write_block_data(&client, command,
					gsb->len, gsb->data);
		}
		break;

	case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
		if (action == ACPI_READ) {
			status = acpi_gsb_i2c_read_bytes(&client, command,
					gsb->data, info->access_length);
			if (status > 0)
				status = 0;
		} else {
			status = acpi_gsb_i2c_write_bytes(&client, command,
					gsb->data, info->access_length);
		}
		break;

	default:
		pr_info("protocol(0x%02x) is not supported.\n", accessor_type);
		ret = AE_BAD_PARAMETER;
		goto err;
	}

	gsb->status = status;

 err:
	ACPI_FREE(ares);
	return ret;
}


int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
{
	acpi_handle handle = ACPI_HANDLE(adapter->dev.parent);
	struct acpi_i2c_handler_data *data;
	acpi_status status;

	if (!handle)
		return -ENODEV;

	data = kzalloc(sizeof(struct acpi_i2c_handler_data),
			    GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->adapter = adapter;
	status = acpi_bus_attach_private_data(handle, (void *)data);
	if (ACPI_FAILURE(status)) {
		kfree(data);
		return -ENOMEM;
	}

	status = acpi_install_address_space_handler(handle,
				ACPI_ADR_SPACE_GSBUS,
				&acpi_i2c_space_handler,
				NULL,
				data);
	if (ACPI_FAILURE(status)) {
		dev_err(&adapter->dev, "Error installing i2c space handler\n");
		acpi_bus_detach_private_data(handle);
		kfree(data);
		return -ENOMEM;
	}

	return 0;
}

void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
{
	acpi_handle handle = ACPI_HANDLE(adapter->dev.parent);
	struct acpi_i2c_handler_data *data;
	acpi_status status;

	if (!handle)
		return;

	acpi_remove_address_space_handler(handle,
				ACPI_ADR_SPACE_GSBUS,
				&acpi_i2c_space_handler);

	status = acpi_bus_get_private_data(handle, (void **)&data);
	if (ACPI_SUCCESS(status))
		kfree(data);

	acpi_bus_detach_private_data(handle);
}
#endif
Commit	Line	Data
5d98e61d LT	1	/*
	2	* I2C ACPI code
	3	*
	4	* Copyright (C) 2014 Intel Corp
	5	*
	6	* Author: Lan Tianyu <tianyu.lan@intel.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
	14	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	15	* for more details.
	16	*/
	17	#define pr_fmt(fmt) "I2C/ACPI : " fmt
	18
	19	#include <linux/kernel.h>
	20	#include <linux/errno.h>
	21	#include <linux/err.h>
	22	#include <linux/i2c.h>
	23	#include <linux/acpi.h>
	24
	25	struct acpi_i2c_handler_data {
	26	struct acpi_connection_info info;
	27	struct i2c_adapter *adapter;
	28	};
	29
	30	struct gsb_buffer {
	31	u8 status;
	32	u8 len;
	33	union {
	34	u16 wdata;
	35	u8 bdata;
	36	u8 data[0];
	37	};
	38	} __packed;
	39
da3c6647 LT	40	static int acpi_i2c_add_resource(struct acpi_resource ares, void data)
	41	{
	42	struct i2c_board_info *info = data;
	43
	44	if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
	45	struct acpi_resource_i2c_serialbus *sb;
	46
	47	sb = &ares->data.i2c_serial_bus;
	48	if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_I2C) {
	49	info->addr = sb->slave_address;
	50	if (sb->access_mode == ACPI_I2C_10BIT_MODE)
	51	info->flags \|= I2C_CLIENT_TEN;
	52	}
	53	} else if (info->irq < 0) {
	54	struct resource r;
	55
	56	if (acpi_dev_resource_interrupt(ares, 0, &r))
	57	info->irq = r.start;
	58	}
	59
	60	/* Tell the ACPI core to skip this resource */
	61	return 1;
	62	}
	63
	64	static acpi_status acpi_i2c_add_device(acpi_handle handle, u32 level,
	65	void data, void *return_value)
	66	{
	67	struct i2c_adapter *adapter = data;
	68	struct list_head resource_list;
	69	struct i2c_board_info info;
	70	struct acpi_device *adev;
	71	int ret;
	72
	73	if (acpi_bus_get_device(handle, &adev))
	74	return AE_OK;
	75	if (acpi_bus_get_status(adev) \|\| !adev->status.present)
	76	return AE_OK;
	77
	78	memset(&info, 0, sizeof(info));
	79	info.acpi_node.companion = adev;
	80	info.irq = -1;
	81
	82	INIT_LIST_HEAD(&resource_list);
	83	ret = acpi_dev_get_resources(adev, &resource_list,
	84	acpi_i2c_add_resource, &info);
	85	acpi_dev_free_resource_list(&resource_list);
	86
	87	if (ret < 0 \|\| !info.addr)
	88	return AE_OK;
	89
	90	adev->power.flags.ignore_parent = true;
	91	strlcpy(info.type, dev_name(&adev->dev), sizeof(info.type));
	92	if (!i2c_new_device(adapter, &info)) {
	93	adev->power.flags.ignore_parent = false;
	94	dev_err(&adapter->dev,
	95	"failed to add I2C device %s from ACPI\n",
	96	dev_name(&adev->dev));
	97	}
	98
	99	return AE_OK;
	100	}
	101
	102	/**
	103	* acpi_i2c_register_devices - enumerate I2C slave devices behind adapter
104	* @adap: pointer to adapter
105	*
106	* Enumerate all I2C slave devices behind this adapter by walking the ACPI
107	* namespace. When a device is found it will be added to the Linux device
108	* model and bound to the corresponding ACPI handle.
109	*/
110	void acpi_i2c_register_devices(struct i2c_adapter *adap)
111	{
112	acpi_handle handle;
113	acpi_status status;
114
115	if (!adap->dev.parent)
116	return;
117
118	handle = ACPI_HANDLE(adap->dev.parent);
119	if (!handle)
120	return;
121
122	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
123	acpi_i2c_add_device, NULL,
124	adap, NULL);
125	if (ACPI_FAILURE(status))
126	dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
127	}
128
36604751	129	#ifdef CONFIG_ACPI_I2C_OPREGION
5d98e61d LT	130	static int acpi_gsb_i2c_read_bytes(struct i2c_client *client,
	131	u8 cmd, u8 *data, u8 data_len)
	132	{
	133
	134	struct i2c_msg msgs[2];
	135	int ret;
	136	u8 *buffer;
	137
	138	buffer = kzalloc(data_len, GFP_KERNEL);
	139	if (!buffer)
	140	return AE_NO_MEMORY;
	141
	142	msgs[0].addr = client->addr;
	143	msgs[0].flags = client->flags;
	144	msgs[0].len = 1;
	145	msgs[0].buf = &cmd;
	146
	147	msgs[1].addr = client->addr;
	148	msgs[1].flags = client->flags \| I2C_M_RD;
	149	msgs[1].len = data_len;
	150	msgs[1].buf = buffer;
	151
	152	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	153	if (ret < 0)
	154	dev_err(&client->adapter->dev, "i2c read failed\n");
	155	else
	156	memcpy(data, buffer, data_len);
	157
	158	kfree(buffer);
	159	return ret;
	160	}
	161
	162	static int acpi_gsb_i2c_write_bytes(struct i2c_client *client,
	163	u8 cmd, u8 *data, u8 data_len)
	164	{
	165
	166	struct i2c_msg msgs[1];
	167	u8 *buffer;
	168	int ret = AE_OK;
	169
	170	buffer = kzalloc(data_len + 1, GFP_KERNEL);
	171	if (!buffer)
	172	return AE_NO_MEMORY;
	173
	174	buffer[0] = cmd;
	175	memcpy(buffer + 1, data, data_len);
	176
	177	msgs[0].addr = client->addr;
	178	msgs[0].flags = client->flags;
	179	msgs[0].len = data_len + 1;
	180	msgs[0].buf = buffer;
	181
	182	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
	183	if (ret < 0)
	184	dev_err(&client->adapter->dev, "i2c write failed\n");
	185
	186	kfree(buffer);
	187	return ret;
	188	}
	189
	190	static acpi_status
	191	acpi_i2c_space_handler(u32 function, acpi_physical_address command,
	192	u32 bits, u64 *value64,
	193	void handler_context, void region_context)
194	{
195	struct gsb_buffer gsb = (struct gsb_buffer )value64;
196	struct acpi_i2c_handler_data *data = handler_context;
197	struct acpi_connection_info *info = &data->info;
198	struct acpi_resource_i2c_serialbus *sb;
199	struct i2c_adapter *adapter = data->adapter;
200	struct i2c_client client;
201	struct acpi_resource *ares;
202	u32 accessor_type = function >> 16;
203	u8 action = function & ACPI_IO_MASK;
204	acpi_status ret = AE_OK;
205	int status;
206
207	ret = acpi_buffer_to_resource(info->connection, info->length, &ares);
208	if (ACPI_FAILURE(ret))
209	return ret;
210
211	if (!value64 \|\| ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) {
212	ret = AE_BAD_PARAMETER;
213	goto err;
214	}
215
216	sb = &ares->data.i2c_serial_bus;
217	if (sb->type != ACPI_RESOURCE_SERIAL_TYPE_I2C) {
218	ret = AE_BAD_PARAMETER;
219	goto err;
220	}
221
222	memset(&client, 0, sizeof(client));
223	client.adapter = adapter;
224	client.addr = sb->slave_address;
225	client.flags = 0;
226
227	if (sb->access_mode == ACPI_I2C_10BIT_MODE)
228	client.flags \|= I2C_CLIENT_TEN;
229
230	switch (accessor_type) {
231	case ACPI_GSB_ACCESS_ATTRIB_SEND_RCV:
232	if (action == ACPI_READ) {
233	status = i2c_smbus_read_byte(&client);
234	if (status >= 0) {
235	gsb->bdata = status;
236	status = 0;
237	}
238	} else {
239	status = i2c_smbus_write_byte(&client, gsb->bdata);
240	}
241	break;
242
243	case ACPI_GSB_ACCESS_ATTRIB_BYTE:
244	if (action == ACPI_READ) {
245	status = i2c_smbus_read_byte_data(&client, command);
246	if (status >= 0) {
247	gsb->bdata = status;
248	status = 0;
249	}
250	} else {
251	status = i2c_smbus_write_byte_data(&client, command,
252	gsb->bdata);
253	}
254	break;
255
256	case ACPI_GSB_ACCESS_ATTRIB_WORD:
257	if (action == ACPI_READ) {
258	status = i2c_smbus_read_word_data(&client, command);
259	if (status >= 0) {
260	gsb->wdata = status;
261	status = 0;
262	}
263	} else {
264	status = i2c_smbus_write_word_data(&client, command,
265	gsb->wdata);
266	}
267	break;
268
269	case ACPI_GSB_ACCESS_ATTRIB_BLOCK:
270	if (action == ACPI_READ) {
271	status = i2c_smbus_read_block_data(&client, command,
272	gsb->data);
273	if (status >= 0) {
274	gsb->len = status;
275	status = 0;
276	}
277	} else {
278	status = i2c_smbus_write_block_data(&client, command,
279	gsb->len, gsb->data);
280	}
281	break;
282
283	case ACPI_GSB_ACCESS_ATTRIB_MULTIBYTE:
284	if (action == ACPI_READ) {
285	status = acpi_gsb_i2c_read_bytes(&client, command,
286	gsb->data, info->access_length);
287	if (status > 0)
288	status = 0;
289	} else {
290	status = acpi_gsb_i2c_write_bytes(&client, command,
291	gsb->data, info->access_length);
292	}
293	break;
294
295	default:
296	pr_info("protocol(0x%02x) is not supported.\n", accessor_type);
297	ret = AE_BAD_PARAMETER;
298	goto err;
299	}
300
301	gsb->status = status;
302
303	err:
304	ACPI_FREE(ares);
305	return ret;
306	}
307
308
309	int acpi_i2c_install_space_handler(struct i2c_adapter *adapter)
310	{
311	acpi_handle handle = ACPI_HANDLE(adapter->dev.parent);
312	struct acpi_i2c_handler_data *data;
313	acpi_status status;
314
315	if (!handle)
316	return -ENODEV;
317
318	data = kzalloc(sizeof(struct acpi_i2c_handler_data),
319	GFP_KERNEL);
320	if (!data)
321	return -ENOMEM;
322
323	data->adapter = adapter;
324	status = acpi_bus_attach_private_data(handle, (void *)data);
325	if (ACPI_FAILURE(status)) {
326	kfree(data);
327	return -ENOMEM;
328	}
329
330	status = acpi_install_address_space_handler(handle,
331	ACPI_ADR_SPACE_GSBUS,
332	&acpi_i2c_space_handler,
333	NULL,
334	data);
335	if (ACPI_FAILURE(status)) {
336	dev_err(&adapter->dev, "Error installing i2c space handler\n");
337	acpi_bus_detach_private_data(handle);
338	kfree(data);
339	return -ENOMEM;
340	}
341
342	return 0;
343	}
344
345	void acpi_i2c_remove_space_handler(struct i2c_adapter *adapter)
346	{
347	acpi_handle handle = ACPI_HANDLE(adapter->dev.parent);
348	struct acpi_i2c_handler_data *data;
349	acpi_status status;
350
351	if (!handle)
352	return;
353
354	acpi_remove_address_space_handler(handle,
355	ACPI_ADR_SPACE_GSBUS,
356	&acpi_i2c_space_handler);
357
358	status = acpi_bus_get_private_data(handle, (void **)&data);
359	if (ACPI_SUCCESS(status))
360	kfree(data);
361
362	acpi_bus_detach_private_data(handle);
363	}
36604751	364	#endif