[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 <fdtdec.h>
#include <malloc.h>
#include <spi.h>
#include <dm/device-internal.h>
#include <dm/uclass-internal.h>
#include <dm/root.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 spi_claim_bus(struct spi_slave *slave)
{
	struct udevice *dev = slave->dev;
	struct udevice *bus = dev->parent;
	struct dm_spi_ops *ops = spi_get_ops(bus);
	struct dm_spi_bus *spi = bus->uclass_priv;
	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;
	ret = spi_set_speed_mode(bus, speed, slave->mode);
	if (ret)
		return ret;

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

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

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

int spi_xfer(struct spi_slave *slave, unsigned int bitlen,
	     const void *dout, void *din, unsigned long flags)
{
	struct udevice *dev = slave->dev;
	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_post_bind(struct udevice *dev)
{
	/* Scan the bus for devices */
	return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
}

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

int spi_post_probe(struct udevice *bus)
{
	struct dm_spi_bus *spi = bus->uclass_priv;

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

	return 0;
}

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_parentdata(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;

	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;
	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) {
		struct dm_spi_slave_platdata *plat;

		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_parentdata(dev);
		slave->dev = dev;
	}

	ret = spi_set_speed_mode(bus, speed, mode);
	if (ret)
		goto err;

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

	return 0;

err:
	debug("%s: Error path, credted=%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_parentdata(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;

	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-half-duplex"))
		mode |= SPI_PREAMBLE;
	plat->mode = mode;

	return 0;
}

UCLASS_DRIVER(spi) = {
	.id		= UCLASS_SPI,
	.name		= "spi",
	.flags		= DM_UC_FLAG_SEQ_ALIAS,
	.post_bind	= spi_post_bind,
	.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>
	15	#include <dm/root.h>
	16	#include <dm/lists.h>
	17	#include <dm/util.h>
	18
	19	DECLARE_GLOBAL_DATA_PTR;
	20
	21	static int spi_set_speed_mode(struct udevice *bus, int speed, int mode)
	22	{
	23	struct dm_spi_ops *ops;
	24	int ret;
	25
	26	ops = spi_get_ops(bus);
	27	if (ops->set_speed)
	28	ret = ops->set_speed(bus, speed);
	29	else
	30	ret = -EINVAL;
	31	if (ret) {
	32	printf("Cannot set speed (err=%d)\n", ret);
	33	return ret;
	34	}
	35
	36	if (ops->set_mode)
	37	ret = ops->set_mode(bus, mode);
	38	else
	39	ret = -EINVAL;
	40	if (ret) {
	41	printf("Cannot set mode (err=%d)\n", ret);
	42	return ret;
	43	}
	44
	45	return 0;
	46	}
	47
	48	int spi_claim_bus(struct spi_slave *slave)
	49	{
	50	struct udevice *dev = slave->dev;
	51	struct udevice *bus = dev->parent;
	52	struct dm_spi_ops *ops = spi_get_ops(bus);
	53	struct dm_spi_bus *spi = bus->uclass_priv;
	54	int speed;
	55	int ret;
	56
	57	speed = slave->max_hz;
	58	if (spi->max_hz) {
	59	if (speed)
b4141195	60	speed = min(speed, (int)spi->max_hz);
d7af6a48 SG	61	else
	62	speed = spi->max_hz;
	63	}
	64	if (!speed)
	65	speed = 100000;
	66	ret = spi_set_speed_mode(bus, speed, slave->mode);
	67	if (ret)
	68	return ret;
	69
	70	return ops->claim_bus ? ops->claim_bus(bus) : 0;
	71	}
	72
	73	void spi_release_bus(struct spi_slave *slave)
	74	{
	75	struct udevice *dev = slave->dev;
	76	struct udevice *bus = dev->parent;
	77	struct dm_spi_ops *ops = spi_get_ops(bus);
	78
	79	if (ops->release_bus)
	80	ops->release_bus(bus);
	81	}
	82
	83	int spi_xfer(struct spi_slave *slave, unsigned int bitlen,
	84	const void dout, void din, unsigned long flags)
	85	{
	86	struct udevice *dev = slave->dev;
	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);
	93	}
	94
	95	int spi_post_bind(struct udevice *dev)
	96	{
	97	/* Scan the bus for devices */
	98	return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
	99	}
	100
d0cff03e	101	int spi_child_post_bind(struct udevice *dev)
d7af6a48	102	{
d0cff03e	103	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
d7af6a48	104
d0cff03e SG	105	if (dev->of_offset == -1)
	106	return 0;
	107
	108	return spi_slave_ofdata_to_platdata(gd->fdt_blob, dev->of_offset, plat);
	109	}
	110
	111	int spi_post_probe(struct udevice *bus)
	112	{
	113	struct dm_spi_bus *spi = bus->uclass_priv;
	114
	115	spi->max_hz = fdtdec_get_int(gd->fdt_blob, bus->of_offset,
d7af6a48 SG	116	"spi-max-frequency", 0);
	117
	118	return 0;
	119	}
	120
440714ee SG	121	int spi_child_pre_probe(struct udevice *dev)
440714ee SG	122	{
d0cff03e	123	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
440714ee SG	124	struct spi_slave *slave = dev_get_parentdata(dev);
440714ee SG	125
d0cff03e SG	126	/*
	127	* This is needed because we pass struct spi_slave around the place
	128	* instead slave->dev (a struct udevice). So we have to have some
	129	* way to access the slave udevice given struct spi_slave. Once we
	130	* change the SPI API to use udevice instead of spi_slave, we can
	131	* drop this.
	132	*/
440714ee SG	133	slave->dev = dev;
440714ee SG	134
d0cff03e SG	135	slave->max_hz = plat->max_hz;
	136	slave->mode = plat->mode;
	137
440714ee SG	138	return 0;
	139	}
	140
d7af6a48 SG	141	int spi_chip_select(struct udevice *dev)
d7af6a48 SG	142	{
d0cff03e	143	struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
d7af6a48	144
d0cff03e	145	return plat ? plat->cs : -ENOENT;
d7af6a48 SG	146	}
d7af6a48 SG	147
ff56bba2	148	int spi_find_chip_select(struct udevice bus, int cs, struct udevice *devp)
d7af6a48 SG	149	{
	150	struct udevice *dev;
	151
	152	for (device_find_first_child(bus, &dev); dev;
	153	device_find_next_child(&dev)) {
d0cff03e	154	struct dm_spi_slave_platdata *plat;
d7af6a48	155
d0cff03e SG	156	plat = dev_get_parent_platdata(dev);
	157	debug("%s: plat=%p, cs=%d\n", __func__, plat, plat->cs);
	158	if (plat->cs == cs) {
d7af6a48 SG	159	*devp = dev;
	160	return 0;
	161	}
	162	}
	163
	164	return -ENODEV;
	165	}
	166
	167	int spi_cs_is_valid(unsigned int busnum, unsigned int cs)
	168	{
	169	struct spi_cs_info info;
	170	struct udevice *bus;
	171	int ret;
	172
	173	ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus);
	174	if (ret) {
	175	debug("%s: No bus %d\n", __func__, busnum);
	176	return ret;
	177	}
	178
	179	return spi_cs_info(bus, cs, &info);
	180	}
	181
	182	int spi_cs_info(struct udevice bus, uint cs, struct spi_cs_info info)
	183	{
	184	struct spi_cs_info local_info;
	185	struct dm_spi_ops *ops;
	186	int ret;
	187
	188	if (!info)
	189	info = &local_info;
	190
	191	/* If there is a device attached, return it */
	192	info->dev = NULL;
	193	ret = spi_find_chip_select(bus, cs, &info->dev);
	194	if (!ret)
	195	return 0;
	196
	197	/*
	198	* Otherwise ask the driver. For the moment we don't have CS info.
	199	* When we do we could provide the driver with a helper function
	200	* to figure out what chip selects are valid, or just handle the
	201	* request.
	202	*/
	203	ops = spi_get_ops(bus);
	204	if (ops->cs_info)
	205	return ops->cs_info(bus, cs, info);
	206
	207	/*
	208	* We could assume there is at least one valid chip select, but best
	209	* to be sure and return an error in this case. The driver didn't
	210	* care enough to tell us.
	211	*/
	212	return -ENODEV;
	213	}
	214
d7af6a48 SG	215	int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
	216	struct udevice **devp)
	217	{
	218	struct udevice bus, dev;
	219	int ret;
	220
	221	ret = uclass_find_device_by_seq(UCLASS_SPI, busnum, false, &bus);
	222	if (ret) {
	223	debug("%s: No bus %d\n", __func__, busnum);
	224	return ret;
	225	}
	226	ret = spi_find_chip_select(bus, cs, &dev);
	227	if (ret) {
	228	debug("%s: No cs %d\n", __func__, cs);
	229	return ret;
	230	}
	231	*busp = bus;
	232	*devp = dev;
	233
	234	return ret;
	235	}
	236
	237	int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
	238	const char drv_name, const char dev_name,
	239	struct udevice busp, struct spi_slave devp)
	240	{
	241	struct udevice bus, dev;
d7af6a48 SG	242	bool created = false;
	243	int ret;
	244
	245	ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus);
	246	if (ret) {
	247	printf("Invalid bus %d (err=%d)\n", busnum, ret);
	248	return ret;
	249	}
	250	ret = spi_find_chip_select(bus, cs, &dev);
	251
	252	/*
	253	* If there is no such device, create one automatically. This means
	254	* that we don't need a device tree node or platform data for the
	255	* SPI flash chip - we will bind to the correct driver.
	256	*/
	257	if (ret == -ENODEV && drv_name) {
d0cff03e SG	258	struct dm_spi_slave_platdata *plat;
d0cff03e SG	259
d7af6a48 SG	260	debug("%s: Binding new device '%s', busnum=%d, cs=%d, driver=%s\n",
d7af6a48 SG	261	__func__, dev_name, busnum, cs, drv_name);
6b18656a	262	ret = device_bind_driver(bus, drv_name, dev_name, &dev);
d7af6a48 SG	263	if (ret)
d7af6a48 SG	264	return ret;
d0cff03e SG	265	plat = dev_get_parent_platdata(dev);
	266	plat->cs = cs;
	267	plat->max_hz = speed;
	268	plat->mode = mode;
d7af6a48 SG	269	created = true;
	270	} else if (ret) {
	271	printf("Invalid chip select %d:%d (err=%d)\n", busnum, cs,
	272	ret);
	273	return ret;
	274	}
	275
	276	if (!device_active(dev)) {
d0cff03e	277	struct spi_slave *slave;
d7af6a48	278
d0cff03e	279	ret = device_probe(dev);
d7af6a48 SG	280	if (ret)
d7af6a48 SG	281	goto err;
d0cff03e	282	slave = dev_get_parentdata(dev);
d7af6a48	283	slave->dev = dev;
d7af6a48 SG	284	}
	285
	286	ret = spi_set_speed_mode(bus, speed, mode);
	287	if (ret)
	288	goto err;
	289
	290	*busp = bus;
	291	*devp = dev_get_parentdata(dev);
	292	debug("%s: bus=%p, slave=%p\n", __func__, bus, *devp);
	293
	294	return 0;
	295
	296	err:
d0cff03e SG	297	debug("%s: Error path, credted=%d, device '%s'\n", __func__,
d0cff03e SG	298	created, dev->name);
d7af6a48 SG	299	if (created) {
	300	device_remove(dev);
	301	device_unbind(dev);
	302	}
	303
	304	return ret;
	305	}
	306
	307	/* Compatibility function - to be removed */
	308	struct spi_slave spi_setup_slave_fdt(const void blob, int node,
	309	int bus_node)
	310	{
	311	struct udevice bus, dev;
	312	int ret;
	313
	314	ret = uclass_get_device_by_of_offset(UCLASS_SPI, bus_node, &bus);
	315	if (ret)
	316	return NULL;
	317	ret = device_get_child_by_of_offset(bus, node, &dev);
	318	if (ret)
	319	return NULL;
	320	return dev_get_parentdata(dev);
	321	}
	322
	323	/* Compatibility function - to be removed */
	324	struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs,
	325	unsigned int speed, unsigned int mode)
	326	{
	327	struct spi_slave *slave;
	328	struct udevice *dev;
	329	int ret;
	330
	331	ret = spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev,
	332	&slave);
	333	if (ret)
	334	return NULL;
	335
	336	return slave;
	337	}
	338
	339	void spi_free_slave(struct spi_slave *slave)
	340	{
	341	device_remove(slave->dev);
	342	slave->dev = NULL;
	343	}
	344
d0cff03e SG	345	int spi_slave_ofdata_to_platdata(const void *blob, int node,
d0cff03e SG	346	struct dm_spi_slave_platdata *plat)
d7af6a48 SG	347	{
	348	int mode = 0;
	349
d0cff03e SG	350	plat->cs = fdtdec_get_int(blob, node, "reg", -1);
d0cff03e SG	351	plat->max_hz = fdtdec_get_int(blob, node, "spi-max-frequency", 0);
d7af6a48 SG	352	if (fdtdec_get_bool(blob, node, "spi-cpol"))
	353	mode \|= SPI_CPOL;
	354	if (fdtdec_get_bool(blob, node, "spi-cpha"))
	355	mode \|= SPI_CPHA;
	356	if (fdtdec_get_bool(blob, node, "spi-cs-high"))
	357	mode \|= SPI_CS_HIGH;
	358	if (fdtdec_get_bool(blob, node, "spi-half-duplex"))
	359	mode \|= SPI_PREAMBLE;
d0cff03e	360	plat->mode = mode;
d7af6a48 SG	361
	362	return 0;
	363	}
	364
	365	UCLASS_DRIVER(spi) = {
	366	.id = UCLASS_SPI,
	367	.name = "spi",
9cc36a2b	368	.flags = DM_UC_FLAG_SEQ_ALIAS,
d7af6a48 SG	369	.post_bind = spi_post_bind,
d7af6a48 SG	370	.post_probe = spi_post_probe,
440714ee	371	.child_pre_probe = spi_child_pre_probe,
d7af6a48	372	.per_device_auto_alloc_size = sizeof(struct dm_spi_bus),
19a25f67	373	.per_child_auto_alloc_size = sizeof(struct spi_slave),
d0cff03e SG	374	.per_child_platdata_auto_alloc_size =
	375	sizeof(struct dm_spi_slave_platdata),
	376	.child_post_bind = spi_child_post_bind,
d7af6a48 SG	377	};
	378
	379	UCLASS_DRIVER(spi_generic) = {
	380	.id = UCLASS_SPI_GENERIC,
	381	.name = "spi_generic",
	382	};
	383
	384	U_BOOT_DRIVER(spi_generic_drv) = {
	385	.name = "spi_generic_drv",
	386	.id = UCLASS_SPI_GENERIC,
	387	};