[J-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 <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;

	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) {
		int 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);
}

#if !CONFIG_IS_ENABLED(OF_PLATDATA)
static int spi_child_post_bind(struct udevice *dev)
{
	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);

	if (!dev_of_valid(dev))
		return 0;

	return spi_slave_ofdata_to_platdata(dev, plat);
}
#endif

static int spi_post_probe(struct udevice *bus)
{
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
	struct dm_spi_bus *spi = dev_get_uclass_priv(bus);

	spi->max_hz = dev_read_u32_default(bus, "spi-max-frequency", 0);
#endif
#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->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;

#if CONFIG_IS_ENABLED(OF_PLATDATA)
	ret = uclass_first_device_err(UCLASS_SPI, &bus);
#else
	ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus);
#endif
	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) {
			debug("%s: Unable to bind driver (ret=%d)\n", __func__,
			      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, DM_REMOVE_NORMAL);
		device_unbind(dev);
	}

	return ret;
}

/* 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, DM_REMOVE_NORMAL);
	slave->dev = NULL;
}

int spi_slave_ofdata_to_platdata(struct udevice *dev,
				 struct dm_spi_slave_platdata *plat)
{
	int mode = 0;
	int value;

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

	/* Device DUAL/QUAD mode */
	value = dev_read_u32_default(dev, "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:
		warn_non_spl("spi-tx-bus-width %d not supported\n", value);
		break;
	}

	value = dev_read_u32_default(dev, "spi-rx-bus-width", 1);
	switch (value) {
	case 1:
		break;
	case 2:
		mode |= SPI_RX_DUAL;
		break;
	case 4:
		mode |= SPI_RX_QUAD;
		break;
	default:
		warn_non_spl("spi-rx-bus-width %d not supported\n", value);
		break;
	}

	plat->mode = mode;

	return 0;
}

UCLASS_DRIVER(spi) = {
	.id		= UCLASS_SPI,
	.name		= "spi",
	.flags		= DM_UC_FLAG_SEQ_ALIAS,
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
	.post_bind	= dm_scan_fdt_dev,
#endif
	.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),
#if !CONFIG_IS_ENABLED(OF_PLATDATA)
	.child_post_bind = spi_child_post_bind,
#endif
};

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