[mirror_ubuntu-hirsute-kernel.git] / drivers / input / rmi4 / rmi_spi.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2011-2016 Synaptics Incorporated
 * Copyright (c) 2011 Unixphere
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/rmi.h>
#include <linux/slab.h>
#include <linux/spi/spi.h>
#include <linux/of.h>
#include "rmi_driver.h"

#define RMI_SPI_DEFAULT_XFER_BUF_SIZE	64

#define RMI_PAGE_SELECT_REGISTER	0x00FF
#define RMI_SPI_PAGE(addr)		(((addr) >> 8) & 0x80)
#define RMI_SPI_XFER_SIZE_LIMIT		255

#define BUFFER_SIZE_INCREMENT 32

enum rmi_spi_op {
	RMI_SPI_WRITE = 0,
	RMI_SPI_READ,
	RMI_SPI_V2_READ_UNIFIED,
	RMI_SPI_V2_READ_SPLIT,
	RMI_SPI_V2_WRITE,
};

struct rmi_spi_cmd {
	enum rmi_spi_op op;
	u16 addr;
};

struct rmi_spi_xport {
	struct rmi_transport_dev xport;
	struct spi_device *spi;

	struct mutex page_mutex;
	int page;

	u8 *rx_buf;
	u8 *tx_buf;
	int xfer_buf_size;

	struct spi_transfer *rx_xfers;
	struct spi_transfer *tx_xfers;
	int rx_xfer_count;
	int tx_xfer_count;
};

static int rmi_spi_manage_pools(struct rmi_spi_xport *rmi_spi, int len)
{
	struct spi_device *spi = rmi_spi->spi;
	int buf_size = rmi_spi->xfer_buf_size
		? rmi_spi->xfer_buf_size : RMI_SPI_DEFAULT_XFER_BUF_SIZE;
	struct spi_transfer *xfer_buf;
	void *buf;
	void *tmp;

	while (buf_size < len)
		buf_size *= 2;

	if (buf_size > RMI_SPI_XFER_SIZE_LIMIT)
		buf_size = RMI_SPI_XFER_SIZE_LIMIT;

	tmp = rmi_spi->rx_buf;
	buf = devm_kcalloc(&spi->dev, buf_size, 2,
				GFP_KERNEL | GFP_DMA);
	if (!buf)
		return -ENOMEM;

	rmi_spi->rx_buf = buf;
	rmi_spi->tx_buf = &rmi_spi->rx_buf[buf_size];
	rmi_spi->xfer_buf_size = buf_size;

	if (tmp)
		devm_kfree(&spi->dev, tmp);

	if (rmi_spi->xport.pdata.spi_data.read_delay_us)
		rmi_spi->rx_xfer_count = buf_size;
	else
		rmi_spi->rx_xfer_count = 1;

	if (rmi_spi->xport.pdata.spi_data.write_delay_us)
		rmi_spi->tx_xfer_count = buf_size;
	else
		rmi_spi->tx_xfer_count = 1;

	/*
	 * Allocate a pool of spi_transfer buffers for devices which need
	 * per byte delays.
	 */
	tmp = rmi_spi->rx_xfers;
	xfer_buf = devm_kcalloc(&spi->dev,
		rmi_spi->rx_xfer_count + rmi_spi->tx_xfer_count,
		sizeof(struct spi_transfer),
		GFP_KERNEL);
	if (!xfer_buf)
		return -ENOMEM;

	rmi_spi->rx_xfers = xfer_buf;
	rmi_spi->tx_xfers = &xfer_buf[rmi_spi->rx_xfer_count];

	if (tmp)
		devm_kfree(&spi->dev, tmp);

	return 0;
}

static int rmi_spi_xfer(struct rmi_spi_xport *rmi_spi,
			const struct rmi_spi_cmd *cmd, const u8 *tx_buf,
			int tx_len, u8 *rx_buf, int rx_len)
{
	struct spi_device *spi = rmi_spi->spi;
	struct rmi_device_platform_data_spi *spi_data =
					&rmi_spi->xport.pdata.spi_data;
	struct spi_message msg;
	struct spi_transfer *xfer;
	int ret = 0;
	int len;
	int cmd_len = 0;
	int total_tx_len;
	int i;
	u16 addr = cmd->addr;

	spi_message_init(&msg);

	switch (cmd->op) {
	case RMI_SPI_WRITE:
	case RMI_SPI_READ:
		cmd_len += 2;
		break;
	case RMI_SPI_V2_READ_UNIFIED:
	case RMI_SPI_V2_READ_SPLIT:
	case RMI_SPI_V2_WRITE:
		cmd_len += 4;
		break;
	}

	total_tx_len = cmd_len + tx_len;
	len = max(total_tx_len, rx_len);

	if (len > RMI_SPI_XFER_SIZE_LIMIT)
		return -EINVAL;

	if (rmi_spi->xfer_buf_size < len) {
		ret = rmi_spi_manage_pools(rmi_spi, len);
		if (ret < 0)
			return ret;
	}

	if (addr == 0)
		/*
		 * SPI needs an address. Use 0x7FF if we want to keep
		 * reading from the last position of the register pointer.
		 */
		addr = 0x7FF;

	switch (cmd->op) {
	case RMI_SPI_WRITE:
		rmi_spi->tx_buf[0] = (addr >> 8);
		rmi_spi->tx_buf[1] = addr & 0xFF;
		break;
	case RMI_SPI_READ:
		rmi_spi->tx_buf[0] = (addr >> 8) | 0x80;
		rmi_spi->tx_buf[1] = addr & 0xFF;
		break;
	case RMI_SPI_V2_READ_UNIFIED:
		break;
	case RMI_SPI_V2_READ_SPLIT:
		break;
	case RMI_SPI_V2_WRITE:
		rmi_spi->tx_buf[0] = 0x40;
		rmi_spi->tx_buf[1] = (addr >> 8) & 0xFF;
		rmi_spi->tx_buf[2] = addr & 0xFF;
		rmi_spi->tx_buf[3] = tx_len;
		break;
	}

	if (tx_buf)
		memcpy(&rmi_spi->tx_buf[cmd_len], tx_buf, tx_len);

	if (rmi_spi->tx_xfer_count > 1) {
		for (i = 0; i < total_tx_len; i++) {
			xfer = &rmi_spi->tx_xfers[i];
			memset(xfer, 0,	sizeof(struct spi_transfer));
			xfer->tx_buf = &rmi_spi->tx_buf[i];
			xfer->len = 1;
			xfer->delay_usecs = spi_data->write_delay_us;
			spi_message_add_tail(xfer, &msg);
		}
	} else {
		xfer = rmi_spi->tx_xfers;
		memset(xfer, 0, sizeof(struct spi_transfer));
		xfer->tx_buf = rmi_spi->tx_buf;
		xfer->len = total_tx_len;
		spi_message_add_tail(xfer, &msg);
	}

	rmi_dbg(RMI_DEBUG_XPORT, &spi->dev, "%s: cmd: %s tx_buf len: %d tx_buf: %*ph\n",
		__func__, cmd->op == RMI_SPI_WRITE ? "WRITE" : "READ",
		total_tx_len, total_tx_len, rmi_spi->tx_buf);

	if (rx_buf) {
		if (rmi_spi->rx_xfer_count > 1) {
			for (i = 0; i < rx_len; i++) {
				xfer = &rmi_spi->rx_xfers[i];
				memset(xfer, 0, sizeof(struct spi_transfer));
				xfer->rx_buf = &rmi_spi->rx_buf[i];
				xfer->len = 1;
				xfer->delay_usecs = spi_data->read_delay_us;
				spi_message_add_tail(xfer, &msg);
			}
		} else {
			xfer = rmi_spi->rx_xfers;
			memset(xfer, 0, sizeof(struct spi_transfer));
			xfer->rx_buf = rmi_spi->rx_buf;
			xfer->len = rx_len;
			spi_message_add_tail(xfer, &msg);
		}
	}

	ret = spi_sync(spi, &msg);
	if (ret < 0) {
		dev_err(&spi->dev, "spi xfer failed: %d\n", ret);
		return ret;
	}

	if (rx_buf) {
		memcpy(rx_buf, rmi_spi->rx_buf, rx_len);
		rmi_dbg(RMI_DEBUG_XPORT, &spi->dev, "%s: (%d) %*ph\n",
			__func__, rx_len, rx_len, rx_buf);
	}

	return 0;
}

/*
 * rmi_set_page - Set RMI page
 * @xport: The pointer to the rmi_transport_dev struct
 * @page: The new page address.
 *
 * RMI devices have 16-bit addressing, but some of the transport
 * implementations (like SMBus) only have 8-bit addressing. So RMI implements
 * a page address at 0xff of every page so we can reliable page addresses
 * every 256 registers.
 *
 * The page_mutex lock must be held when this function is entered.
 *
 * Returns zero on success, non-zero on failure.
 */
static int rmi_set_page(struct rmi_spi_xport *rmi_spi, u8 page)
{
	struct rmi_spi_cmd cmd;
	int ret;

	cmd.op = RMI_SPI_WRITE;
	cmd.addr = RMI_PAGE_SELECT_REGISTER;

	ret = rmi_spi_xfer(rmi_spi, &cmd, &page, 1, NULL, 0);

	if (ret)
		rmi_spi->page = page;

	return ret;
}

static int rmi_spi_write_block(struct rmi_transport_dev *xport, u16 addr,
			       const void *buf, size_t len)
{
	struct rmi_spi_xport *rmi_spi =
		container_of(xport, struct rmi_spi_xport, xport);
	struct rmi_spi_cmd cmd;
	int ret;

	mutex_lock(&rmi_spi->page_mutex);

	if (RMI_SPI_PAGE(addr) != rmi_spi->page) {
		ret = rmi_set_page(rmi_spi, RMI_SPI_PAGE(addr));
		if (ret)
			goto exit;
	}

	cmd.op = RMI_SPI_WRITE;
	cmd.addr = addr;

	ret = rmi_spi_xfer(rmi_spi, &cmd, buf, len, NULL, 0);

exit:
	mutex_unlock(&rmi_spi->page_mutex);
	return ret;
}

static int rmi_spi_read_block(struct rmi_transport_dev *xport, u16 addr,
			      void *buf, size_t len)
{
	struct rmi_spi_xport *rmi_spi =
		container_of(xport, struct rmi_spi_xport, xport);
	struct rmi_spi_cmd cmd;
	int ret;

	mutex_lock(&rmi_spi->page_mutex);

	if (RMI_SPI_PAGE(addr) != rmi_spi->page) {
		ret = rmi_set_page(rmi_spi, RMI_SPI_PAGE(addr));
		if (ret)
			goto exit;
	}

	cmd.op = RMI_SPI_READ;
	cmd.addr = addr;

	ret = rmi_spi_xfer(rmi_spi, &cmd, NULL, 0, buf, len);

exit:
	mutex_unlock(&rmi_spi->page_mutex);
	return ret;
}

static const struct rmi_transport_ops rmi_spi_ops = {
	.write_block	= rmi_spi_write_block,
	.read_block	= rmi_spi_read_block,
};

#ifdef CONFIG_OF
static int rmi_spi_of_probe(struct spi_device *spi,
			struct rmi_device_platform_data *pdata)
{
	struct device *dev = &spi->dev;
	int retval;

	retval = rmi_of_property_read_u32(dev,
			&pdata->spi_data.read_delay_us,
			"spi-rx-delay-us", 1);
	if (retval)
		return retval;

	retval = rmi_of_property_read_u32(dev,
			&pdata->spi_data.write_delay_us,
			"spi-tx-delay-us", 1);
	if (retval)
		return retval;

	return 0;
}

static const struct of_device_id rmi_spi_of_match[] = {
	{ .compatible = "syna,rmi4-spi" },
	{},
};
MODULE_DEVICE_TABLE(of, rmi_spi_of_match);
#else
static inline int rmi_spi_of_probe(struct spi_device *spi,
				struct rmi_device_platform_data *pdata)
{
	return -ENODEV;
}
#endif

static void rmi_spi_unregister_transport(void *data)
{
	struct rmi_spi_xport *rmi_spi = data;

	rmi_unregister_transport_device(&rmi_spi->xport);
}

static int rmi_spi_probe(struct spi_device *spi)
{
	struct rmi_spi_xport *rmi_spi;
	struct rmi_device_platform_data *pdata;
	struct rmi_device_platform_data *spi_pdata = spi->dev.platform_data;
	int error;

	if (spi->master->flags & SPI_MASTER_HALF_DUPLEX)
		return -EINVAL;

	rmi_spi = devm_kzalloc(&spi->dev, sizeof(struct rmi_spi_xport),
			GFP_KERNEL);
	if (!rmi_spi)
		return -ENOMEM;

	pdata = &rmi_spi->xport.pdata;

	if (spi->dev.of_node) {
		error = rmi_spi_of_probe(spi, pdata);
		if (error)
			return error;
	} else if (spi_pdata) {
		*pdata = *spi_pdata;
	}

	if (pdata->spi_data.bits_per_word)
		spi->bits_per_word = pdata->spi_data.bits_per_word;

	if (pdata->spi_data.mode)
		spi->mode = pdata->spi_data.mode;

	error = spi_setup(spi);
	if (error < 0) {
		dev_err(&spi->dev, "spi_setup failed!\n");
		return error;
	}

	pdata->irq = spi->irq;

	rmi_spi->spi = spi;
	mutex_init(&rmi_spi->page_mutex);

	rmi_spi->xport.dev = &spi->dev;
	rmi_spi->xport.proto_name = "spi";
	rmi_spi->xport.ops = &rmi_spi_ops;

	spi_set_drvdata(spi, rmi_spi);

	error = rmi_spi_manage_pools(rmi_spi, RMI_SPI_DEFAULT_XFER_BUF_SIZE);
	if (error)
		return error;

	/*
	 * Setting the page to zero will (a) make sure the PSR is in a
	 * known state, and (b) make sure we can talk to the device.
	 */
	error = rmi_set_page(rmi_spi, 0);
	if (error) {
		dev_err(&spi->dev, "Failed to set page select to 0.\n");
		return error;
	}

	dev_info(&spi->dev, "registering SPI-connected sensor\n");

	error = rmi_register_transport_device(&rmi_spi->xport);
	if (error) {
		dev_err(&spi->dev, "failed to register sensor: %d\n", error);
		return error;
	}

	error = devm_add_action_or_reset(&spi->dev,
					  rmi_spi_unregister_transport,
					  rmi_spi);
	if (error)
		return error;

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int rmi_spi_suspend(struct device *dev)
{
	struct spi_device *spi = to_spi_device(dev);
	struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
	int ret;

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

	return ret;
}

static int rmi_spi_resume(struct device *dev)
{
	struct spi_device *spi = to_spi_device(dev);
	struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
	int ret;

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

	return ret;
}
#endif

#ifdef CONFIG_PM
static int rmi_spi_runtime_suspend(struct device *dev)
{
	struct spi_device *spi = to_spi_device(dev);
	struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
	int ret;

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

	return 0;
}

static int rmi_spi_runtime_resume(struct device *dev)
{
	struct spi_device *spi = to_spi_device(dev);
	struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
	int ret;

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

	return 0;
}
#endif

static const struct dev_pm_ops rmi_spi_pm = {
	SET_SYSTEM_SLEEP_PM_OPS(rmi_spi_suspend, rmi_spi_resume)
	SET_RUNTIME_PM_OPS(rmi_spi_runtime_suspend, rmi_spi_runtime_resume,
			   NULL)
};

static const struct spi_device_id rmi_id[] = {
	{ "rmi4_spi", 0 },
	{ }
};
MODULE_DEVICE_TABLE(spi, rmi_id);

static struct spi_driver rmi_spi_driver = {
	.driver = {
		.name	= "rmi4_spi",
		.pm	= &rmi_spi_pm,
		.of_match_table = of_match_ptr(rmi_spi_of_match),
	},
	.id_table	= rmi_id,
	.probe		= rmi_spi_probe,
};

module_spi_driver(rmi_spi_driver);

MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com>");
MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
MODULE_DESCRIPTION("RMI SPI driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
8d99758d AD	2	/*
	3	* Copyright (c) 2011-2016 Synaptics Incorporated
	4	* Copyright (c) 2011 Unixphere
8d99758d AD	5	*/
	6
	7	#include <linux/kernel.h>
	8	#include <linux/module.h>
	9	#include <linux/rmi.h>
	10	#include <linux/slab.h>
	11	#include <linux/spi/spi.h>
48147b97	12	#include <linux/of.h>
8d99758d AD	13	#include "rmi_driver.h"
	14
	15	#define RMI_SPI_DEFAULT_XFER_BUF_SIZE 64
	16
	17	#define RMI_PAGE_SELECT_REGISTER 0x00FF
	18	#define RMI_SPI_PAGE(addr) (((addr) >> 8) & 0x80)
	19	#define RMI_SPI_XFER_SIZE_LIMIT 255
	20
	21	#define BUFFER_SIZE_INCREMENT 32
	22
	23	enum rmi_spi_op {
	24	RMI_SPI_WRITE = 0,
	25	RMI_SPI_READ,
	26	RMI_SPI_V2_READ_UNIFIED,
	27	RMI_SPI_V2_READ_SPLIT,
	28	RMI_SPI_V2_WRITE,
	29	};
	30
	31	struct rmi_spi_cmd {
	32	enum rmi_spi_op op;
	33	u16 addr;
	34	};
	35
	36	struct rmi_spi_xport {
	37	struct rmi_transport_dev xport;
	38	struct spi_device *spi;
	39
	40	struct mutex page_mutex;
	41	int page;
	42
8d99758d AD	43	u8 *rx_buf;
	44	u8 *tx_buf;
	45	int xfer_buf_size;
	46
	47	struct spi_transfer *rx_xfers;
	48	struct spi_transfer *tx_xfers;
	49	int rx_xfer_count;
	50	int tx_xfer_count;
	51	};
	52
	53	static int rmi_spi_manage_pools(struct rmi_spi_xport *rmi_spi, int len)
	54	{
	55	struct spi_device *spi = rmi_spi->spi;
	56	int buf_size = rmi_spi->xfer_buf_size
	57	? rmi_spi->xfer_buf_size : RMI_SPI_DEFAULT_XFER_BUF_SIZE;
	58	struct spi_transfer *xfer_buf;
	59	void *buf;
	60	void *tmp;
	61
	62	while (buf_size < len)
	63	buf_size *= 2;
	64
	65	if (buf_size > RMI_SPI_XFER_SIZE_LIMIT)
	66	buf_size = RMI_SPI_XFER_SIZE_LIMIT;
	67
	68	tmp = rmi_spi->rx_buf;
a86854d0	69	buf = devm_kcalloc(&spi->dev, buf_size, 2,
8d99758d AD	70	GFP_KERNEL \| GFP_DMA);
	71	if (!buf)
	72	return -ENOMEM;
	73
	74	rmi_spi->rx_buf = buf;
	75	rmi_spi->tx_buf = &rmi_spi->rx_buf[buf_size];
	76	rmi_spi->xfer_buf_size = buf_size;
	77
	78	if (tmp)
	79	devm_kfree(&spi->dev, tmp);
	80
	81	if (rmi_spi->xport.pdata.spi_data.read_delay_us)
	82	rmi_spi->rx_xfer_count = buf_size;
	83	else
	84	rmi_spi->rx_xfer_count = 1;
	85
	86	if (rmi_spi->xport.pdata.spi_data.write_delay_us)
	87	rmi_spi->tx_xfer_count = buf_size;
	88	else
	89	rmi_spi->tx_xfer_count = 1;
	90
	91	/*
	92	* Allocate a pool of spi_transfer buffers for devices which need
	93	* per byte delays.
	94	*/
	95	tmp = rmi_spi->rx_xfers;
a86854d0 KC	96	xfer_buf = devm_kcalloc(&spi->dev,
	97	rmi_spi->rx_xfer_count + rmi_spi->tx_xfer_count,
	98	sizeof(struct spi_transfer),
	99	GFP_KERNEL);
8d99758d AD	100	if (!xfer_buf)
	101	return -ENOMEM;
	102
	103	rmi_spi->rx_xfers = xfer_buf;
	104	rmi_spi->tx_xfers = &xfer_buf[rmi_spi->rx_xfer_count];
	105
	106	if (tmp)
	107	devm_kfree(&spi->dev, tmp);
	108
	109	return 0;
	110	}
	111
	112	static int rmi_spi_xfer(struct rmi_spi_xport *rmi_spi,
	113	const struct rmi_spi_cmd cmd, const u8 tx_buf,
	114	int tx_len, u8 *rx_buf, int rx_len)
	115	{
	116	struct spi_device *spi = rmi_spi->spi;
	117	struct rmi_device_platform_data_spi *spi_data =
	118	&rmi_spi->xport.pdata.spi_data;
	119	struct spi_message msg;
	120	struct spi_transfer *xfer;
	121	int ret = 0;
	122	int len;
	123	int cmd_len = 0;
	124	int total_tx_len;
	125	int i;
	126	u16 addr = cmd->addr;
	127
	128	spi_message_init(&msg);
	129
	130	switch (cmd->op) {
	131	case RMI_SPI_WRITE:
	132	case RMI_SPI_READ:
	133	cmd_len += 2;
	134	break;
	135	case RMI_SPI_V2_READ_UNIFIED:
	136	case RMI_SPI_V2_READ_SPLIT:
	137	case RMI_SPI_V2_WRITE:
	138	cmd_len += 4;
	139	break;
	140	}
	141
	142	total_tx_len = cmd_len + tx_len;
	143	len = max(total_tx_len, rx_len);
	144
	145	if (len > RMI_SPI_XFER_SIZE_LIMIT)
	146	return -EINVAL;
	147
839c4227 CJ	148	if (rmi_spi->xfer_buf_size < len) {
	149	ret = rmi_spi_manage_pools(rmi_spi, len);
	150	if (ret < 0)
	151	return ret;
	152	}
8d99758d AD	153
	154	if (addr == 0)
	155	/*
	156	* SPI needs an address. Use 0x7FF if we want to keep
	157	* reading from the last position of the register pointer.
	158	*/
	159	addr = 0x7FF;
	160
	161	switch (cmd->op) {
	162	case RMI_SPI_WRITE:
	163	rmi_spi->tx_buf[0] = (addr >> 8);
	164	rmi_spi->tx_buf[1] = addr & 0xFF;
	165	break;
	166	case RMI_SPI_READ:
	167	rmi_spi->tx_buf[0] = (addr >> 8) \| 0x80;
	168	rmi_spi->tx_buf[1] = addr & 0xFF;
	169	break;
	170	case RMI_SPI_V2_READ_UNIFIED:
	171	break;
	172	case RMI_SPI_V2_READ_SPLIT:
	173	break;
	174	case RMI_SPI_V2_WRITE:
	175	rmi_spi->tx_buf[0] = 0x40;
	176	rmi_spi->tx_buf[1] = (addr >> 8) & 0xFF;
	177	rmi_spi->tx_buf[2] = addr & 0xFF;
	178	rmi_spi->tx_buf[3] = tx_len;
	179	break;
	180	}
	181
	182	if (tx_buf)
	183	memcpy(&rmi_spi->tx_buf[cmd_len], tx_buf, tx_len);
	184
	185	if (rmi_spi->tx_xfer_count > 1) {
	186	for (i = 0; i < total_tx_len; i++) {
	187	xfer = &rmi_spi->tx_xfers[i];
	188	memset(xfer, 0, sizeof(struct spi_transfer));
	189	xfer->tx_buf = &rmi_spi->tx_buf[i];
	190	xfer->len = 1;
	191	xfer->delay_usecs = spi_data->write_delay_us;
	192	spi_message_add_tail(xfer, &msg);
	193	}
	194	} else {
	195	xfer = rmi_spi->tx_xfers;
	196	memset(xfer, 0, sizeof(struct spi_transfer));
	197	xfer->tx_buf = rmi_spi->tx_buf;
	198	xfer->len = total_tx_len;
	199	spi_message_add_tail(xfer, &msg);
	200	}
	201
	202	rmi_dbg(RMI_DEBUG_XPORT, &spi->dev, "%s: cmd: %s tx_buf len: %d tx_buf: %*ph\n",
	203	__func__, cmd->op == RMI_SPI_WRITE ? "WRITE" : "READ",
	204	total_tx_len, total_tx_len, rmi_spi->tx_buf);
	205
	206	if (rx_buf) {
	207	if (rmi_spi->rx_xfer_count > 1) {
	208	for (i = 0; i < rx_len; i++) {
	209	xfer = &rmi_spi->rx_xfers[i];
	210	memset(xfer, 0, sizeof(struct spi_transfer));
	211	xfer->rx_buf = &rmi_spi->rx_buf[i];
	212	xfer->len = 1;
	213	xfer->delay_usecs = spi_data->read_delay_us;
	214	spi_message_add_tail(xfer, &msg);
	215	}
	216	} else {
217	xfer = rmi_spi->rx_xfers;
218	memset(xfer, 0, sizeof(struct spi_transfer));
219	xfer->rx_buf = rmi_spi->rx_buf;
220	xfer->len = rx_len;
221	spi_message_add_tail(xfer, &msg);
222	}
223	}
224
225	ret = spi_sync(spi, &msg);
226	if (ret < 0) {
227	dev_err(&spi->dev, "spi xfer failed: %d\n", ret);
228	return ret;
229	}
230
231	if (rx_buf) {
232	memcpy(rx_buf, rmi_spi->rx_buf, rx_len);
233	rmi_dbg(RMI_DEBUG_XPORT, &spi->dev, "%s: (%d) %*ph\n",
234	__func__, rx_len, rx_len, rx_buf);
235	}
236
237	return 0;
238	}
239
240	/*
241	* rmi_set_page - Set RMI page
242	* @xport: The pointer to the rmi_transport_dev struct
243	* @page: The new page address.
244	*
245	* RMI devices have 16-bit addressing, but some of the transport
246	* implementations (like SMBus) only have 8-bit addressing. So RMI implements
247	* a page address at 0xff of every page so we can reliable page addresses
248	* every 256 registers.
249	*
250	* The page_mutex lock must be held when this function is entered.
251	*
252	* Returns zero on success, non-zero on failure.
253	*/
254	static int rmi_set_page(struct rmi_spi_xport *rmi_spi, u8 page)
255	{
256	struct rmi_spi_cmd cmd;
257	int ret;
258
259	cmd.op = RMI_SPI_WRITE;
260	cmd.addr = RMI_PAGE_SELECT_REGISTER;
261
262	ret = rmi_spi_xfer(rmi_spi, &cmd, &page, 1, NULL, 0);
263
264	if (ret)
265	rmi_spi->page = page;
266
267	return ret;
268	}
269
270	static int rmi_spi_write_block(struct rmi_transport_dev *xport, u16 addr,
271	const void *buf, size_t len)
272	{
273	struct rmi_spi_xport *rmi_spi =
274	container_of(xport, struct rmi_spi_xport, xport);
275	struct rmi_spi_cmd cmd;
276	int ret;
277
278	mutex_lock(&rmi_spi->page_mutex);
279
280	if (RMI_SPI_PAGE(addr) != rmi_spi->page) {
281	ret = rmi_set_page(rmi_spi, RMI_SPI_PAGE(addr));
282	if (ret)
283	goto exit;
284	}
285
286	cmd.op = RMI_SPI_WRITE;
287	cmd.addr = addr;
288
289	ret = rmi_spi_xfer(rmi_spi, &cmd, buf, len, NULL, 0);
290
291	exit:
292	mutex_unlock(&rmi_spi->page_mutex);
293	return ret;
294	}
295
296	static int rmi_spi_read_block(struct rmi_transport_dev *xport, u16 addr,
297	void *buf, size_t len)
298	{
299	struct rmi_spi_xport *rmi_spi =
300	container_of(xport, struct rmi_spi_xport, xport);
301	struct rmi_spi_cmd cmd;
302	int ret;
303
304	mutex_lock(&rmi_spi->page_mutex);
305
306	if (RMI_SPI_PAGE(addr) != rmi_spi->page) {
307	ret = rmi_set_page(rmi_spi, RMI_SPI_PAGE(addr));
308	if (ret)
309	goto exit;
310	}
311
312	cmd.op = RMI_SPI_READ;
313	cmd.addr = addr;
314
315	ret = rmi_spi_xfer(rmi_spi, &cmd, NULL, 0, buf, len);
316
317	exit:
318	mutex_unlock(&rmi_spi->page_mutex);
319	return ret;
320	}
321
322	static const struct rmi_transport_ops rmi_spi_ops = {
323	.write_block = rmi_spi_write_block,
324	.read_block = rmi_spi_read_block,
325	};
326
48147b97 AD	327	#ifdef CONFIG_OF
	328	static int rmi_spi_of_probe(struct spi_device *spi,
	329	struct rmi_device_platform_data *pdata)
	330	{
	331	struct device *dev = &spi->dev;
	332	int retval;
	333
	334	retval = rmi_of_property_read_u32(dev,
	335	&pdata->spi_data.read_delay_us,
	336	"spi-rx-delay-us", 1);
	337	if (retval)
	338	return retval;
	339
	340	retval = rmi_of_property_read_u32(dev,
	341	&pdata->spi_data.write_delay_us,
	342	"spi-tx-delay-us", 1);
	343	if (retval)
	344	return retval;
	345
	346	return 0;
	347	}
	348
	349	static const struct of_device_id rmi_spi_of_match[] = {
	350	{ .compatible = "syna,rmi4-spi" },
	351	{},
	352	};
	353	MODULE_DEVICE_TABLE(of, rmi_spi_of_match);
	354	#else
	355	static inline int rmi_spi_of_probe(struct spi_device *spi,
	356	struct rmi_device_platform_data *pdata)
	357	{
	358	return -ENODEV;
	359	}
	360	#endif
	361
bbc2ceeb GR	362	static void rmi_spi_unregister_transport(void *data)
	363	{
	364	struct rmi_spi_xport *rmi_spi = data;
	365
	366	rmi_unregister_transport_device(&rmi_spi->xport);
	367	}
	368
8d99758d AD	369	static int rmi_spi_probe(struct spi_device *spi)
	370	{
	371	struct rmi_spi_xport *rmi_spi;
	372	struct rmi_device_platform_data *pdata;
	373	struct rmi_device_platform_data *spi_pdata = spi->dev.platform_data;
54bf0894	374	int error;
8d99758d AD	375
	376	if (spi->master->flags & SPI_MASTER_HALF_DUPLEX)
	377	return -EINVAL;
	378
	379	rmi_spi = devm_kzalloc(&spi->dev, sizeof(struct rmi_spi_xport),
	380	GFP_KERNEL);
	381	if (!rmi_spi)
	382	return -ENOMEM;
	383
	384	pdata = &rmi_spi->xport.pdata;
	385
48147b97	386	if (spi->dev.of_node) {
54bf0894 DT	387	error = rmi_spi_of_probe(spi, pdata);
	388	if (error)
	389	return error;
48147b97	390	} else if (spi_pdata) {
8d99758d	391	pdata = spi_pdata;
48147b97	392	}
8d99758d AD	393
	394	if (pdata->spi_data.bits_per_word)
	395	spi->bits_per_word = pdata->spi_data.bits_per_word;
	396
	397	if (pdata->spi_data.mode)
	398	spi->mode = pdata->spi_data.mode;
	399
54bf0894 DT	400	error = spi_setup(spi);
54bf0894 DT	401	if (error < 0) {
8d99758d	402	dev_err(&spi->dev, "spi_setup failed!\n");
54bf0894	403	return error;
8d99758d AD	404	}
8d99758d AD	405
3aeed5b5	406	pdata->irq = spi->irq;
8d99758d AD	407
	408	rmi_spi->spi = spi;
	409	mutex_init(&rmi_spi->page_mutex);
	410
	411	rmi_spi->xport.dev = &spi->dev;
	412	rmi_spi->xport.proto_name = "spi";
	413	rmi_spi->xport.ops = &rmi_spi_ops;
	414
	415	spi_set_drvdata(spi, rmi_spi);
	416
54bf0894 DT	417	error = rmi_spi_manage_pools(rmi_spi, RMI_SPI_DEFAULT_XFER_BUF_SIZE);
	418	if (error)
	419	return error;
8d99758d AD	420
	421	/*
	422	* Setting the page to zero will (a) make sure the PSR is in a
	423	* known state, and (b) make sure we can talk to the device.
	424	*/
54bf0894 DT	425	error = rmi_set_page(rmi_spi, 0);
54bf0894 DT	426	if (error) {
8d99758d	427	dev_err(&spi->dev, "Failed to set page select to 0.\n");
54bf0894	428	return error;
8d99758d AD	429	}
8d99758d AD	430
54bf0894 DT	431	dev_info(&spi->dev, "registering SPI-connected sensor\n");
	432
	433	error = rmi_register_transport_device(&rmi_spi->xport);
	434	if (error) {
	435	dev_err(&spi->dev, "failed to register sensor: %d\n", error);
	436	return error;
8d99758d	437	}
54bf0894 DT	438
54bf0894 DT	439	error = devm_add_action_or_reset(&spi->dev,
bbc2ceeb GR	440	rmi_spi_unregister_transport,
bbc2ceeb GR	441	rmi_spi);
54bf0894 DT	442	if (error)
54bf0894 DT	443	return error;
8d99758d	444
8d99758d AD	445	return 0;
	446	}
	447
8d99758d AD	448	#ifdef CONFIG_PM_SLEEP
	449	static int rmi_spi_suspend(struct device *dev)
	450	{
	451	struct spi_device *spi = to_spi_device(dev);
	452	struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
	453	int ret;
	454
3aeed5b5	455	ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev, true);
8d99758d AD	456	if (ret)
	457	dev_warn(dev, "Failed to resume device: %d\n", ret);
	458
8d99758d AD	459	return ret;
	460	}
	461
	462	static int rmi_spi_resume(struct device *dev)
	463	{
	464	struct spi_device *spi = to_spi_device(dev);
	465	struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
	466	int ret;
	467
3aeed5b5	468	ret = rmi_driver_resume(rmi_spi->xport.rmi_dev, true);
8d99758d AD	469	if (ret)
	470	dev_warn(dev, "Failed to resume device: %d\n", ret);
	471
	472	return ret;
	473	}
	474	#endif
	475
	476	#ifdef CONFIG_PM
	477	static int rmi_spi_runtime_suspend(struct device *dev)
	478	{
	479	struct spi_device *spi = to_spi_device(dev);
	480	struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
	481	int ret;
	482
3aeed5b5	483	ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev, false);
8d99758d AD	484	if (ret)
	485	dev_warn(dev, "Failed to resume device: %d\n", ret);
	486
8d99758d AD	487	return 0;
	488	}
	489
	490	static int rmi_spi_runtime_resume(struct device *dev)
	491	{
	492	struct spi_device *spi = to_spi_device(dev);
	493	struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
	494	int ret;
	495
3aeed5b5	496	ret = rmi_driver_resume(rmi_spi->xport.rmi_dev, false);
8d99758d AD	497	if (ret)
	498	dev_warn(dev, "Failed to resume device: %d\n", ret);
	499
	500	return 0;
	501	}
	502	#endif
	503
	504	static const struct dev_pm_ops rmi_spi_pm = {
	505	SET_SYSTEM_SLEEP_PM_OPS(rmi_spi_suspend, rmi_spi_resume)
	506	SET_RUNTIME_PM_OPS(rmi_spi_runtime_suspend, rmi_spi_runtime_resume,
	507	NULL)
	508	};
	509
	510	static const struct spi_device_id rmi_id[] = {
	511	{ "rmi4_spi", 0 },
	512	{ }
	513	};
	514	MODULE_DEVICE_TABLE(spi, rmi_id);
	515
	516	static struct spi_driver rmi_spi_driver = {
	517	.driver = {
	518	.name = "rmi4_spi",
	519	.pm = &rmi_spi_pm,
48147b97	520	.of_match_table = of_match_ptr(rmi_spi_of_match),
8d99758d AD	521	},
	522	.id_table = rmi_id,
	523	.probe = rmi_spi_probe,
8d99758d AD	524	};
	525
	526	module_spi_driver(rmi_spi_driver);
	527
	528	MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com>");
	529	MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
	530	MODULE_DESCRIPTION("RMI SPI driver");
	531	MODULE_LICENSE("GPL");