[mirror_ubuntu-jammy-kernel.git] / drivers / spi / spi-lp8841-rtc.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * SPI master driver for ICP DAS LP-8841 RTC
 *
 * Copyright (C) 2016 Sergei Ianovich
 *
 * based on
 *
 * Dallas DS1302 RTC Support
 * Copyright (C) 2002 David McCullough
 * Copyright (C) 2003 - 2007 Paul Mundt
 */
#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/spi/spi.h>

#define DRIVER_NAME	"spi_lp8841_rtc"

#define SPI_LP8841_RTC_CE	0x01
#define SPI_LP8841_RTC_CLK	0x02
#define SPI_LP8841_RTC_nWE	0x04
#define SPI_LP8841_RTC_MOSI	0x08
#define SPI_LP8841_RTC_MISO	0x01

/*
 * REVISIT If there is support for SPI_3WIRE and SPI_LSB_FIRST in SPI
 * GPIO driver, this SPI driver can be replaced by a simple GPIO driver
 * providing 3 GPIO pins.
 */

struct spi_lp8841_rtc {
	void		*iomem;
	unsigned long	state;
};

static inline void
setsck(struct spi_lp8841_rtc *data, int is_on)
{
	if (is_on)
		data->state |= SPI_LP8841_RTC_CLK;
	else
		data->state &= ~SPI_LP8841_RTC_CLK;
	writeb(data->state, data->iomem);
}

static inline void
setmosi(struct spi_lp8841_rtc *data, int is_on)
{
	if (is_on)
		data->state |= SPI_LP8841_RTC_MOSI;
	else
		data->state &= ~SPI_LP8841_RTC_MOSI;
	writeb(data->state, data->iomem);
}

static inline int
getmiso(struct spi_lp8841_rtc *data)
{
	return ioread8(data->iomem) & SPI_LP8841_RTC_MISO;
}

static inline u32
bitbang_txrx_be_cpha0_lsb(struct spi_lp8841_rtc *data,
		unsigned usecs, unsigned cpol, unsigned flags,
		u32 word, u8 bits)
{
	/* if (cpol == 0) this is SPI_MODE_0; else this is SPI_MODE_2 */

	u32 shift = 32 - bits;
	/* clock starts at inactive polarity */
	for (; likely(bits); bits--) {

		/* setup LSB (to slave) on leading edge */
		if ((flags & SPI_MASTER_NO_TX) == 0)
			setmosi(data, (word & 1));

		usleep_range(usecs, usecs + 1);	/* T(setup) */

		/* sample LSB (from slave) on trailing edge */
		word >>= 1;
		if ((flags & SPI_MASTER_NO_RX) == 0)
			word |= (getmiso(data) << 31);

		setsck(data, !cpol);
		usleep_range(usecs, usecs + 1);

		setsck(data, cpol);
	}

	word >>= shift;
	return word;
}

static int
spi_lp8841_rtc_transfer_one(struct spi_master *master,
			    struct spi_device *spi,
			    struct spi_transfer *t)
{
	struct spi_lp8841_rtc	*data = spi_master_get_devdata(master);
	unsigned		count = t->len;
	const u8		*tx = t->tx_buf;
	u8			*rx = t->rx_buf;
	u8			word = 0;
	int			ret = 0;

	if (tx) {
		data->state &= ~SPI_LP8841_RTC_nWE;
		writeb(data->state, data->iomem);
		while (likely(count > 0)) {
			word = *tx++;
			bitbang_txrx_be_cpha0_lsb(data, 1, 0,
					SPI_MASTER_NO_RX, word, 8);
			count--;
		}
	} else if (rx) {
		data->state |= SPI_LP8841_RTC_nWE;
		writeb(data->state, data->iomem);
		while (likely(count > 0)) {
			word = bitbang_txrx_be_cpha0_lsb(data, 1, 0,
					SPI_MASTER_NO_TX, word, 8);
			*rx++ = word;
			count--;
		}
	} else {
		ret = -EINVAL;
	}

	spi_finalize_current_transfer(master);

	return ret;
}

static void
spi_lp8841_rtc_set_cs(struct spi_device *spi, bool enable)
{
	struct spi_lp8841_rtc *data = spi_master_get_devdata(spi->master);

	data->state = 0;
	writeb(data->state, data->iomem);
	if (enable) {
		usleep_range(4, 5);
		data->state |= SPI_LP8841_RTC_CE;
		writeb(data->state, data->iomem);
		usleep_range(4, 5);
	}
}

static int
spi_lp8841_rtc_setup(struct spi_device *spi)
{
	if ((spi->mode & SPI_CS_HIGH) == 0) {
		dev_err(&spi->dev, "unsupported active low chip select\n");
		return -EINVAL;
	}

	if ((spi->mode & SPI_LSB_FIRST) == 0) {
		dev_err(&spi->dev, "unsupported MSB first mode\n");
		return -EINVAL;
	}

	if ((spi->mode & SPI_3WIRE) == 0) {
		dev_err(&spi->dev, "unsupported wiring. 3 wires required\n");
		return -EINVAL;
	}

	return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id spi_lp8841_rtc_dt_ids[] = {
	{ .compatible = "icpdas,lp8841-spi-rtc" },
	{ }
};

MODULE_DEVICE_TABLE(of, spi_lp8841_rtc_dt_ids);
#endif

static int
spi_lp8841_rtc_probe(struct platform_device *pdev)
{
	int				ret;
	struct spi_master		*master;
	struct spi_lp8841_rtc		*data;

	master = spi_alloc_master(&pdev->dev, sizeof(*data));
	if (!master)
		return -ENOMEM;
	platform_set_drvdata(pdev, master);

	master->flags = SPI_MASTER_HALF_DUPLEX;
	master->mode_bits = SPI_CS_HIGH | SPI_3WIRE | SPI_LSB_FIRST;

	master->bus_num = pdev->id;
	master->num_chipselect = 1;
	master->setup = spi_lp8841_rtc_setup;
	master->set_cs = spi_lp8841_rtc_set_cs;
	master->transfer_one = spi_lp8841_rtc_transfer_one;
	master->bits_per_word_mask = SPI_BPW_MASK(8);
#ifdef CONFIG_OF
	master->dev.of_node = pdev->dev.of_node;
#endif

	data = spi_master_get_devdata(master);

	data->iomem = devm_platform_ioremap_resource(pdev, 0);
	ret = PTR_ERR_OR_ZERO(data->iomem);
	if (ret) {
		dev_err(&pdev->dev, "failed to get IO address\n");
		goto err_put_master;
	}

	/* register with the SPI framework */
	ret = devm_spi_register_master(&pdev->dev, master);
	if (ret) {
		dev_err(&pdev->dev, "cannot register spi master\n");
		goto err_put_master;
	}

	return ret;


err_put_master:
	spi_master_put(master);

	return ret;
}

MODULE_ALIAS("platform:" DRIVER_NAME);

static struct platform_driver spi_lp8841_rtc_driver = {
	.driver = {
		.name	= DRIVER_NAME,
		.of_match_table = of_match_ptr(spi_lp8841_rtc_dt_ids),
	},
	.probe		= spi_lp8841_rtc_probe,
};
module_platform_driver(spi_lp8841_rtc_driver);

MODULE_DESCRIPTION("SPI master driver for ICP DAS LP-8841 RTC");
MODULE_AUTHOR("Sergei Ianovich");
MODULE_LICENSE("GPL");
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
7ecbfff6 SI	2	/*
	3	* SPI master driver for ICP DAS LP-8841 RTC
	4	*
	5	* Copyright (C) 2016 Sergei Ianovich
	6	*
	7	* based on
	8	*
	9	* Dallas DS1302 RTC Support
	10	* Copyright (C) 2002 David McCullough
	11	* Copyright (C) 2003 - 2007 Paul Mundt
7ecbfff6 SI	12	*/
	13	#include <linux/delay.h>
	14	#include <linux/kernel.h>
	15	#include <linux/module.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/of.h>
	18	#include <linux/of_device.h>
	19	#include <linux/spi/spi.h>
	20
	21	#define DRIVER_NAME "spi_lp8841_rtc"
	22
	23	#define SPI_LP8841_RTC_CE 0x01
	24	#define SPI_LP8841_RTC_CLK 0x02
	25	#define SPI_LP8841_RTC_nWE 0x04
	26	#define SPI_LP8841_RTC_MOSI 0x08
	27	#define SPI_LP8841_RTC_MISO 0x01
	28
	29	/*
	30	* REVISIT If there is support for SPI_3WIRE and SPI_LSB_FIRST in SPI
	31	* GPIO driver, this SPI driver can be replaced by a simple GPIO driver
	32	* providing 3 GPIO pins.
	33	*/
	34
	35	struct spi_lp8841_rtc {
	36	void *iomem;
	37	unsigned long state;
	38	};
	39
	40	static inline void
	41	setsck(struct spi_lp8841_rtc *data, int is_on)
	42	{
	43	if (is_on)
	44	data->state \|= SPI_LP8841_RTC_CLK;
	45	else
	46	data->state &= ~SPI_LP8841_RTC_CLK;
	47	writeb(data->state, data->iomem);
	48	}
	49
	50	static inline void
	51	setmosi(struct spi_lp8841_rtc *data, int is_on)
	52	{
	53	if (is_on)
	54	data->state \|= SPI_LP8841_RTC_MOSI;
	55	else
	56	data->state &= ~SPI_LP8841_RTC_MOSI;
	57	writeb(data->state, data->iomem);
	58	}
	59
	60	static inline int
	61	getmiso(struct spi_lp8841_rtc *data)
	62	{
	63	return ioread8(data->iomem) & SPI_LP8841_RTC_MISO;
	64	}
	65
	66	static inline u32
	67	bitbang_txrx_be_cpha0_lsb(struct spi_lp8841_rtc *data,
	68	unsigned usecs, unsigned cpol, unsigned flags,
	69	u32 word, u8 bits)
	70	{
	71	/* if (cpol == 0) this is SPI_MODE_0; else this is SPI_MODE_2 */
	72
	73	u32 shift = 32 - bits;
	74	/* clock starts at inactive polarity */
	75	for (; likely(bits); bits--) {
76
77	/* setup LSB (to slave) on leading edge */
78	if ((flags & SPI_MASTER_NO_TX) == 0)
79	setmosi(data, (word & 1));
80
81	usleep_range(usecs, usecs + 1); /* T(setup) */
82
83	/* sample LSB (from slave) on trailing edge */
84	word >>= 1;
85	if ((flags & SPI_MASTER_NO_RX) == 0)
86	word \|= (getmiso(data) << 31);
87
88	setsck(data, !cpol);
89	usleep_range(usecs, usecs + 1);
90
91	setsck(data, cpol);
92	}
93
94	word >>= shift;
95	return word;
96	}
97
98	static int
99	spi_lp8841_rtc_transfer_one(struct spi_master *master,
100	struct spi_device *spi,
101	struct spi_transfer *t)
102	{
103	struct spi_lp8841_rtc *data = spi_master_get_devdata(master);
104	unsigned count = t->len;
105	const u8 *tx = t->tx_buf;
106	u8 *rx = t->rx_buf;
107	u8 word = 0;
108	int ret = 0;
109
110	if (tx) {
111	data->state &= ~SPI_LP8841_RTC_nWE;
112	writeb(data->state, data->iomem);
113	while (likely(count > 0)) {
114	word = *tx++;
115	bitbang_txrx_be_cpha0_lsb(data, 1, 0,
116	SPI_MASTER_NO_RX, word, 8);
117	count--;
118	}
119	} else if (rx) {
120	data->state \|= SPI_LP8841_RTC_nWE;
121	writeb(data->state, data->iomem);
122	while (likely(count > 0)) {
123	word = bitbang_txrx_be_cpha0_lsb(data, 1, 0,
124	SPI_MASTER_NO_TX, word, 8);
125	*rx++ = word;
126	count--;
127	}
128	} else {
129	ret = -EINVAL;
130	}
131
132	spi_finalize_current_transfer(master);
133
134	return ret;
135	}
136
137	static void
138	spi_lp8841_rtc_set_cs(struct spi_device *spi, bool enable)
139	{
140	struct spi_lp8841_rtc *data = spi_master_get_devdata(spi->master);
141
142	data->state = 0;
143	writeb(data->state, data->iomem);
144	if (enable) {
145	usleep_range(4, 5);
146	data->state \|= SPI_LP8841_RTC_CE;
147	writeb(data->state, data->iomem);
148	usleep_range(4, 5);
149	}
150	}
151
152	static int
153	spi_lp8841_rtc_setup(struct spi_device *spi)
154	{
155	if ((spi->mode & SPI_CS_HIGH) == 0) {
156	dev_err(&spi->dev, "unsupported active low chip select\n");
157	return -EINVAL;
158	}
159
160	if ((spi->mode & SPI_LSB_FIRST) == 0) {
161	dev_err(&spi->dev, "unsupported MSB first mode\n");
162	return -EINVAL;
163	}
164
165	if ((spi->mode & SPI_3WIRE) == 0) {
166	dev_err(&spi->dev, "unsupported wiring. 3 wires required\n");
167	return -EINVAL;
168	}
169
170	return 0;
171	}
172
173	#ifdef CONFIG_OF
174	static const struct of_device_id spi_lp8841_rtc_dt_ids[] = {
175	{ .compatible = "icpdas,lp8841-spi-rtc" },
176	{ }
177	};
178
179	MODULE_DEVICE_TABLE(of, spi_lp8841_rtc_dt_ids);
180	#endif
181
182	static int
183	spi_lp8841_rtc_probe(struct platform_device *pdev)
184	{
185	int ret;
186	struct spi_master *master;
187	struct spi_lp8841_rtc *data;
7ecbfff6 SI	188
	189	master = spi_alloc_master(&pdev->dev, sizeof(*data));
	190	if (!master)
	191	return -ENOMEM;
	192	platform_set_drvdata(pdev, master);
	193
	194	master->flags = SPI_MASTER_HALF_DUPLEX;
	195	master->mode_bits = SPI_CS_HIGH \| SPI_3WIRE \| SPI_LSB_FIRST;
	196
	197	master->bus_num = pdev->id;
	198	master->num_chipselect = 1;
	199	master->setup = spi_lp8841_rtc_setup;
	200	master->set_cs = spi_lp8841_rtc_set_cs;
	201	master->transfer_one = spi_lp8841_rtc_transfer_one;
	202	master->bits_per_word_mask = SPI_BPW_MASK(8);
	203	#ifdef CONFIG_OF
	204	master->dev.of_node = pdev->dev.of_node;
	205	#endif
	206
	207	data = spi_master_get_devdata(master);
	208
7d2600b9	209	data->iomem = devm_platform_ioremap_resource(pdev, 0);
14a20428 AB	210	ret = PTR_ERR_OR_ZERO(data->iomem);
14a20428 AB	211	if (ret) {
7ecbfff6 SI	212	dev_err(&pdev->dev, "failed to get IO address\n");
	213	goto err_put_master;
	214	}
	215
	216	/* register with the SPI framework */
	217	ret = devm_spi_register_master(&pdev->dev, master);
	218	if (ret) {
	219	dev_err(&pdev->dev, "cannot register spi master\n");
	220	goto err_put_master;
	221	}
	222
	223	return ret;
	224
	225
	226	err_put_master:
	227	spi_master_put(master);
	228
	229	return ret;
	230	}
	231
	232	MODULE_ALIAS("platform:" DRIVER_NAME);
	233
	234	static struct platform_driver spi_lp8841_rtc_driver = {
	235	.driver = {
	236	.name = DRIVER_NAME,
	237	.of_match_table = of_match_ptr(spi_lp8841_rtc_dt_ids),
	238	},
	239	.probe = spi_lp8841_rtc_probe,
	240	};
	241	module_platform_driver(spi_lp8841_rtc_driver);
	242
	243	MODULE_DESCRIPTION("SPI master driver for ICP DAS LP-8841 RTC");
	244	MODULE_AUTHOR("Sergei Ianovich");
	245	MODULE_LICENSE("GPL");