[thirdparty/u-boot.git] / drivers / spi / spi-uclass.c

/*
 * Copyright (c) 2014 Google, Inc
 *
 * 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 <dm/device-internal.h>
#include <dm/uclass-internal.h>
#include <dm/lists.h>
#include <dm/util.h>

DECLARE_GLOBAL_DATA_PTR;

static int spi_set_speed_mode(struct udevice *bus, int speed, int mode)
{
	struct dm_spi_ops *ops;
	int ret;

	ops = spi_get_ops(bus);
	if (ops->set_speed)
		ret = ops->set_speed(bus, speed);
	else
		ret = -EINVAL;
	if (ret) {
		printf("Cannot set speed (err=%d)\n", ret);
		return ret;
	}

	if (ops->set_mode)
		ret = ops->set_mode(bus, mode);
	else
		ret = -EINVAL;
	if (ret) {
		printf("Cannot set mode (err=%d)\n", ret);
		return ret;
	}

	return 0;
}

int dm_spi_claim_bus(struct udevice *dev)
{
	struct udevice *bus = dev->parent;
	struct dm_spi_ops *ops = spi_get_ops(bus);
	struct dm_spi_bus *spi = dev_get_uclass_priv(bus);
	struct spi_slave *slave = dev_get_parent_priv(dev);
	int speed;
	int ret;

	speed = slave->max_hz;
	if (spi->max_hz) {
		if (speed)
			speed = min(speed, (int)spi->max_hz);
		else
			speed = spi->max_hz;
	}
	if (!speed)
		speed = 100000;
	if (speed != slave->speed) {
		ret = spi_set_speed_mode(bus, speed, slave->mode);
		if (ret)
			return ret;
		slave->speed = speed;
	}

	return ops->claim_bus ? ops->claim_bus(dev) : 0;
}

void dm_spi_release_bus(struct udevice *dev)
{
	struct udevice *bus = dev->parent;
	struct dm_spi_ops *ops = spi_get_ops(bus);

	if (ops->release_bus)
		ops->release_bus(dev);
}

int dm_spi_xfer(struct udevice *dev, unsigned int bitlen,
		const void *dout, void *din, unsigned long flags)
{
	struct udevice *bus = dev->parent;

	if (bus->uclass->uc_drv->id != UCLASS_SPI)
		return -EOPNOTSUPP;

	return spi_get_ops(bus)->xfer(dev, bitlen, dout, din, flags);
}

int spi_claim_bus(struct spi_slave *slave)
{
	return dm_spi_claim_bus(slave->dev);
}

void spi_release_bus(struct spi_slave *slave)
{
	dm_spi_release_bus(slave->dev);
}

int spi_xfer(struct spi_slave *slave, unsigned int bitlen,
	     const void *dout, void *din, unsigned long flags)
{
	return dm_spi_xfer(slave->dev, bitlen, dout, din, flags);
}

static int spi_child_post_bind(struct udevice *dev)
{
	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);

	if (dev->of_offset == -1)
		return 0;

	return spi_slave_ofdata_to_platdata(gd->fdt_blob, dev->of_offset, plat);
}

static int spi_post_probe(struct udevice *bus)
{
	struct dm_spi_bus *spi = dev_get_uclass_priv(bus);

	spi->max_hz = fdtdec_get_int(gd->fdt_blob, bus->of_offset,
				     "spi-max-frequency", 0);

#if defined(CONFIG_NEEDS_MANUAL_RELOC)
	struct dm_spi_ops *ops = spi_get_ops(bus);


	if (ops->claim_bus)
		ops->claim_bus += gd->reloc_off;
	if (ops->release_bus)
		ops->release_bus += gd->reloc_off;
	if (ops->set_wordlen)
		ops->set_wordlen += gd->reloc_off;
	if (ops->xfer)
		ops->xfer += gd->reloc_off;
	if (ops->set_speed)
		ops->set_speed += gd->reloc_off;
	if (ops->set_mode)
		ops->set_mode += gd->reloc_off;
	if (ops->cs_info)
		ops->cs_info += gd->reloc_off;
#endif

	return 0;
}

static int spi_child_pre_probe(struct udevice *dev)
{
	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
	struct spi_slave *slave = dev_get_parent_priv(dev);

	/*
	 * This is needed because we pass struct spi_slave around the place
	 * instead slave->dev (a struct udevice). So we have to have some
	 * way to access the slave udevice given struct spi_slave. Once we
	 * change the SPI API to use udevice instead of spi_slave, we can
	 * drop this.
	 */
	slave->dev = dev;

	slave->max_hz = plat->max_hz;
	slave->mode = plat->mode;
	slave->mode_rx = plat->mode_rx;
	slave->wordlen = SPI_DEFAULT_WORDLEN;

	return 0;
}

int spi_chip_select(struct udevice *dev)
{
	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);

	return plat ? plat->cs : -ENOENT;
}

int spi_find_chip_select(struct udevice *bus, int cs, struct udevice **devp)
{
	struct udevice *dev;

	for (device_find_first_child(bus, &dev); dev;
	     device_find_next_child(&dev)) {
		struct dm_spi_slave_platdata *plat;

		plat = dev_get_parent_platdata(dev);
		debug("%s: plat=%p, cs=%d\n", __func__, plat, plat->cs);
		if (plat->cs == cs) {
			*devp = dev;
			return 0;
		}
	}

	return -ENODEV;
}

int spi_cs_is_valid(unsigned int busnum, unsigned int cs)
{
	struct spi_cs_info info;
	struct udevice *bus;
	int ret;

	ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus);
	if (ret) {
		debug("%s: No bus %d\n", __func__, busnum);
		return ret;
	}

	return spi_cs_info(bus, cs, &info);
}

int spi_cs_info(struct udevice *bus, uint cs, struct spi_cs_info *info)
{
	struct spi_cs_info local_info;
	struct dm_spi_ops *ops;
	int ret;

	if (!info)
		info = &local_info;

	/* If there is a device attached, return it */
	info->dev = NULL;
	ret = spi_find_chip_select(bus, cs, &info->dev);
	if (!ret)
		return 0;

	/*
	 * Otherwise ask the driver. For the moment we don't have CS info.
	 * When we do we could provide the driver with a helper function
	 * to figure out what chip selects are valid, or just handle the
	 * request.
	 */
	ops = spi_get_ops(bus);
	if (ops->cs_info)
		return ops->cs_info(bus, cs, info);

	/*
	 * We could assume there is at least one valid chip select, but best
	 * to be sure and return an error in this case. The driver didn't
	 * care enough to tell us.
	 */
	return -ENODEV;
}

int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
			struct udevice **devp)
{
	struct udevice *bus, *dev;
	int ret;

	ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus);
	if (ret) {
		debug("%s: No bus %d\n", __func__, busnum);
		return ret;
	}
	ret = spi_find_chip_select(bus, cs, &dev);
	if (ret) {
		debug("%s: No cs %d\n", __func__, cs);
		return ret;
	}
	*busp = bus;
	*devp = dev;

	return ret;
}

int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
		       const char *drv_name, const char *dev_name,
		       struct udevice **busp, struct spi_slave **devp)
{
	struct udevice *bus, *dev;
	struct dm_spi_slave_platdata *plat;
	bool created = false;
	int ret;

	ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus);
	if (ret) {
		printf("Invalid bus %d (err=%d)\n", busnum, ret);
		return ret;
	}
	ret = spi_find_chip_select(bus, cs, &dev);

	/*
	 * If there is no such device, create one automatically. This means
	 * that we don't need a device tree node or platform data for the
	 * SPI flash chip - we will bind to the correct driver.
	 */
	if (ret == -ENODEV && drv_name) {
		debug("%s: Binding new device '%s', busnum=%d, cs=%d, driver=%s\n",
		      __func__, dev_name, busnum, cs, drv_name);
		ret = device_bind_driver(bus, drv_name, dev_name, &dev);
		if (ret)
			return ret;
		plat = dev_get_parent_platdata(dev);
		plat->cs = cs;
		plat->max_hz = speed;
		plat->mode = mode;
		created = true;
	} else if (ret) {
		printf("Invalid chip select %d:%d (err=%d)\n", busnum, cs,
		       ret);
		return ret;
	}

	if (!device_active(dev)) {
		struct spi_slave *slave;

		ret = device_probe(dev);
		if (ret)
			goto err;
		slave = dev_get_parent_priv(dev);
		slave->dev = dev;
	}

	plat = dev_get_parent_platdata(dev);
	if (!speed) {
		speed = plat->max_hz;
		mode = plat->mode;
	}
	ret = spi_set_speed_mode(bus, speed, mode);
	if (ret)
		goto err;

	*busp = bus;
	*devp = dev_get_parent_priv(dev);
	debug("%s: bus=%p, slave=%p\n", __func__, bus, *devp);

	return 0;

err:
	debug("%s: Error path, created=%d, device '%s'\n", __func__,
	      created, dev->name);
	if (created) {
		device_remove(dev);
		device_unbind(dev);
	}

	return ret;
}

/* Compatibility function - to be removed */
struct spi_slave *spi_setup_slave_fdt(const void *blob, int node,
				      int bus_node)
{
	struct udevice *bus, *dev;
	int ret;

	ret = uclass_get_device_by_of_offset(UCLASS_SPI, bus_node, &bus);
	if (ret)
		return NULL;
	ret = device_get_child_by_of_offset(bus, node, &dev);
	if (ret)
		return NULL;
	return dev_get_parent_priv(dev);
}

/* Compatibility function - to be removed */
struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs,
				  unsigned int speed, unsigned int mode)
{
	struct spi_slave *slave;
	struct udevice *dev;
	int ret;

	ret = spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev,
				  &slave);
	if (ret)
		return NULL;

	return slave;
}

void spi_free_slave(struct spi_slave *slave)
{
	device_remove(slave->dev);
	slave->dev = NULL;
}

int spi_slave_ofdata_to_platdata(const void *blob, int node,
				 struct dm_spi_slave_platdata *plat)
{
	int mode = 0, mode_rx = 0;
	int value;

	plat->cs = fdtdec_get_int(blob, node, "reg", -1);
	plat->max_hz = fdtdec_get_int(blob, node, "spi-max-frequency", 0);
	if (fdtdec_get_bool(blob, node, "spi-cpol"))
		mode |= SPI_CPOL;
	if (fdtdec_get_bool(blob, node, "spi-cpha"))
		mode |= SPI_CPHA;
	if (fdtdec_get_bool(blob, node, "spi-cs-high"))
		mode |= SPI_CS_HIGH;
	if (fdtdec_get_bool(blob, node, "spi-3wire"))
		mode |= SPI_3WIRE;
	if (fdtdec_get_bool(blob, node, "spi-half-duplex"))
		mode |= SPI_PREAMBLE;

	/* Device DUAL/QUAD mode */
	value = fdtdec_get_uint(blob, node, "spi-tx-bus-width", 1);
	switch (value) {
	case 1:
		break;
	case 2:
		mode |= SPI_TX_DUAL;
		break;
	case 4:
		mode |= SPI_TX_QUAD;
		break;
	default:
		error("spi-tx-bus-width %d not supported\n", value);
		break;
	}

	plat->mode = mode;

	value = fdtdec_get_uint(blob, node, "spi-rx-bus-width", 1);
	switch (value) {
	case 1:
		break;
	case 2:
		mode_rx |= SPI_RX_DUAL;
		break;
	case 4:
		mode_rx |= SPI_RX_QUAD;
		break;
	default:
		error("spi-rx-bus-width %d not supported\n", value);
		break;
	}

	plat->mode_rx = mode_rx;

	return 0;
}

UCLASS_DRIVER(spi) = {
	.id		= UCLASS_SPI,
	.name		= "spi",
	.flags		= DM_UC_FLAG_SEQ_ALIAS,
	.post_bind	= dm_scan_fdt_dev,
	.post_probe	= spi_post_probe,
	.child_pre_probe = spi_child_pre_probe,
	.per_device_auto_alloc_size = sizeof(struct dm_spi_bus),
	.per_child_auto_alloc_size = sizeof(struct spi_slave),
	.per_child_platdata_auto_alloc_size =
			sizeof(struct dm_spi_slave_platdata),
	.child_post_bind = spi_child_post_bind,
};

UCLASS_DRIVER(spi_generic) = {
	.id		= UCLASS_SPI_GENERIC,
	.name		= "spi_generic",
};

U_BOOT_DRIVER(spi_generic_drv) = {
	.name		= "spi_generic_drv",
	.id		= UCLASS_SPI_GENERIC,
};
Commit	Line	Data
d7af6a48 SG	1	/*
	2	* Copyright (c) 2014 Google, Inc
	3	*
	4	* SPDX-License-Identifier: GPL-2.0+
	5	*/
	6
	7	#include <common.h>
	8	#include <dm.h>
	9	#include <errno.h>
	10	#include <fdtdec.h>
	11	#include <malloc.h>
	12	#include <spi.h>
	13	#include <dm/device-internal.h>
	14	#include <dm/uclass-internal.h>
d7af6a48 SG	15	#include <dm/lists.h>
	16	#include <dm/util.h>
	17
	18	DECLARE_GLOBAL_DATA_PTR;
	19
	20	static int spi_set_speed_mode(struct udevice *bus, int speed, int mode)
	21	{
	22	struct dm_spi_ops *ops;
	23	int ret;
	24
	25	ops = spi_get_ops(bus);
	26	if (ops->set_speed)
	27	ret = ops->set_speed(bus, speed);
	28	else
	29	ret = -EINVAL;
	30	if (ret) {
	31	printf("Cannot set speed (err=%d)\n", ret);
	32	return ret;
	33	}
	34
	35	if (ops->set_mode)
	36	ret = ops->set_mode(bus, mode);
	37	else
	38	ret = -EINVAL;
	39	if (ret) {
	40	printf("Cannot set mode (err=%d)\n", ret);
	41	return ret;
	42	}
	43
	44	return 0;
	45	}
	46
7a3eff4c	47	int dm_spi_claim_bus(struct udevice *dev)
d7af6a48	48	{
d7af6a48 SG	49	struct udevice *bus = dev->parent;
d7af6a48 SG	50	struct dm_spi_ops *ops = spi_get_ops(bus);
e564f054	51	struct dm_spi_bus *spi = dev_get_uclass_priv(bus);
7a3eff4c	52	struct spi_slave *slave = dev_get_parent_priv(dev);
d7af6a48 SG	53	int speed;
	54	int ret;
	55
	56	speed = slave->max_hz;
	57	if (spi->max_hz) {
	58	if (speed)
b4141195	59	speed = min(speed, (int)spi->max_hz);
d7af6a48 SG	60	else
	61	speed = spi->max_hz;
	62	}
	63	if (!speed)
	64	speed = 100000;
60e2809a SG	65	if (speed != slave->speed) {
	66	ret = spi_set_speed_mode(bus, speed, slave->mode);
	67	if (ret)
	68	return ret;
	69	slave->speed = speed;
	70	}
d7af6a48	71
9694b724	72	return ops->claim_bus ? ops->claim_bus(dev) : 0;
d7af6a48 SG	73	}
d7af6a48 SG	74
7a3eff4c	75	void dm_spi_release_bus(struct udevice *dev)
d7af6a48	76	{
d7af6a48 SG	77	struct udevice *bus = dev->parent;
	78	struct dm_spi_ops *ops = spi_get_ops(bus);
	79
	80	if (ops->release_bus)
9694b724	81	ops->release_bus(dev);
d7af6a48 SG	82	}
d7af6a48 SG	83
7a3eff4c PF	84	int dm_spi_xfer(struct udevice *dev, unsigned int bitlen,
7a3eff4c PF	85	const void dout, void din, unsigned long flags)
d7af6a48	86	{
d7af6a48 SG	87	struct udevice *bus = dev->parent;
	88
	89	if (bus->uclass->uc_drv->id != UCLASS_SPI)
	90	return -EOPNOTSUPP;
	91
	92	return spi_get_ops(bus)->xfer(dev, bitlen, dout, din, flags);
7a3eff4c PF	93	}
	94
	95	int spi_claim_bus(struct spi_slave *slave)
	96	{
	97	return dm_spi_claim_bus(slave->dev);
	98	}
	99
	100	void spi_release_bus(struct spi_slave *slave)
	101	{
	102	dm_spi_release_bus(slave->dev);
	103	}
	104
	105	int spi_xfer(struct spi_slave *slave, unsigned int bitlen,
	106	const void dout, void din, unsigned long flags)
	107	{
	108	return dm_spi_xfer(slave->dev, bitlen, dout, din, flags);
d7af6a48 SG	109	}
d7af6a48 SG	110
6f849c30	111	static int spi_child_post_bind(struct udevice *dev)
d7af6a48	112	{
d0cff03e	113	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
d7af6a48	114
d0cff03e SG	115	if (dev->of_offset == -1)
	116	return 0;
	117
	118	return spi_slave_ofdata_to_platdata(gd->fdt_blob, dev->of_offset, plat);
	119	}
	120
6f849c30	121	static int spi_post_probe(struct udevice *bus)
d0cff03e	122	{
e564f054	123	struct dm_spi_bus *spi = dev_get_uclass_priv(bus);
d0cff03e SG	124
d0cff03e SG	125	spi->max_hz = fdtdec_get_int(gd->fdt_blob, bus->of_offset,
d7af6a48 SG	126	"spi-max-frequency", 0);
d7af6a48 SG	127
281f1566 MS	128	#if defined(CONFIG_NEEDS_MANUAL_RELOC)
	129	struct dm_spi_ops *ops = spi_get_ops(bus);
	130
	131
	132	if (ops->claim_bus)
	133	ops->claim_bus += gd->reloc_off;
	134	if (ops->release_bus)
	135	ops->release_bus += gd->reloc_off;
	136	if (ops->set_wordlen)
	137	ops->set_wordlen += gd->reloc_off;
	138	if (ops->xfer)
	139	ops->xfer += gd->reloc_off;
	140	if (ops->set_speed)
	141	ops->set_speed += gd->reloc_off;
	142	if (ops->set_mode)
	143	ops->set_mode += gd->reloc_off;
	144	if (ops->cs_info)
	145	ops->cs_info += gd->reloc_off;
	146	#endif
	147
d7af6a48 SG	148	return 0;
	149	}
	150
6f849c30	151	static int spi_child_pre_probe(struct udevice *dev)
440714ee	152	{
d0cff03e	153	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
bcbe3d15	154	struct spi_slave *slave = dev_get_parent_priv(dev);
440714ee	155
d0cff03e SG	156	/*
	157	* This is needed because we pass struct spi_slave around the place
	158	* instead slave->dev (a struct udevice). So we have to have some
	159	* way to access the slave udevice given struct spi_slave. Once we
	160	* change the SPI API to use udevice instead of spi_slave, we can
	161	* drop this.
	162	*/
440714ee SG	163	slave->dev = dev;
440714ee SG	164
d0cff03e SG	165	slave->max_hz = plat->max_hz;
d0cff03e SG	166	slave->mode = plat->mode;
f8e2f92d	167	slave->mode_rx = plat->mode_rx;
674f3609	168	slave->wordlen = SPI_DEFAULT_WORDLEN;
d0cff03e	169
440714ee SG	170	return 0;
	171	}
	172
d7af6a48 SG	173	int spi_chip_select(struct udevice *dev)
d7af6a48 SG	174	{
d0cff03e	175	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
d7af6a48	176
d0cff03e	177	return plat ? plat->cs : -ENOENT;
d7af6a48 SG	178	}
d7af6a48 SG	179
ff56bba2	180	int spi_find_chip_select(struct udevice bus, int cs, struct udevice *devp)
d7af6a48 SG	181	{
	182	struct udevice *dev;
	183
	184	for (device_find_first_child(bus, &dev); dev;
	185	device_find_next_child(&dev)) {
d0cff03e	186	struct dm_spi_slave_platdata *plat;
d7af6a48	187
d0cff03e SG	188	plat = dev_get_parent_platdata(dev);
	189	debug("%s: plat=%p, cs=%d\n", __func__, plat, plat->cs);
	190	if (plat->cs == cs) {
d7af6a48 SG	191	*devp = dev;
	192	return 0;
	193	}
	194	}
	195
	196	return -ENODEV;
	197	}
	198
	199	int spi_cs_is_valid(unsigned int busnum, unsigned int cs)
	200	{
	201	struct spi_cs_info info;
	202	struct udevice *bus;
	203	int ret;
	204
	205	ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus);
	206	if (ret) {
	207	debug("%s: No bus %d\n", __func__, busnum);
	208	return ret;
	209	}
	210
	211	return spi_cs_info(bus, cs, &info);
	212	}
	213
	214	int spi_cs_info(struct udevice bus, uint cs, struct spi_cs_info info)
	215	{
	216	struct spi_cs_info local_info;
	217	struct dm_spi_ops *ops;
	218	int ret;
	219
	220	if (!info)
	221	info = &local_info;
	222
	223	/* If there is a device attached, return it */
	224	info->dev = NULL;
	225	ret = spi_find_chip_select(bus, cs, &info->dev);
	226	if (!ret)
	227	return 0;
	228
	229	/*
	230	* Otherwise ask the driver. For the moment we don't have CS info.
	231	* When we do we could provide the driver with a helper function
	232	* to figure out what chip selects are valid, or just handle the
	233	* request.
	234	*/
	235	ops = spi_get_ops(bus);
	236	if (ops->cs_info)
	237	return ops->cs_info(bus, cs, info);
	238
	239	/*
	240	* We could assume there is at least one valid chip select, but best
	241	* to be sure and return an error in this case. The driver didn't
	242	* care enough to tell us.
	243	*/
	244	return -ENODEV;
	245	}
	246
d7af6a48 SG	247	int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
	248	struct udevice **devp)
	249	{
	250	struct udevice bus, dev;
	251	int ret;
	252
	253	ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus);
	254	if (ret) {
	255	debug("%s: No bus %d\n", __func__, busnum);
	256	return ret;
	257	}
	258	ret = spi_find_chip_select(bus, cs, &dev);
	259	if (ret) {
	260	debug("%s: No cs %d\n", __func__, cs);
	261	return ret;
	262	}
	263	*busp = bus;
	264	*devp = dev;
	265
	266	return ret;
	267	}
	268
	269	int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
	270	const char drv_name, const char dev_name,
	271	struct udevice busp, struct spi_slave devp)
	272	{
	273	struct udevice bus, dev;
96907c0f	274	struct dm_spi_slave_platdata *plat;
d7af6a48 SG	275	bool created = false;
	276	int ret;
	277
	278	ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus);
	279	if (ret) {
	280	printf("Invalid bus %d (err=%d)\n", busnum, ret);
	281	return ret;
	282	}
	283	ret = spi_find_chip_select(bus, cs, &dev);
	284
	285	/*
	286	* If there is no such device, create one automatically. This means
	287	* that we don't need a device tree node or platform data for the
	288	* SPI flash chip - we will bind to the correct driver.
	289	*/
	290	if (ret == -ENODEV && drv_name) {
	291	debug("%s: Binding new device '%s', busnum=%d, cs=%d, driver=%s\n",
	292	__func__, dev_name, busnum, cs, drv_name);
6b18656a	293	ret = device_bind_driver(bus, drv_name, dev_name, &dev);
d7af6a48 SG	294	if (ret)
d7af6a48 SG	295	return ret;
d0cff03e SG	296	plat = dev_get_parent_platdata(dev);
	297	plat->cs = cs;
	298	plat->max_hz = speed;
	299	plat->mode = mode;
d7af6a48 SG	300	created = true;
	301	} else if (ret) {
	302	printf("Invalid chip select %d:%d (err=%d)\n", busnum, cs,
	303	ret);
	304	return ret;
	305	}
	306
	307	if (!device_active(dev)) {
d0cff03e	308	struct spi_slave *slave;
d7af6a48	309
d0cff03e	310	ret = device_probe(dev);
d7af6a48 SG	311	if (ret)
d7af6a48 SG	312	goto err;
bcbe3d15	313	slave = dev_get_parent_priv(dev);
d7af6a48	314	slave->dev = dev;
d7af6a48 SG	315	}
d7af6a48 SG	316
96907c0f V	317	plat = dev_get_parent_platdata(dev);
	318	if (!speed) {
	319	speed = plat->max_hz;
	320	mode = plat->mode;
	321	}
d7af6a48 SG	322	ret = spi_set_speed_mode(bus, speed, mode);
	323	if (ret)
	324	goto err;
	325
	326	*busp = bus;
bcbe3d15	327	*devp = dev_get_parent_priv(dev);
d7af6a48 SG	328	debug("%s: bus=%p, slave=%p\n", __func__, bus, *devp);
	329
	330	return 0;
	331
	332	err:
c8864d72	333	debug("%s: Error path, created=%d, device '%s'\n", __func__,
d0cff03e	334	created, dev->name);
d7af6a48 SG	335	if (created) {
	336	device_remove(dev);
	337	device_unbind(dev);
	338	}
	339
	340	return ret;
	341	}
	342
	343	/* Compatibility function - to be removed */
	344	struct spi_slave spi_setup_slave_fdt(const void blob, int node,
	345	int bus_node)
	346	{
	347	struct udevice bus, dev;
	348	int ret;
	349
	350	ret = uclass_get_device_by_of_offset(UCLASS_SPI, bus_node, &bus);
	351	if (ret)
	352	return NULL;
	353	ret = device_get_child_by_of_offset(bus, node, &dev);
	354	if (ret)
	355	return NULL;
bcbe3d15	356	return dev_get_parent_priv(dev);
d7af6a48 SG	357	}
	358
	359	/* Compatibility function - to be removed */
	360	struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs,
	361	unsigned int speed, unsigned int mode)
	362	{
	363	struct spi_slave *slave;
	364	struct udevice *dev;
	365	int ret;
	366
	367	ret = spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev,
	368	&slave);
	369	if (ret)
	370	return NULL;
	371
	372	return slave;
	373	}
	374
	375	void spi_free_slave(struct spi_slave *slave)
	376	{
	377	device_remove(slave->dev);
	378	slave->dev = NULL;
	379	}
	380
d0cff03e SG	381	int spi_slave_ofdata_to_platdata(const void *blob, int node,
d0cff03e SG	382	struct dm_spi_slave_platdata *plat)
d7af6a48	383	{
f8e2f92d M	384	int mode = 0, mode_rx = 0;
f8e2f92d M	385	int value;
d7af6a48	386
d0cff03e SG	387	plat->cs = fdtdec_get_int(blob, node, "reg", -1);
d0cff03e SG	388	plat->max_hz = fdtdec_get_int(blob, node, "spi-max-frequency", 0);
d7af6a48 SG	389	if (fdtdec_get_bool(blob, node, "spi-cpol"))
	390	mode \|= SPI_CPOL;
	391	if (fdtdec_get_bool(blob, node, "spi-cpha"))
	392	mode \|= SPI_CPHA;
	393	if (fdtdec_get_bool(blob, node, "spi-cs-high"))
	394	mode \|= SPI_CS_HIGH;
379b49d8 JT	395	if (fdtdec_get_bool(blob, node, "spi-3wire"))
379b49d8 JT	396	mode \|= SPI_3WIRE;
d7af6a48 SG	397	if (fdtdec_get_bool(blob, node, "spi-half-duplex"))
d7af6a48 SG	398	mode \|= SPI_PREAMBLE;
f8e2f92d M	399
	400	/* Device DUAL/QUAD mode */
	401	value = fdtdec_get_uint(blob, node, "spi-tx-bus-width", 1);
	402	switch (value) {
	403	case 1:
	404	break;
	405	case 2:
	406	mode \|= SPI_TX_DUAL;
	407	break;
	408	case 4:
	409	mode \|= SPI_TX_QUAD;
	410	break;
	411	default:
	412	error("spi-tx-bus-width %d not supported\n", value);
	413	break;
	414	}
	415
d0cff03e	416	plat->mode = mode;
d7af6a48	417
f8e2f92d M	418	value = fdtdec_get_uint(blob, node, "spi-rx-bus-width", 1);
	419	switch (value) {
	420	case 1:
	421	break;
	422	case 2:
	423	mode_rx \|= SPI_RX_DUAL;
	424	break;
	425	case 4:
	426	mode_rx \|= SPI_RX_QUAD;
	427	break;
	428	default:
	429	error("spi-rx-bus-width %d not supported\n", value);
	430	break;
	431	}
	432
	433	plat->mode_rx = mode_rx;
	434
d7af6a48 SG	435	return 0;
	436	}
	437
	438	UCLASS_DRIVER(spi) = {
	439	.id = UCLASS_SPI,
	440	.name = "spi",
9cc36a2b	441	.flags = DM_UC_FLAG_SEQ_ALIAS,
91195485	442	.post_bind = dm_scan_fdt_dev,
d7af6a48	443	.post_probe = spi_post_probe,
440714ee	444	.child_pre_probe = spi_child_pre_probe,
d7af6a48	445	.per_device_auto_alloc_size = sizeof(struct dm_spi_bus),
19a25f67	446	.per_child_auto_alloc_size = sizeof(struct spi_slave),
d0cff03e SG	447	.per_child_platdata_auto_alloc_size =
	448	sizeof(struct dm_spi_slave_platdata),
	449	.child_post_bind = spi_child_post_bind,
d7af6a48 SG	450	};
	451
	452	UCLASS_DRIVER(spi_generic) = {
	453	.id = UCLASS_SPI_GENERIC,
	454	.name = "spi_generic",
	455	};
	456
	457	U_BOOT_DRIVER(spi_generic_drv) = {
	458	.name = "spi_generic_drv",
	459	.id = UCLASS_SPI_GENERIC,
	460	};