[U-Boot] [PATCH 06/25] dm: spi: Add a uclass for SPI

[Daniel Schwierzeck <daniel.schwierzeck@gmail.com>]

Hi Simon,

some nitpicking

On 15.07.2014 02:56, Simon Glass wrote:
> Add a uclass which provides access to SPI buses and includes operations
> required by SPI.
> 
> For a time driver model will need to co-exist with the legacy SPI interface
> so some parts of the header file are changed depending on which is in use.
> The exports are adjusted also since some functions are not available with
> driver model.
> 
> Boards must define CONFIG_DM_SPI to use driver model for SPI.
> 
> Signed-off-by: Simon Glass <sjg@chromium.org>
> ---
> 
>  common/exports.c         |   4 +-
>  drivers/spi/Makefile     |   4 +
>  drivers/spi/spi-uclass.c | 253 +++++++++++++++++++++++++++++++++++++++++++++++
>  include/dm/uclass-id.h   |   1 +
>  include/spi.h            | 140 ++++++++++++++++++++++++++
>  5 files changed, 401 insertions(+), 1 deletion(-)
>  create mode 100644 drivers/spi/spi-uclass.c

...

> --- /dev/null
> +++ b/drivers/spi/spi-uclass.c
> @@ -0,0 +1,253 @@
> +/*
> + * Copyright (c) 2014 Google, Inc
> + *
> + * SPDX-License-Identifier:	GPL-2.0+
> + */
> +
> +#include <common.h>
> +#include <dm.h>
> +#include <errno.h>
> +#include <fdtdec.h>
> +#include <spi.h>
> +#include <dm/device-internal.h>
> +#include <dm/uclass-internal.h>
> +#include <dm/root.h>
> +#include <dm/lists.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);

ret = ops->set_speed(bus, speed);

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

redundant assignment

> +	if (ops->set_mode)
> +		ret = (*ops->set_mode)(bus, 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, 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)
> +		spi_get_ops(bus)->release_bus(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(bus, 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_post_probe(struct udevice *dev)
> +{
> +	struct dm_spi_bus *spi = dev->uclass_priv;
> +
> +	spi->max_hz = fdtdec_get_int(gd->fdt_blob, dev->of_offset,
> +				     "spi-max-frequency", 0);
> +
> +	return 0;
> +}
> +
> +int spi_bind_device(struct udevice *bus, int cs, const char *drv_name,
> +		    const char *dev_name, struct udevice **slavep)
> +{
> +	struct driver *drv;
> +	int ret;
> +
> +	drv = lists_driver_lookup_name(drv_name);
> +	if (!drv) {
> +		puts("Cannot find spi_flash_std driver\n");
> +		return -ENOENT;
> +	}
> +	ret = device_bind(bus, drv, dev_name, NULL, -1, slavep);
> +	if (ret) {
> +		printf("Cannot create device named '%s' (err=%d)\n",
> +		       dev_name, ret);
> +		return ret;
> +	}
> +	(*slavep)->req_seq = cs;
> +
> +	return 0;
> +}
> +
> +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)
> +		return ret;
> +	ret = device_find_child_by_seq(bus, cs, false, &dev);
> +	if (ret)
> +		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 **devp, struct spi_slave **slavep)
> +{
> +	struct udevice *bus, *dev;
> +	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 = device_get_child_by_seq(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) {
> +		ret = spi_bind_device(bus, cs, drv_name, dev_name, &dev);
> +		if (ret)
> +			return ret;
> +	}
> +	if (ret) {
> +		printf("Invalid chip select %d:%d (err=%d)\n", busnum, cs,
> +		       ret);
> +		return ret;
> +	}
> +
> +	ret = spi_set_speed_mode(bus, speed, mode);
> +	if (ret)
> +		return ret;
> +
> +	*devp = bus;
> +	*slavep = dev_get_parentdata(dev);
> +
> +	return 0;
> +}
> +
> +/* 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_ofdata_to_platdata(const void *blob, int node,
> +			   struct spi_slave *spi)
> +{
> +	int mode = 0;
> +
> +	spi->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;
> +	spi->mode = mode;
> +
> +	return 0;
> +}
> +
> +UCLASS_DRIVER(spi) = {
> +	.id		= UCLASS_SPI,
> +	.name		= "spi",
> +	.post_bind	= spi_post_bind,
> +	.post_probe	= spi_post_probe,
> +	.per_device_auto_alloc_size = sizeof(struct dm_spi_bus),
> +};


-- 
- Daniel