[people/ms/u-boot.git] / drivers / spi / soft_spi.c

/*
 * Copyright (c) 2014 Google, Inc
 *
 * (C) Copyright 2002
 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
 *
 * Influenced by code from:
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <dm.h>
#include <errno.h>
#include <fdtdec.h>
#include <malloc.h>
#include <spi.h>
#include <asm/gpio.h>

DECLARE_GLOBAL_DATA_PTR;

struct soft_spi_platdata {
	struct gpio_desc cs;
	struct gpio_desc sclk;
	struct gpio_desc mosi;
	struct gpio_desc miso;
	int spi_delay_us;
	int flags;
};

#define SPI_MASTER_NO_RX        BIT(0)
#define SPI_MASTER_NO_TX        BIT(1)

struct soft_spi_priv {
	unsigned int mode;
};

static int soft_spi_scl(struct udevice *dev, int bit)
{
	struct udevice *bus = dev_get_parent(dev);
	struct soft_spi_platdata *plat = dev_get_platdata(bus);

	dm_gpio_set_value(&plat->sclk, bit);

	return 0;
}

static int soft_spi_sda(struct udevice *dev, int bit)
{
	struct udevice *bus = dev_get_parent(dev);
	struct soft_spi_platdata *plat = dev_get_platdata(bus);

	dm_gpio_set_value(&plat->mosi, bit);

	return 0;
}

static int soft_spi_cs_activate(struct udevice *dev)
{
	struct udevice *bus = dev_get_parent(dev);
	struct soft_spi_platdata *plat = dev_get_platdata(bus);

	dm_gpio_set_value(&plat->cs, 0);
	dm_gpio_set_value(&plat->sclk, 0);
	dm_gpio_set_value(&plat->cs, 1);

	return 0;
}

static int soft_spi_cs_deactivate(struct udevice *dev)
{
	struct udevice *bus = dev_get_parent(dev);
	struct soft_spi_platdata *plat = dev_get_platdata(bus);

	dm_gpio_set_value(&plat->cs, 0);

	return 0;
}

static int soft_spi_claim_bus(struct udevice *dev)
{
	/*
	 * Make sure the SPI clock is in idle state as defined for
	 * this slave.
	 */
	return soft_spi_scl(dev, 0);
}

static int soft_spi_release_bus(struct udevice *dev)
{
	/* Nothing to do */
	return 0;
}

/*-----------------------------------------------------------------------
 * SPI transfer
 *
 * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
 * "bitlen" bits in the SPI MISO port.  That's just the way SPI works.
 *
 * The source of the outgoing bits is the "dout" parameter and the
 * destination of the input bits is the "din" parameter.  Note that "dout"
 * and "din" can point to the same memory location, in which case the
 * input data overwrites the output data (since both are buffered by
 * temporary variables, this is OK).
 */
static int soft_spi_xfer(struct udevice *dev, unsigned int bitlen,
			 const void *dout, void *din, unsigned long flags)
{
	struct udevice *bus = dev_get_parent(dev);
	struct soft_spi_priv *priv = dev_get_priv(bus);
	struct soft_spi_platdata *plat = dev_get_platdata(bus);
	uchar		tmpdin  = 0;
	uchar		tmpdout = 0;
	const u8	*txd = dout;
	u8		*rxd = din;
	int		cpha = priv->mode & SPI_CPHA;
	unsigned int	j;

	debug("spi_xfer: slave %s:%s dout %08X din %08X bitlen %u\n",
	      dev->parent->name, dev->name, *(uint *)txd, *(uint *)rxd,
	      bitlen);

	if (flags & SPI_XFER_BEGIN)
		soft_spi_cs_activate(dev);

	for (j = 0; j < bitlen; j++) {
		/*
		 * Check if it is time to work on a new byte.
		 */
		if ((j % 8) == 0) {
			if (txd)
				tmpdout = *txd++;
			else
				tmpdout = 0;
			if (j != 0) {
				if (rxd)
					*rxd++ = tmpdin;
			}
			tmpdin  = 0;
		}

		if (!cpha)
			soft_spi_scl(dev, 0);
		if ((plat->flags & SPI_MASTER_NO_TX) == 0)
			soft_spi_sda(dev, !!(tmpdout & 0x80));
		udelay(plat->spi_delay_us);
		if (cpha)
			soft_spi_scl(dev, 0);
		else
			soft_spi_scl(dev, 1);
		tmpdin	<<= 1;
		if ((plat->flags & SPI_MASTER_NO_RX) == 0)
			tmpdin	|= dm_gpio_get_value(&plat->miso);
		tmpdout	<<= 1;
		udelay(plat->spi_delay_us);
		if (cpha)
			soft_spi_scl(dev, 1);
	}
	/*
	 * If the number of bits isn't a multiple of 8, shift the last
	 * bits over to left-justify them.  Then store the last byte
	 * read in.
	 */
	if (rxd) {
		if ((bitlen % 8) != 0)
			tmpdin <<= 8 - (bitlen % 8);
		*rxd++ = tmpdin;
	}

	if (flags & SPI_XFER_END)
		soft_spi_cs_deactivate(dev);

	return 0;
}

static int soft_spi_set_speed(struct udevice *dev, unsigned int speed)
{
	/* Accept any speed */
	return 0;
}

static int soft_spi_set_mode(struct udevice *dev, unsigned int mode)
{
	struct soft_spi_priv *priv = dev_get_priv(dev);

	priv->mode = mode;

	return 0;
}

static const struct dm_spi_ops soft_spi_ops = {
	.claim_bus	= soft_spi_claim_bus,
	.release_bus	= soft_spi_release_bus,
	.xfer		= soft_spi_xfer,
	.set_speed	= soft_spi_set_speed,
	.set_mode	= soft_spi_set_mode,
};

static int soft_spi_ofdata_to_platdata(struct udevice *dev)
{
	struct soft_spi_platdata *plat = dev->platdata;
	const void *blob = gd->fdt_blob;
	int node = dev_of_offset(dev);

	plat->spi_delay_us = fdtdec_get_int(blob, node, "spi-delay-us", 0);

	return 0;
}

static int soft_spi_probe(struct udevice *dev)
{
	struct spi_slave *slave = dev_get_parent_priv(dev);
	struct soft_spi_platdata *plat = dev->platdata;
	int cs_flags, clk_flags;
	int ret;

	cs_flags = (slave->mode & SPI_CS_HIGH) ? 0 : GPIOD_ACTIVE_LOW;
	clk_flags = (slave->mode & SPI_CPOL) ? GPIOD_ACTIVE_LOW : 0;

	if (gpio_request_by_name(dev, "cs-gpios", 0, &plat->cs,
				 GPIOD_IS_OUT | cs_flags) ||
	    gpio_request_by_name(dev, "gpio-sck", 0, &plat->sclk,
				 GPIOD_IS_OUT | clk_flags))
		return -EINVAL;

	ret = gpio_request_by_name(dev, "gpio-mosi", 0, &plat->mosi,
				   GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE);
	if (ret)
		plat->flags |= SPI_MASTER_NO_TX;

	ret = gpio_request_by_name(dev, "gpio-miso", 0, &plat->miso,
				   GPIOD_IS_IN);
	if (ret)
		plat->flags |= SPI_MASTER_NO_RX;

	if ((plat->flags & (SPI_MASTER_NO_RX | SPI_MASTER_NO_TX)) ==
	    (SPI_MASTER_NO_RX | SPI_MASTER_NO_TX))
		return -EINVAL;

	return 0;
}

static const struct udevice_id soft_spi_ids[] = {
	{ .compatible = "spi-gpio" },
	{ }
};

U_BOOT_DRIVER(soft_spi) = {
	.name	= "soft_spi",
	.id	= UCLASS_SPI,
	.of_match = soft_spi_ids,
	.ops	= &soft_spi_ops,
	.ofdata_to_platdata = soft_spi_ofdata_to_platdata,
	.platdata_auto_alloc_size = sizeof(struct soft_spi_platdata),
	.priv_auto_alloc_size = sizeof(struct soft_spi_priv),
	.probe	= soft_spi_probe,
};
Commit	Line	Data
623b6386 SG	1	/*
	2	* Copyright (c) 2014 Google, Inc
	3	*
	4	* (C) Copyright 2002
	5	* Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
	6	*
	7	* Influenced by code from:
	8	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
	9	*
	10	* SPDX-License-Identifier: GPL-2.0+
	11	*/
	12
	13	#include <common.h>
	14	#include <dm.h>
	15	#include <errno.h>
	16	#include <fdtdec.h>
	17	#include <malloc.h>
	18	#include <spi.h>
	19	#include <asm/gpio.h>
	20
	21	DECLARE_GLOBAL_DATA_PTR;
	22
	23	struct soft_spi_platdata {
050fb909 SG	24	struct gpio_desc cs;
	25	struct gpio_desc sclk;
	26	struct gpio_desc mosi;
	27	struct gpio_desc miso;
623b6386	28	int spi_delay_us;
102412c4	29	int flags;
623b6386 SG	30	};
623b6386 SG	31
102412c4 PF	32	#define SPI_MASTER_NO_RX BIT(0)
	33	#define SPI_MASTER_NO_TX BIT(1)
	34
623b6386 SG	35	struct soft_spi_priv {
	36	unsigned int mode;
	37	};
	38
	39	static int soft_spi_scl(struct udevice *dev, int bit)
	40	{
b6d54d52 PF	41	struct udevice *bus = dev_get_parent(dev);
b6d54d52 PF	42	struct soft_spi_platdata *plat = dev_get_platdata(bus);
623b6386	43
050fb909	44	dm_gpio_set_value(&plat->sclk, bit);
623b6386 SG	45
	46	return 0;
	47	}
	48
	49	static int soft_spi_sda(struct udevice *dev, int bit)
	50	{
b6d54d52 PF	51	struct udevice *bus = dev_get_parent(dev);
b6d54d52 PF	52	struct soft_spi_platdata *plat = dev_get_platdata(bus);
623b6386	53
050fb909	54	dm_gpio_set_value(&plat->mosi, bit);
623b6386 SG	55
	56	return 0;
	57	}
	58
	59	static int soft_spi_cs_activate(struct udevice *dev)
	60	{
b6d54d52 PF	61	struct udevice *bus = dev_get_parent(dev);
b6d54d52 PF	62	struct soft_spi_platdata *plat = dev_get_platdata(bus);
623b6386	63
050fb909 SG	64	dm_gpio_set_value(&plat->cs, 0);
	65	dm_gpio_set_value(&plat->sclk, 0);
	66	dm_gpio_set_value(&plat->cs, 1);
623b6386 SG	67
	68	return 0;
	69	}
	70
	71	static int soft_spi_cs_deactivate(struct udevice *dev)
	72	{
b6d54d52 PF	73	struct udevice *bus = dev_get_parent(dev);
b6d54d52 PF	74	struct soft_spi_platdata *plat = dev_get_platdata(bus);
623b6386	75
050fb909	76	dm_gpio_set_value(&plat->cs, 0);
623b6386 SG	77
	78	return 0;
	79	}
	80
	81	static int soft_spi_claim_bus(struct udevice *dev)
	82	{
	83	/*
	84	* Make sure the SPI clock is in idle state as defined for
	85	* this slave.
	86	*/
	87	return soft_spi_scl(dev, 0);
	88	}
	89
	90	static int soft_spi_release_bus(struct udevice *dev)
	91	{
	92	/* Nothing to do */
	93	return 0;
	94	}
	95
	96	/*-----------------------------------------------------------------------
	97	* SPI transfer
	98	*
	99	* This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
	100	* "bitlen" bits in the SPI MISO port. That's just the way SPI works.
	101	*
	102	* The source of the outgoing bits is the "dout" parameter and the
	103	* destination of the input bits is the "din" parameter. Note that "dout"
	104	* and "din" can point to the same memory location, in which case the
	105	* input data overwrites the output data (since both are buffered by
	106	* temporary variables, this is OK).
	107	*/
	108	static int soft_spi_xfer(struct udevice *dev, unsigned int bitlen,
	109	const void dout, void din, unsigned long flags)
	110	{
b6d54d52 PF	111	struct udevice *bus = dev_get_parent(dev);
	112	struct soft_spi_priv *priv = dev_get_priv(bus);
	113	struct soft_spi_platdata *plat = dev_get_platdata(bus);
623b6386 SG	114	uchar tmpdin = 0;
	115	uchar tmpdout = 0;
	116	const u8 *txd = dout;
	117	u8 *rxd = din;
623b6386 SG	118	int cpha = priv->mode & SPI_CPHA;
	119	unsigned int j;
	120
	121	debug("spi_xfer: slave %s:%s dout %08X din %08X bitlen %u\n",
	122	dev->parent->name, dev->name, (uint )txd, (uint )rxd,
	123	bitlen);
	124
	125	if (flags & SPI_XFER_BEGIN)
	126	soft_spi_cs_activate(dev);
	127
	128	for (j = 0; j < bitlen; j++) {
	129	/*
	130	* Check if it is time to work on a new byte.
	131	*/
	132	if ((j % 8) == 0) {
	133	if (txd)
	134	tmpdout = *txd++;
	135	else
	136	tmpdout = 0;
	137	if (j != 0) {
	138	if (rxd)
	139	*rxd++ = tmpdin;
	140	}
	141	tmpdin = 0;
	142	}
	143
	144	if (!cpha)
050fb909	145	soft_spi_scl(dev, 0);
102412c4 PF	146	if ((plat->flags & SPI_MASTER_NO_TX) == 0)
102412c4 PF	147	soft_spi_sda(dev, !!(tmpdout & 0x80));
623b6386 SG	148	udelay(plat->spi_delay_us);
623b6386 SG	149	if (cpha)
050fb909	150	soft_spi_scl(dev, 0);
623b6386	151	else
050fb909	152	soft_spi_scl(dev, 1);
623b6386	153	tmpdin <<= 1;
102412c4 PF	154	if ((plat->flags & SPI_MASTER_NO_RX) == 0)
102412c4 PF	155	tmpdin \|= dm_gpio_get_value(&plat->miso);
623b6386 SG	156	tmpdout <<= 1;
	157	udelay(plat->spi_delay_us);
	158	if (cpha)
050fb909	159	soft_spi_scl(dev, 1);
623b6386 SG	160	}
	161	/*
	162	* If the number of bits isn't a multiple of 8, shift the last
	163	* bits over to left-justify them. Then store the last byte
	164	* read in.
	165	*/
	166	if (rxd) {
	167	if ((bitlen % 8) != 0)
	168	tmpdin <<= 8 - (bitlen % 8);
	169	*rxd++ = tmpdin;
	170	}
	171
	172	if (flags & SPI_XFER_END)
	173	soft_spi_cs_deactivate(dev);
	174
	175	return 0;
	176	}
	177
	178	static int soft_spi_set_speed(struct udevice *dev, unsigned int speed)
	179	{
	180	/* Accept any speed */
	181	return 0;
	182	}
	183
	184	static int soft_spi_set_mode(struct udevice *dev, unsigned int mode)
	185	{
	186	struct soft_spi_priv *priv = dev_get_priv(dev);
	187
	188	priv->mode = mode;
	189
	190	return 0;
	191	}
	192
623b6386 SG	193	static const struct dm_spi_ops soft_spi_ops = {
	194	.claim_bus = soft_spi_claim_bus,
	195	.release_bus = soft_spi_release_bus,
	196	.xfer = soft_spi_xfer,
	197	.set_speed = soft_spi_set_speed,
	198	.set_mode = soft_spi_set_mode,
	199	};
	200
	201	static int soft_spi_ofdata_to_platdata(struct udevice *dev)
	202	{
	203	struct soft_spi_platdata *plat = dev->platdata;
	204	const void *blob = gd->fdt_blob;
e160f7d4	205	int node = dev_of_offset(dev);
623b6386	206
623b6386 SG	207	plat->spi_delay_us = fdtdec_get_int(blob, node, "spi-delay-us", 0);
	208
	209	return 0;
	210	}
	211
	212	static int soft_spi_probe(struct udevice *dev)
	213	{
bcbe3d15	214	struct spi_slave *slave = dev_get_parent_priv(dev);
623b6386	215	struct soft_spi_platdata *plat = dev->platdata;
050fb909	216	int cs_flags, clk_flags;
102412c4	217	int ret;
050fb909 SG	218
	219	cs_flags = (slave->mode & SPI_CS_HIGH) ? 0 : GPIOD_ACTIVE_LOW;
	220	clk_flags = (slave->mode & SPI_CPOL) ? GPIOD_ACTIVE_LOW : 0;
102412c4 PF	221
102412c4 PF	222	if (gpio_request_by_name(dev, "cs-gpios", 0, &plat->cs,
050fb909	223	GPIOD_IS_OUT \| cs_flags) \|\|
102412c4 PF	224	gpio_request_by_name(dev, "gpio-sck", 0, &plat->sclk,
	225	GPIOD_IS_OUT \| clk_flags))
	226	return -EINVAL;
	227
	228	ret = gpio_request_by_name(dev, "gpio-mosi", 0, &plat->mosi,
	229	GPIOD_IS_OUT \| GPIOD_IS_OUT_ACTIVE);
	230	if (ret)
	231	plat->flags \|= SPI_MASTER_NO_TX;
	232
	233	ret = gpio_request_by_name(dev, "gpio-miso", 0, &plat->miso,
	234	GPIOD_IS_IN);
	235	if (ret)
	236	plat->flags \|= SPI_MASTER_NO_RX;
	237
	238	if ((plat->flags & (SPI_MASTER_NO_RX \| SPI_MASTER_NO_TX)) ==
	239	(SPI_MASTER_NO_RX \| SPI_MASTER_NO_TX))
050fb909	240	return -EINVAL;
623b6386 SG	241
	242	return 0;
	243	}
	244
	245	static const struct udevice_id soft_spi_ids[] = {
102412c4	246	{ .compatible = "spi-gpio" },
623b6386 SG	247	{ }
	248	};
	249
	250	U_BOOT_DRIVER(soft_spi) = {
	251	.name = "soft_spi",
	252	.id = UCLASS_SPI,
	253	.of_match = soft_spi_ids,
	254	.ops = &soft_spi_ops,
	255	.ofdata_to_platdata = soft_spi_ofdata_to_platdata,
	256	.platdata_auto_alloc_size = sizeof(struct soft_spi_platdata),
	257	.priv_auto_alloc_size = sizeof(struct soft_spi_priv),
623b6386	258	.probe = soft_spi_probe,
623b6386	259	};