regmap: spi: Support asynchronous I/O for SPI

#include <linux/init.h>

#include <linux/module.h>

#include "internal.h"

struct regmap_async_spi {

	struct regmap_async core;

	struct spi_message m;

	struct spi_transfer t[2];

};

static void regmap_spi_complete(void *data)

{

	struct regmap_async_spi *async = data;

	regmap_async_complete_cb(&async->core, async->m.status);

}

static int regmap_spi_write(void *context, const void *data, size_t count)

{

	struct device *dev = context;

	return spi_sync(spi, &m);

}

static int regmap_spi_async_write(void *context,

				  const void *reg, size_t reg_len,

				  const void *val, size_t val_len,

				  struct regmap_async *a)

{

	struct regmap_async_spi *async = container_of(a,

						      struct regmap_async_spi,

						      core);

	struct device *dev = context;

	struct spi_device *spi = to_spi_device(dev);

	async->t[0].tx_buf = reg;

	async->t[0].len = reg_len;

	async->t[1].tx_buf = val;

	async->t[1].len = val_len;

	spi_message_init(&async->m);

	spi_message_add_tail(&async->t[0], &async->m);

	spi_message_add_tail(&async->t[1], &async->m);

	async->m.complete = regmap_spi_complete;

	async->m.context = async;

	return spi_async(spi, &async->m);

}

static struct regmap_async *regmap_spi_async_alloc(void)

{

	struct regmap_async_spi *async_spi;

	async_spi = kzalloc(sizeof(*async_spi), GFP_KERNEL);

	return &async_spi->core;

}

static int regmap_spi_read(void *context,

			   const void *reg, size_t reg_size,

			   void *val, size_t val_size)

static struct regmap_bus regmap_spi = {

	.write = regmap_spi_write,

	.gather_write = regmap_spi_gather_write,

	.async_write = regmap_spi_async_write,

	.async_alloc = regmap_spi_async_alloc,

	.read = regmap_spi_read,

	.read_flag_mask = 0x80,

};