Re: [PATCH v3 07/18] Input: synaptics-rmi4 - add SMBus support

[Dmitry Torokhov <dmitry.torokhov@gmail.com>]

On Thu, Oct 13, 2016 at 05:51:01PM +0200, Benjamin Tissoires wrote:
> Code obtained from https://raw.githubusercontent.com/mightybigcar/synaptics-rmi4/jf/drivers/input/rmi4/rmi_smbus.c
> and updated to match upstream. And fixed to make it work.
> 
> Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
> Signed-off-by: Andrew Duggan <aduggan@synaptics.com>

Applied, thank you.

> 
> ---
> 
> changes in v3:
> - use of irq for Host Notify, not alert
> - forward the irq to rmi_core and let it handling it
> 
> no changes in v2
> 
> Changes in v1 of this series:
> - rely on PM functions for resume handling
> 
> Changes from the Host Notify series:
> new in v5
> 
> no changes in v6
> 
> changes in v7:
> - fixed typos as per Andrew's requests
> - changed module author from Allie to Andrew as per Andrew's request
> - add suspend/resume callbacks to match upstream rmi4 behavior
> 
> no changes in v8
> ---
>  drivers/input/rmi4/Kconfig     |  12 ++
>  drivers/input/rmi4/Makefile    |   1 +
>  drivers/input/rmi4/rmi_bus.h   |  12 ++
>  drivers/input/rmi4/rmi_smbus.c | 448 +++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 473 insertions(+)
>  create mode 100644 drivers/input/rmi4/rmi_smbus.c
> 
> diff --git a/drivers/input/rmi4/Kconfig b/drivers/input/rmi4/Kconfig
> index 4c8a558..8cbd362 100644
> --- a/drivers/input/rmi4/Kconfig
> +++ b/drivers/input/rmi4/Kconfig
> @@ -27,6 +27,18 @@ config RMI4_SPI
>  
>  	  If unsure, say N.
>  
> +config RMI4_SMB
> +	tristate "RMI4 SMB Support"
> +	depends on RMI4_CORE && I2C
> +	help
> +	  Say Y here if you want to support RMI4 devices connected to an SMB
> +	  bus.
> +
> +	  If unsure, say N.
> +
> +	  To compile this driver as a module, choose M here: the module will be
> +	  called rmi_smbus.
> +
>  config RMI4_2D_SENSOR
>  	bool
>  	depends on RMI4_CORE
> diff --git a/drivers/input/rmi4/Makefile b/drivers/input/rmi4/Makefile
> index 0bafc85..a6e2752 100644
> --- a/drivers/input/rmi4/Makefile
> +++ b/drivers/input/rmi4/Makefile
> @@ -12,3 +12,4 @@ rmi_core-$(CONFIG_RMI4_F54) += rmi_f54.o
>  # Transports
>  obj-$(CONFIG_RMI4_I2C) += rmi_i2c.o
>  obj-$(CONFIG_RMI4_SPI) += rmi_spi.o
> +obj-$(CONFIG_RMI4_SMB) += rmi_smbus.o
> diff --git a/drivers/input/rmi4/rmi_bus.h b/drivers/input/rmi4/rmi_bus.h
> index 8995798..b7625a9 100644
> --- a/drivers/input/rmi4/rmi_bus.h
> +++ b/drivers/input/rmi4/rmi_bus.h
> @@ -105,6 +105,18 @@ rmi_get_platform_data(struct rmi_device *d)
>  bool rmi_is_physical_device(struct device *dev);
>  
>  /**
> + * rmi_reset - reset a RMI4 device
> + * @d: Pointer to an RMI device
> + *
> + * Calls for a reset of each function implemented by a specific device.
> + * Returns 0 on success or a negative error code.
> + */
> +static inline int rmi_reset(struct rmi_device *d)
> +{
> +	return d->driver->reset_handler(d);
> +}
> +
> +/**
>   * rmi_read - read a single byte
>   * @d: Pointer to an RMI device
>   * @addr: The address to read from
> diff --git a/drivers/input/rmi4/rmi_smbus.c b/drivers/input/rmi4/rmi_smbus.c
> new file mode 100644
> index 0000000..96ad325
> --- /dev/null
> +++ b/drivers/input/rmi4/rmi_smbus.c
> @@ -0,0 +1,448 @@
> +/*
> + * 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 = {
> +		.owner	= THIS_MODULE,
> +		.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");
> -- 
> 2.7.4
> 

-- 
Dmitry