[people/ms/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;
	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);
}

#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_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, 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 SG	52	int speed;
	53	int ret;
	54
	55	speed = slave->max_hz;
	56	if (spi->max_hz) {
	57	if (speed)
b4141195	58	speed = min(speed, (int)spi->max_hz);
d7af6a48 SG	59	else
	60	speed = spi->max_hz;
	61	}
	62	if (!speed)
	63	speed = 100000;
60e2809a SG	64	if (speed != slave->speed) {
	65	ret = spi_set_speed_mode(bus, speed, slave->mode);
	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
	132
	133	if (ops->claim_bus)
	134	ops->claim_bus += gd->reloc_off;
	135	if (ops->release_bus)
	136	ops->release_bus += gd->reloc_off;
	137	if (ops->set_wordlen)
	138	ops->set_wordlen += gd->reloc_off;
	139	if (ops->xfer)
	140	ops->xfer += gd->reloc_off;
	141	if (ops->set_speed)
	142	ops->set_speed += gd->reloc_off;
	143	if (ops->set_mode)
	144	ops->set_mode += gd->reloc_off;
	145	if (ops->cs_info)
	146	ops->cs_info += gd->reloc_off;
	147	#endif
	148
d7af6a48 SG	149	return 0;
	150	}
	151
6f849c30	152	static int spi_child_pre_probe(struct udevice *dev)
440714ee	153	{
d0cff03e	154	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
bcbe3d15	155	struct spi_slave *slave = dev_get_parent_priv(dev);
440714ee	156
d0cff03e SG	157	/*
	158	* This is needed because we pass struct spi_slave around the place
	159	* instead slave->dev (a struct udevice). So we have to have some
	160	* way to access the slave udevice given struct spi_slave. Once we
	161	* change the SPI API to use udevice instead of spi_slave, we can
	162	* drop this.
	163	*/
440714ee SG	164	slave->dev = dev;
440714ee SG	165
d0cff03e SG	166	slave->max_hz = plat->max_hz;
d0cff03e SG	167	slave->mode = plat->mode;
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
71634f28 SG	278	#if CONFIG_IS_ENABLED(OF_PLATDATA)
	279	ret = uclass_first_device_err(UCLASS_SPI, &bus);
	280	#else
d7af6a48	281	ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus);
71634f28	282	#endif
d7af6a48 SG	283	if (ret) {
	284	printf("Invalid bus %d (err=%d)\n", busnum, ret);
	285	return ret;
	286	}
	287	ret = spi_find_chip_select(bus, cs, &dev);
	288
	289	/*
	290	* If there is no such device, create one automatically. This means
	291	* that we don't need a device tree node or platform data for the
	292	* SPI flash chip - we will bind to the correct driver.
	293	*/
	294	if (ret == -ENODEV && drv_name) {
	295	debug("%s: Binding new device '%s', busnum=%d, cs=%d, driver=%s\n",
	296	__func__, dev_name, busnum, cs, drv_name);
6b18656a	297	ret = device_bind_driver(bus, drv_name, dev_name, &dev);
28f98858 SG	298	if (ret) {
	299	debug("%s: Unable to bind driver (ret=%d)\n", __func__,
	300	ret);
d7af6a48	301	return ret;
28f98858	302	}
d0cff03e SG	303	plat = dev_get_parent_platdata(dev);
	304	plat->cs = cs;
	305	plat->max_hz = speed;
	306	plat->mode = mode;
d7af6a48 SG	307	created = true;
	308	} else if (ret) {
	309	printf("Invalid chip select %d:%d (err=%d)\n", busnum, cs,
	310	ret);
	311	return ret;
	312	}
	313
	314	if (!device_active(dev)) {
d0cff03e	315	struct spi_slave *slave;
d7af6a48	316
d0cff03e	317	ret = device_probe(dev);
d7af6a48 SG	318	if (ret)
d7af6a48 SG	319	goto err;
bcbe3d15	320	slave = dev_get_parent_priv(dev);
d7af6a48	321	slave->dev = dev;
d7af6a48 SG	322	}
d7af6a48 SG	323
96907c0f V	324	plat = dev_get_parent_platdata(dev);
	325	if (!speed) {
	326	speed = plat->max_hz;
	327	mode = plat->mode;
	328	}
d7af6a48 SG	329	ret = spi_set_speed_mode(bus, speed, mode);
	330	if (ret)
	331	goto err;
	332
	333	*busp = bus;
bcbe3d15	334	*devp = dev_get_parent_priv(dev);
d7af6a48 SG	335	debug("%s: bus=%p, slave=%p\n", __func__, bus, *devp);
	336
	337	return 0;
	338
	339	err:
c8864d72	340	debug("%s: Error path, created=%d, device '%s'\n", __func__,
d0cff03e	341	created, dev->name);
d7af6a48	342	if (created) {
706865af	343	device_remove(dev, DM_REMOVE_NORMAL);
d7af6a48 SG	344	device_unbind(dev);
	345	}
	346
	347	return ret;
	348	}
	349
	350	/* Compatibility function - to be removed */
	351	struct spi_slave spi_setup_slave_fdt(const void blob, int node,
	352	int bus_node)
	353	{
	354	struct udevice bus, dev;
	355	int ret;
	356
	357	ret = uclass_get_device_by_of_offset(UCLASS_SPI, bus_node, &bus);
	358	if (ret)
	359	return NULL;
	360	ret = device_get_child_by_of_offset(bus, node, &dev);
	361	if (ret)
	362	return NULL;
bcbe3d15	363	return dev_get_parent_priv(dev);
d7af6a48 SG	364	}
	365
	366	/* Compatibility function - to be removed */
	367	struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs,
	368	unsigned int speed, unsigned int mode)
	369	{
	370	struct spi_slave *slave;
	371	struct udevice *dev;
	372	int ret;
	373
	374	ret = spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev,
279e26f5	375	&slave);
d7af6a48 SG	376	if (ret)
	377	return NULL;
	378
	379	return slave;
	380	}
	381
	382	void spi_free_slave(struct spi_slave *slave)
	383	{
706865af	384	device_remove(slave->dev, DM_REMOVE_NORMAL);
d7af6a48 SG	385	slave->dev = NULL;
	386	}
	387
279e26f5	388	int spi_slave_ofdata_to_platdata(struct udevice *dev,
d0cff03e	389	struct dm_spi_slave_platdata *plat)
d7af6a48	390	{
08fe9c29	391	int mode = 0;
f8e2f92d	392	int value;
d7af6a48	393
279e26f5 SG	394	plat->cs = dev_read_u32_default(dev, "reg", -1);
	395	plat->max_hz = dev_read_u32_default(dev, "spi-max-frequency", 0);
	396	if (dev_read_bool(dev, "spi-cpol"))
d7af6a48	397	mode \|= SPI_CPOL;
279e26f5	398	if (dev_read_bool(dev, "spi-cpha"))
d7af6a48	399	mode \|= SPI_CPHA;
279e26f5	400	if (dev_read_bool(dev, "spi-cs-high"))
d7af6a48	401	mode \|= SPI_CS_HIGH;
279e26f5	402	if (dev_read_bool(dev, "spi-3wire"))
379b49d8	403	mode \|= SPI_3WIRE;
279e26f5	404	if (dev_read_bool(dev, "spi-half-duplex"))
d7af6a48	405	mode \|= SPI_PREAMBLE;
f8e2f92d M	406
f8e2f92d M	407	/* Device DUAL/QUAD mode */
279e26f5	408	value = dev_read_u32_default(dev, "spi-tx-bus-width", 1);
f8e2f92d M	409	switch (value) {
	410	case 1:
	411	break;
	412	case 2:
	413	mode \|= SPI_TX_DUAL;
	414	break;
	415	case 4:
	416	mode \|= SPI_TX_QUAD;
	417	break;
	418	default:
1b7c28f5	419	warn_non_spl("spi-tx-bus-width %d not supported\n", value);
f8e2f92d M	420	break;
	421	}
	422
279e26f5	423	value = dev_read_u32_default(dev, "spi-rx-bus-width", 1);
f8e2f92d M	424	switch (value) {
	425	case 1:
	426	break;
	427	case 2:
08fe9c29	428	mode \|= SPI_RX_DUAL;
f8e2f92d M	429	break;
f8e2f92d M	430	case 4:
08fe9c29	431	mode \|= SPI_RX_QUAD;
f8e2f92d M	432	break;
f8e2f92d M	433	default:
1b7c28f5	434	warn_non_spl("spi-rx-bus-width %d not supported\n", value);
f8e2f92d M	435	break;
	436	}
	437
08fe9c29	438	plat->mode = mode;
f8e2f92d	439
d7af6a48 SG	440	return 0;
	441	}
	442
	443	UCLASS_DRIVER(spi) = {
	444	.id = UCLASS_SPI,
	445	.name = "spi",
9cc36a2b	446	.flags = DM_UC_FLAG_SEQ_ALIAS,
71634f28	447	#if !CONFIG_IS_ENABLED(OF_PLATDATA)
91195485	448	.post_bind = dm_scan_fdt_dev,
71634f28	449	#endif
d7af6a48	450	.post_probe = spi_post_probe,
440714ee	451	.child_pre_probe = spi_child_pre_probe,
d7af6a48	452	.per_device_auto_alloc_size = sizeof(struct dm_spi_bus),
19a25f67	453	.per_child_auto_alloc_size = sizeof(struct spi_slave),
d0cff03e SG	454	.per_child_platdata_auto_alloc_size =
d0cff03e SG	455	sizeof(struct dm_spi_slave_platdata),
71634f28	456	#if !CONFIG_IS_ENABLED(OF_PLATDATA)
d0cff03e	457	.child_post_bind = spi_child_post_bind,
71634f28	458	#endif
d7af6a48 SG	459	};
	460
	461	UCLASS_DRIVER(spi_generic) = {
	462	.id = UCLASS_SPI_GENERIC,
	463	.name = "spi_generic",
	464	};
	465
	466	U_BOOT_DRIVER(spi_generic_drv) = {
	467	.name = "spi_generic_drv",
	468	.id = UCLASS_SPI_GENERIC,
	469	};