[thirdparty/kernel/stable.git] / drivers / input / rmi4 / rmi_smbus.c

/*
 * Copyright (c) 2015 - 2016 Red Hat, Inc
 * Copyright (c) 2011, 2012 Synaptics Incorporated
 * Copyright (c) 2011 Unixphere
 *
 * 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.
 */

#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/kconfig.h>
#include <linux/lockdep.h>
#include <linux/module.h>
#include <linux/pm.h>
#include <linux/rmi.h>
#include <linux/slab.h>
#include "rmi_driver.h"

#define SMB_PROTOCOL_VERSION_ADDRESS	0xfd
#define SMB_MAX_COUNT			32
#define RMI_SMB2_MAP_SIZE		8 /* 8 entry of 4 bytes each */
#define RMI_SMB2_MAP_FLAGS_WE		0x01

struct mapping_table_entry {
	__le16 rmiaddr;
	u8 readcount;
	u8 flags;
};

struct rmi_smb_xport {
	struct rmi_transport_dev xport;
	struct i2c_client *client;

	struct mutex page_mutex;
	int page;
	u8 table_index;
	struct mutex mappingtable_mutex;
	struct mapping_table_entry mapping_table[RMI_SMB2_MAP_SIZE];
};

static int rmi_smb_get_version(struct rmi_smb_xport *rmi_smb)
{
	struct i2c_client *client = rmi_smb->client;
	int retval;

	/* Check if for SMBus new version device by reading version byte. */
	retval = i2c_smbus_read_byte_data(client, SMB_PROTOCOL_VERSION_ADDRESS);
	if (retval < 0) {
		dev_err(&client->dev, "failed to get SMBus version number!\n");
		return retval;
	}
	return retval + 1;
}

/* SMB block write - wrapper over ic2_smb_write_block */
static int smb_block_write(struct rmi_transport_dev *xport,
			      u8 commandcode, const void *buf, size_t len)
{
	struct rmi_smb_xport *rmi_smb =
		container_of(xport, struct rmi_smb_xport, xport);
	struct i2c_client *client = rmi_smb->client;
	int retval;

	retval = i2c_smbus_write_block_data(client, commandcode, len, buf);

	rmi_dbg(RMI_DEBUG_XPORT, &client->dev,
		"wrote %zd bytes at %#04x: %d (%*ph)\n",
		len, commandcode, retval, (int)len, buf);

	return retval;
}

/*
 * The function to get command code for smbus operations and keeps
 * records to the driver mapping table
 */
static int rmi_smb_get_command_code(struct rmi_transport_dev *xport,
		u16 rmiaddr, int bytecount, bool isread, u8 *commandcode)
{
	struct rmi_smb_xport *rmi_smb =
		container_of(xport, struct rmi_smb_xport, xport);
	int i;
	int retval;
	struct mapping_table_entry mapping_data[1];

	mutex_lock(&rmi_smb->mappingtable_mutex);
	for (i = 0; i < RMI_SMB2_MAP_SIZE; i++) {
		if (rmi_smb->mapping_table[i].rmiaddr == rmiaddr) {
			if (isread) {
				if (rmi_smb->mapping_table[i].readcount
							== bytecount) {
					*commandcode = i;
					retval = 0;
					goto exit;
				}
			} else {
				if (rmi_smb->mapping_table[i].flags &
							RMI_SMB2_MAP_FLAGS_WE) {
					*commandcode = i;
					retval = 0;
					goto exit;
				}
			}
		}
	}
	i = rmi_smb->table_index;
	rmi_smb->table_index = (i + 1) % RMI_SMB2_MAP_SIZE;

	/* constructs mapping table data entry. 4 bytes each entry */
	memset(mapping_data, 0, sizeof(mapping_data));

	mapping_data[0].rmiaddr = cpu_to_le16(rmiaddr);
	mapping_data[0].readcount = bytecount;
	mapping_data[0].flags = !isread ? RMI_SMB2_MAP_FLAGS_WE : 0;

	retval = smb_block_write(xport, i + 0x80, mapping_data,
				 sizeof(mapping_data));

	if (retval < 0) {
		/*
		 * if not written to device mapping table
		 * clear the driver mapping table records
		 */
		rmi_smb->mapping_table[i].rmiaddr = 0x0000;
		rmi_smb->mapping_table[i].readcount = 0;
		rmi_smb->mapping_table[i].flags = 0;
		goto exit;
	}
	/* save to the driver level mapping table */
	rmi_smb->mapping_table[i].rmiaddr = rmiaddr;
	rmi_smb->mapping_table[i].readcount = bytecount;
	rmi_smb->mapping_table[i].flags = !isread ? RMI_SMB2_MAP_FLAGS_WE : 0;
	*commandcode = i;

exit:
	mutex_unlock(&rmi_smb->mappingtable_mutex);

	return retval;
}

static int rmi_smb_write_block(struct rmi_transport_dev *xport, u16 rmiaddr,
				const void *databuff, size_t len)
{
	int retval = 0;
	u8 commandcode;
	struct rmi_smb_xport *rmi_smb =
		container_of(xport, struct rmi_smb_xport, xport);
	int cur_len = (int)len;

	mutex_lock(&rmi_smb->page_mutex);

	while (cur_len > 0) {
		/*
		 * break into 32 bytes chunks to write get command code
		 */
		int block_len = min_t(int, len, SMB_MAX_COUNT);

		retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
						  false, &commandcode);
		if (retval < 0)
			goto exit;

		retval = smb_block_write(xport, commandcode,
					 databuff, block_len);
		if (retval < 0)
			goto exit;

		/* prepare to write next block of bytes */
		cur_len -= SMB_MAX_COUNT;
		databuff += SMB_MAX_COUNT;
		rmiaddr += SMB_MAX_COUNT;
	}
exit:
	mutex_unlock(&rmi_smb->page_mutex);
	return retval;
}

/* SMB block read - wrapper over ic2_smb_read_block */
static int smb_block_read(struct rmi_transport_dev *xport,
			     u8 commandcode, void *buf, size_t len)
{
	struct rmi_smb_xport *rmi_smb =
		container_of(xport, struct rmi_smb_xport, xport);
	struct i2c_client *client = rmi_smb->client;
	int retval;

	retval = i2c_smbus_read_block_data(client, commandcode, buf);
	if (retval < 0)
		return retval;

	return retval;
}

static int rmi_smb_read_block(struct rmi_transport_dev *xport, u16 rmiaddr,
			      void *databuff, size_t len)
{
	struct rmi_smb_xport *rmi_smb =
		container_of(xport, struct rmi_smb_xport, xport);
	int retval;
	u8 commandcode;
	int cur_len = (int)len;

	mutex_lock(&rmi_smb->page_mutex);
	memset(databuff, 0, len);

	while (cur_len > 0) {
		/* break into 32 bytes chunks to write get command code */
		int block_len =  min_t(int, cur_len, SMB_MAX_COUNT);

		retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
						  true, &commandcode);
		if (retval < 0)
			goto exit;

		retval = smb_block_read(xport, commandcode,
					databuff, block_len);
		if (retval < 0)
			goto exit;

		/* prepare to read next block of bytes */
		cur_len -= SMB_MAX_COUNT;
		databuff += SMB_MAX_COUNT;
		rmiaddr += SMB_MAX_COUNT;
	}

	retval = 0;

exit:
	mutex_unlock(&rmi_smb->page_mutex);
	return retval;
}

static void rmi_smb_clear_state(struct rmi_smb_xport *rmi_smb)
{
	/* the mapping table has been flushed, discard the current one */
	mutex_lock(&rmi_smb->mappingtable_mutex);
	memset(rmi_smb->mapping_table, 0, sizeof(rmi_smb->mapping_table));
	mutex_unlock(&rmi_smb->mappingtable_mutex);
}

static int rmi_smb_enable_smbus_mode(struct rmi_smb_xport *rmi_smb)
{
	int retval;

	/* we need to get the smbus version to activate the touchpad */
	retval = rmi_smb_get_version(rmi_smb);
	if (retval < 0)
		return retval;

	return 0;
}

static int rmi_smb_reset(struct rmi_transport_dev *xport, u16 reset_addr)
{
	struct rmi_smb_xport *rmi_smb =
		container_of(xport, struct rmi_smb_xport, xport);

	rmi_smb_clear_state(rmi_smb);

	/*
	 * we do not call the actual reset command, it has to be handled in
	 * PS/2 or there will be races between PS/2 and SMBus.
	 * PS/2 should ensure that a psmouse_reset is called before
	 * intializing the device and after it has been removed to be in a known
	 * state.
	 */
	return rmi_smb_enable_smbus_mode(rmi_smb);
}

static const struct rmi_transport_ops rmi_smb_ops = {
	.write_block	= rmi_smb_write_block,
	.read_block	= rmi_smb_read_block,
	.reset		= rmi_smb_reset,
};

static int rmi_smb_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
	struct rmi_smb_xport *rmi_smb;
	int retval;
	int smbus_version;

	if (!i2c_check_functionality(client->adapter,
				     I2C_FUNC_SMBUS_READ_BLOCK_DATA |
				     I2C_FUNC_SMBUS_HOST_NOTIFY)) {
		dev_err(&client->dev,
			"adapter does not support required functionality.\n");
		return -ENODEV;
	}

	if (client->irq <= 0) {
		dev_err(&client->dev, "no IRQ provided, giving up.\n");
		return client->irq ? client->irq : -ENODEV;
	}

	rmi_smb = devm_kzalloc(&client->dev, sizeof(struct rmi_smb_xport),
				GFP_KERNEL);
	if (!rmi_smb)
		return -ENOMEM;

	if (!pdata) {
		dev_err(&client->dev, "no platform data, aborting\n");
		return -ENOMEM;
	}

	rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s.\n",
		dev_name(&client->dev));

	rmi_smb->client = client;
	mutex_init(&rmi_smb->page_mutex);
	mutex_init(&rmi_smb->mappingtable_mutex);

	rmi_smb->xport.dev = &client->dev;
	rmi_smb->xport.pdata = *pdata;
	rmi_smb->xport.pdata.irq = client->irq;
	rmi_smb->xport.proto_name = "smb2";
	rmi_smb->xport.ops = &rmi_smb_ops;

	retval = rmi_smb_get_version(rmi_smb);
	if (retval < 0)
		return retval;

	smbus_version = retval;
	rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
		smbus_version);

	if (smbus_version != 2) {
		dev_err(&client->dev, "Unrecognized SMB version %d.\n",
				smbus_version);
		return -ENODEV;
	}

	i2c_set_clientdata(client, rmi_smb);

	retval = rmi_register_transport_device(&rmi_smb->xport);
	if (retval) {
		dev_err(&client->dev, "Failed to register transport driver at 0x%.2X.\n",
			client->addr);
		i2c_set_clientdata(client, NULL);
		return retval;
	}

	dev_info(&client->dev, "registered rmi smb driver at %#04x.\n",
			client->addr);
	return 0;

}

static int rmi_smb_remove(struct i2c_client *client)
{
	struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);

	rmi_unregister_transport_device(&rmi_smb->xport);

	return 0;
}

static int __maybe_unused rmi_smb_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
	int ret;

	ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, true);
	if (ret)
		dev_warn(dev, "Failed to suspend device: %d\n", ret);

	return ret;
}

static int __maybe_unused rmi_smb_runtime_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
	int ret;

	ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, false);
	if (ret)
		dev_warn(dev, "Failed to suspend device: %d\n", ret);

	return ret;
}

static int __maybe_unused rmi_smb_resume(struct device *dev)
{
	struct i2c_client *client = container_of(dev, struct i2c_client, dev);
	struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
	struct rmi_device *rmi_dev = rmi_smb->xport.rmi_dev;
	int ret;

	rmi_smb_reset(&rmi_smb->xport, 0);

	rmi_reset(rmi_dev);

	ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, true);
	if (ret)
		dev_warn(dev, "Failed to resume device: %d\n", ret);

	return 0;
}

static int __maybe_unused rmi_smb_runtime_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
	int ret;

	ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, false);
	if (ret)
		dev_warn(dev, "Failed to resume device: %d\n", ret);

	return 0;
}

static const struct dev_pm_ops rmi_smb_pm = {
	SET_SYSTEM_SLEEP_PM_OPS(rmi_smb_suspend, rmi_smb_resume)
	SET_RUNTIME_PM_OPS(rmi_smb_runtime_suspend, rmi_smb_runtime_resume,
			   NULL)
};

static const struct i2c_device_id rmi_id[] = {
	{ "rmi4_smbus", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, rmi_id);

static struct i2c_driver rmi_smb_driver = {
	.driver = {
		.name	= "rmi4_smbus",
		.pm	= &rmi_smb_pm,
	},
	.id_table	= rmi_id,
	.probe		= rmi_smb_probe,
	.remove		= rmi_smb_remove,
};

module_i2c_driver(rmi_smb_driver);

MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
MODULE_DESCRIPTION("RMI4 SMBus driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
82264d0c BT	1	/*
	2	* Copyright (c) 2015 - 2016 Red Hat, Inc
	3	* Copyright (c) 2011, 2012 Synaptics Incorporated
	4	* Copyright (c) 2011 Unixphere
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License version 2 as published by
	8	* the Free Software Foundation.
	9	*/
	10
	11	#include <linux/kernel.h>
	12	#include <linux/delay.h>
	13	#include <linux/i2c.h>
	14	#include <linux/interrupt.h>
	15	#include <linux/kconfig.h>
	16	#include <linux/lockdep.h>
	17	#include <linux/module.h>
	18	#include <linux/pm.h>
	19	#include <linux/rmi.h>
	20	#include <linux/slab.h>
	21	#include "rmi_driver.h"
	22
	23	#define SMB_PROTOCOL_VERSION_ADDRESS 0xfd
	24	#define SMB_MAX_COUNT 32
	25	#define RMI_SMB2_MAP_SIZE 8 /* 8 entry of 4 bytes each */
	26	#define RMI_SMB2_MAP_FLAGS_WE 0x01
	27
	28	struct mapping_table_entry {
	29	__le16 rmiaddr;
	30	u8 readcount;
	31	u8 flags;
	32	};
	33
	34	struct rmi_smb_xport {
	35	struct rmi_transport_dev xport;
	36	struct i2c_client *client;
	37
	38	struct mutex page_mutex;
	39	int page;
	40	u8 table_index;
	41	struct mutex mappingtable_mutex;
	42	struct mapping_table_entry mapping_table[RMI_SMB2_MAP_SIZE];
	43	};
	44
	45	static int rmi_smb_get_version(struct rmi_smb_xport *rmi_smb)
	46	{
	47	struct i2c_client *client = rmi_smb->client;
	48	int retval;
	49
	50	/* Check if for SMBus new version device by reading version byte. */
	51	retval = i2c_smbus_read_byte_data(client, SMB_PROTOCOL_VERSION_ADDRESS);
	52	if (retval < 0) {
	53	dev_err(&client->dev, "failed to get SMBus version number!\n");
	54	return retval;
	55	}
	56	return retval + 1;
	57	}
	58
	59	/* SMB block write - wrapper over ic2_smb_write_block */
	60	static int smb_block_write(struct rmi_transport_dev *xport,
	61	u8 commandcode, const void *buf, size_t len)
	62	{
	63	struct rmi_smb_xport *rmi_smb =
	64	container_of(xport, struct rmi_smb_xport, xport);
65	struct i2c_client *client = rmi_smb->client;
66	int retval;
67
68	retval = i2c_smbus_write_block_data(client, commandcode, len, buf);
69
70	rmi_dbg(RMI_DEBUG_XPORT, &client->dev,
71	"wrote %zd bytes at %#04x: %d (%*ph)\n",
72	len, commandcode, retval, (int)len, buf);
73
74	return retval;
75	}
76
77	/*
78	* The function to get command code for smbus operations and keeps
79	* records to the driver mapping table
80	*/
81	static int rmi_smb_get_command_code(struct rmi_transport_dev *xport,
82	u16 rmiaddr, int bytecount, bool isread, u8 *commandcode)
83	{
84	struct rmi_smb_xport *rmi_smb =
85	container_of(xport, struct rmi_smb_xport, xport);
86	int i;
87	int retval;
88	struct mapping_table_entry mapping_data[1];
89
90	mutex_lock(&rmi_smb->mappingtable_mutex);
91	for (i = 0; i < RMI_SMB2_MAP_SIZE; i++) {
92	if (rmi_smb->mapping_table[i].rmiaddr == rmiaddr) {
93	if (isread) {
94	if (rmi_smb->mapping_table[i].readcount
95	== bytecount) {
96	*commandcode = i;
97	retval = 0;
98	goto exit;
99	}
100	} else {
101	if (rmi_smb->mapping_table[i].flags &
102	RMI_SMB2_MAP_FLAGS_WE) {
103	*commandcode = i;
104	retval = 0;
105	goto exit;
106	}
107	}
108	}
109	}
110	i = rmi_smb->table_index;
111	rmi_smb->table_index = (i + 1) % RMI_SMB2_MAP_SIZE;
112
113	/* constructs mapping table data entry. 4 bytes each entry */
114	memset(mapping_data, 0, sizeof(mapping_data));
115
116	mapping_data[0].rmiaddr = cpu_to_le16(rmiaddr);
117	mapping_data[0].readcount = bytecount;
118	mapping_data[0].flags = !isread ? RMI_SMB2_MAP_FLAGS_WE : 0;
119
120	retval = smb_block_write(xport, i + 0x80, mapping_data,
121	sizeof(mapping_data));
122
123	if (retval < 0) {
124	/*
125	* if not written to device mapping table
126	* clear the driver mapping table records
127	*/
128	rmi_smb->mapping_table[i].rmiaddr = 0x0000;
129	rmi_smb->mapping_table[i].readcount = 0;
130	rmi_smb->mapping_table[i].flags = 0;
131	goto exit;
132	}
133	/* save to the driver level mapping table */
134	rmi_smb->mapping_table[i].rmiaddr = rmiaddr;
135	rmi_smb->mapping_table[i].readcount = bytecount;
136	rmi_smb->mapping_table[i].flags = !isread ? RMI_SMB2_MAP_FLAGS_WE : 0;
137	*commandcode = i;
138
139	exit:
140	mutex_unlock(&rmi_smb->mappingtable_mutex);
141
142	return retval;
143	}
144
145	static int rmi_smb_write_block(struct rmi_transport_dev *xport, u16 rmiaddr,
146	const void *databuff, size_t len)
147	{
148	int retval = 0;
149	u8 commandcode;
150	struct rmi_smb_xport *rmi_smb =
151	container_of(xport, struct rmi_smb_xport, xport);
152	int cur_len = (int)len;
153
154	mutex_lock(&rmi_smb->page_mutex);
155
156	while (cur_len > 0) {
157	/*
158	* break into 32 bytes chunks to write get command code
159	*/
160	int block_len = min_t(int, len, SMB_MAX_COUNT);
161
162	retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
163	false, &commandcode);
164	if (retval < 0)
165	goto exit;
166
167	retval = smb_block_write(xport, commandcode,
168	databuff, block_len);
169	if (retval < 0)
170	goto exit;
171
172	/* prepare to write next block of bytes */
173	cur_len -= SMB_MAX_COUNT;
174	databuff += SMB_MAX_COUNT;
175	rmiaddr += SMB_MAX_COUNT;
176	}
177	exit:
178	mutex_unlock(&rmi_smb->page_mutex);
179	return retval;
180	}
181
182	/* SMB block read - wrapper over ic2_smb_read_block */
183	static int smb_block_read(struct rmi_transport_dev *xport,
184	u8 commandcode, void *buf, size_t len)
185	{
186	struct rmi_smb_xport *rmi_smb =
187	container_of(xport, struct rmi_smb_xport, xport);
188	struct i2c_client *client = rmi_smb->client;
189	int retval;
190
191	retval = i2c_smbus_read_block_data(client, commandcode, buf);
192	if (retval < 0)
193	return retval;
194
195	return retval;
196	}
197
198	static int rmi_smb_read_block(struct rmi_transport_dev *xport, u16 rmiaddr,
199	void *databuff, size_t len)
200	{
201	struct rmi_smb_xport *rmi_smb =
202	container_of(xport, struct rmi_smb_xport, xport);
203	int retval;
204	u8 commandcode;
205	int cur_len = (int)len;
206
207	mutex_lock(&rmi_smb->page_mutex);
208	memset(databuff, 0, len);
209
210	while (cur_len > 0) {
211	/* break into 32 bytes chunks to write get command code */
212	int block_len = min_t(int, cur_len, SMB_MAX_COUNT);
213
214	retval = rmi_smb_get_command_code(xport, rmiaddr, block_len,
215	true, &commandcode);
216	if (retval < 0)
217	goto exit;
218
219	retval = smb_block_read(xport, commandcode,
220	databuff, block_len);
221	if (retval < 0)
222	goto exit;
223
224	/* prepare to read next block of bytes */
225	cur_len -= SMB_MAX_COUNT;
226	databuff += SMB_MAX_COUNT;
227	rmiaddr += SMB_MAX_COUNT;
228	}
229
230	retval = 0;
231
232	exit:
233	mutex_unlock(&rmi_smb->page_mutex);
234	return retval;
235	}
236
237	static void rmi_smb_clear_state(struct rmi_smb_xport *rmi_smb)
238	{
239	/* the mapping table has been flushed, discard the current one */
240	mutex_lock(&rmi_smb->mappingtable_mutex);
241	memset(rmi_smb->mapping_table, 0, sizeof(rmi_smb->mapping_table));
242	mutex_unlock(&rmi_smb->mappingtable_mutex);
243	}
244
245	static int rmi_smb_enable_smbus_mode(struct rmi_smb_xport *rmi_smb)
246	{
247	int retval;
248
249	/* we need to get the smbus version to activate the touchpad */
250	retval = rmi_smb_get_version(rmi_smb);
251	if (retval < 0)
252	return retval;
253
254	return 0;
255	}
256
257	static int rmi_smb_reset(struct rmi_transport_dev *xport, u16 reset_addr)
258	{
259	struct rmi_smb_xport *rmi_smb =
260	container_of(xport, struct rmi_smb_xport, xport);
261
262	rmi_smb_clear_state(rmi_smb);
263
264	/*
265	* we do not call the actual reset command, it has to be handled in
266	* PS/2 or there will be races between PS/2 and SMBus.
267	* PS/2 should ensure that a psmouse_reset is called before
268	* intializing the device and after it has been removed to be in a known
269	* state.
270	*/
271	return rmi_smb_enable_smbus_mode(rmi_smb);
272	}
273
274	static const struct rmi_transport_ops rmi_smb_ops = {
275	.write_block = rmi_smb_write_block,
276	.read_block = rmi_smb_read_block,
277	.reset = rmi_smb_reset,
278	};
279
280	static int rmi_smb_probe(struct i2c_client *client,
281	const struct i2c_device_id *id)
282	{
283	struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
284	struct rmi_smb_xport *rmi_smb;
285	int retval;
286	int smbus_version;
287
288	if (!i2c_check_functionality(client->adapter,
289	I2C_FUNC_SMBUS_READ_BLOCK_DATA \|
290	I2C_FUNC_SMBUS_HOST_NOTIFY)) {
291	dev_err(&client->dev,
292	"adapter does not support required functionality.\n");
293	return -ENODEV;
294	}
295
296	if (client->irq <= 0) {
297	dev_err(&client->dev, "no IRQ provided, giving up.\n");
298	return client->irq ? client->irq : -ENODEV;
299	}
300
301	rmi_smb = devm_kzalloc(&client->dev, sizeof(struct rmi_smb_xport),
302	GFP_KERNEL);
303	if (!rmi_smb)
304	return -ENOMEM;
305
306	if (!pdata) {
307	dev_err(&client->dev, "no platform data, aborting\n");
308	return -ENOMEM;
309	}
310
311	rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s.\n",
312	dev_name(&client->dev));
313
314	rmi_smb->client = client;
315	mutex_init(&rmi_smb->page_mutex);
316	mutex_init(&rmi_smb->mappingtable_mutex);
317
318	rmi_smb->xport.dev = &client->dev;
319	rmi_smb->xport.pdata = *pdata;
320	rmi_smb->xport.pdata.irq = client->irq;
321	rmi_smb->xport.proto_name = "smb2";
322	rmi_smb->xport.ops = &rmi_smb_ops;
323
324	retval = rmi_smb_get_version(rmi_smb);
325	if (retval < 0)
326	return retval;
327
328	smbus_version = retval;
329	rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
330	smbus_version);
331
332	if (smbus_version != 2) {
333	dev_err(&client->dev, "Unrecognized SMB version %d.\n",
334	smbus_version);
335	return -ENODEV;
336	}
337
338	i2c_set_clientdata(client, rmi_smb);
339
340	retval = rmi_register_transport_device(&rmi_smb->xport);
341	if (retval) {
342	dev_err(&client->dev, "Failed to register transport driver at 0x%.2X.\n",
343	client->addr);
344	i2c_set_clientdata(client, NULL);
345	return retval;
346	}
347
348	dev_info(&client->dev, "registered rmi smb driver at %#04x.\n",
349	client->addr);
350	return 0;
351
352	}
353
354	static int rmi_smb_remove(struct i2c_client *client)
355	{
356	struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
357
358	rmi_unregister_transport_device(&rmi_smb->xport);
359
360	return 0;
361	}
362
363	static int __maybe_unused rmi_smb_suspend(struct device *dev)
364	{
365	struct i2c_client *client = to_i2c_client(dev);
366	struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
367	int ret;
368
369	ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, true);
370	if (ret)
371	dev_warn(dev, "Failed to suspend device: %d\n", ret);
372
373	return ret;
374	}
375
376	static int __maybe_unused rmi_smb_runtime_suspend(struct device *dev)
377	{
378	struct i2c_client *client = to_i2c_client(dev);
379	struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
380	int ret;
381
382	ret = rmi_driver_suspend(rmi_smb->xport.rmi_dev, false);
383	if (ret)
384	dev_warn(dev, "Failed to suspend device: %d\n", ret);
385
386	return ret;
387	}
388
389	static int __maybe_unused rmi_smb_resume(struct device *dev)
390	{
391	struct i2c_client *client = container_of(dev, struct i2c_client, dev);
392	struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
393	struct rmi_device *rmi_dev = rmi_smb->xport.rmi_dev;
394	int ret;
395
396	rmi_smb_reset(&rmi_smb->xport, 0);
397
398	rmi_reset(rmi_dev);
399
400	ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, true);
401	if (ret)
402	dev_warn(dev, "Failed to resume device: %d\n", ret);
403
404	return 0;
405	}
406
407	static int __maybe_unused rmi_smb_runtime_resume(struct device *dev)
408	{
409	struct i2c_client *client = to_i2c_client(dev);
410	struct rmi_smb_xport *rmi_smb = i2c_get_clientdata(client);
411	int ret;
412
413	ret = rmi_driver_resume(rmi_smb->xport.rmi_dev, false);
414	if (ret)
415	dev_warn(dev, "Failed to resume device: %d\n", ret);
416
417	return 0;
418	}
419
420	static const struct dev_pm_ops rmi_smb_pm = {
421	SET_SYSTEM_SLEEP_PM_OPS(rmi_smb_suspend, rmi_smb_resume)
422	SET_RUNTIME_PM_OPS(rmi_smb_runtime_suspend, rmi_smb_runtime_resume,
423	NULL)
424	};
425
426	static const struct i2c_device_id rmi_id[] = {
427	{ "rmi4_smbus", 0 },
428	{ }
429	};
430	MODULE_DEVICE_TABLE(i2c, rmi_id);
431
432	static struct i2c_driver rmi_smb_driver = {
433	.driver = {
434	.name = "rmi4_smbus",
435	.pm = &rmi_smb_pm,
436	},
437	.id_table = rmi_id,
438	.probe = rmi_smb_probe,
439	.remove = rmi_smb_remove,
440	};
441
442	module_i2c_driver(rmi_smb_driver);
443
444	MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
445	MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@redhat.com>");
446	MODULE_DESCRIPTION("RMI4 SMBus driver");
447	MODULE_LICENSE("GPL");