[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 = dev_get_uclass_priv(bus);
	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 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(dev);
}

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 = dev_get_uclass_priv(bus);

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