xref: /device/soc/rockchip/rk3588/kernel/drivers/mfd/rk806-spi.c

// SPDX-License-Identifier: GPL-2.0
/*
 * SPI access driver for rockchip rk806
 *
 * Copyright (c) 2021 Rockchip Electronics Co., Ltd.
 *
 * Author: Xu Shengfei <xsf@rock-chips.com>
 */

#include <linux/mfd/rk806.h>
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/spi/spi.h>

static const struct of_device_id rk806_spi_of_match_table[] = {
	{ .compatible = "rockchip,rk806", },
	{ }
};
MODULE_DEVICE_TABLE(of, rk806_spi_of_match_table);

static int rk806_spi_write(struct spi_device *spi,
			   char addr,
			   const char *data,
			   size_t data_len)
{
	char write_cmd = RK806_CMD_WRITE | (data_len - 1);
	char addrh = RK806_REG_H;
	struct spi_message m;
	int buffer, ret = 0;
	struct spi_transfer write_cmd_packet = {
		.tx_buf	= &buffer,
		.len	= sizeof(buffer),
	};

	buffer = write_cmd | (addr << 8) | (addrh << 16) | (*data << 24);

	spi_message_init(&m);
	spi_message_add_tail(&write_cmd_packet, &m);
	ret = spi_sync(spi, &m);
	return ret;
}

static int rk806_spi_bus_write(void *context, const void *data, size_t count)
{
	struct device *dev = context;
	struct spi_device *spi = to_spi_device(dev);
	char buf[2];

	if (count < 2) {
		dev_err(&spi->dev, "regmap write err!\n");
		return -EINVAL;
	}
	memcpy(buf, data, 2);

	return rk806_spi_write(spi, buf[0], &buf[1], (count - 1));
}

static int rk806_spi_bus_read(void *context,
			      const void *reg,
			      size_t reg_size,
			      void *val,
			      size_t val_size)
{
	struct device *dev = context;
	struct spi_device *spi = to_spi_device(dev);
	char addr;
	char txbuf[3] = { 0 };

	if (reg_size != sizeof(char) || val_size < 1)
		return -EINVAL;

	/* Copy address to read from into first element of SPI buffer. */
	memcpy(&addr, reg, sizeof(char));

	txbuf[0] = RK806_CMD_READ | (val_size - 1);
	txbuf[1] = addr;
	txbuf[2] = RK806_REG_H;

	return spi_write_then_read(spi, txbuf, 3, val, val_size);
}

static const struct regmap_bus rk806_regmap_bus_spi = {
	.write = rk806_spi_bus_write,
	.read = rk806_spi_bus_read,
	.reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
	.val_format_endian_default = REGMAP_ENDIAN_NATIVE,
};

static int rk806_spi_probe(struct spi_device *spi)
{
	struct rk806 *rk806;

	rk806 = devm_kzalloc(&spi->dev, sizeof(*rk806), GFP_KERNEL);
	if (!rk806)
		return -ENOMEM;

	spi_set_drvdata(spi, rk806);
	rk806->dev = &spi->dev;
	rk806->irq = spi->irq;

	rk806->regmap = devm_regmap_init(&spi->dev,
					 &rk806_regmap_bus_spi,
					 &spi->dev,
					 &rk806_regmap_config_spi);
	if (IS_ERR(rk806->regmap)) {
		dev_err(rk806->dev, "Failed to initialize register map\n");
		return PTR_ERR(rk806->regmap);
	}

	return rk806_device_init(rk806);
}

static int rk806_spi_remove(struct spi_device *spi)
{
	struct rk806 *rk806 = spi_get_drvdata(spi);

	return rk806_device_exit(rk806);
}

static const struct spi_device_id rk806_spi_id_table[] = {
	{ "rk806", 0 },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(spi, rk806_spi_id_table);

static struct spi_driver rk806_spi_driver = {
	.driver		= {
		.name	= "rk806",
		.owner = THIS_MODULE,
		.of_match_table = rk806_spi_of_match_table,
	},
	.probe		= rk806_spi_probe,
	.remove		= rk806_spi_remove,
	.id_table	= rk806_spi_id_table,
};
module_spi_driver(rk806_spi_driver);

MODULE_AUTHOR("Xu Shengfei <xsf@rock-chips.com>");
MODULE_DESCRIPTION("RK806 SPI Interface Driver");
MODULE_LICENSE("GPL v2");