[deliverable/linux.git] / drivers / base / regmap / regmap-spi.c

/*
 * Register map access API - SPI support
 *
 * Copyright 2011 Wolfson Microelectronics plc
 *
 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/regmap.h>
#include <linux/spi/spi.h>
#include <linux/init.h>
#include <linux/module.h>

static int regmap_spi_write(void *context, const void *data, size_t count)
{
	struct device *dev = context;
	struct spi_device *spi = to_spi_device(dev);

	return spi_write(spi, data, count);
}

static int regmap_spi_gather_write(void *context,
				   const void *reg, size_t reg_len,
				   const void *val, size_t val_len)
{
	struct device *dev = context;
	struct spi_device *spi = to_spi_device(dev);
	struct spi_message m;
	struct spi_transfer t[2] = { { .tx_buf = reg, .len = reg_len, },
				     { .tx_buf = val, .len = val_len, }, };

	spi_message_init(&m);
	spi_message_add_tail(&t[0], &m);
	spi_message_add_tail(&t[1], &m);

	return spi_sync(spi, &m);
}

static int regmap_spi_read(void *context,
			   const void *reg, size_t reg_size,
			   void *val, size_t val_size)
{
	struct device *dev = context;
	struct spi_device *spi = to_spi_device(dev);

	return spi_write_then_read(spi, reg, reg_size, val, val_size);
}

static struct regmap_bus regmap_spi = {
	.write = regmap_spi_write,
	.gather_write = regmap_spi_gather_write,
	.read = regmap_spi_read,
	.read_flag_mask = 0x80,
};

/**
 * regmap_init_spi(): Initialise register map
 *
 * @spi: Device that will be interacted with
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.
 */
struct regmap *regmap_init_spi(struct spi_device *spi,
			       const struct regmap_config *config)
{
	return regmap_init(&spi->dev, &regmap_spi, &spi->dev, config);
}
EXPORT_SYMBOL_GPL(regmap_init_spi);

/**
 * devm_regmap_init_spi(): Initialise register map
 *
 * @spi: Device that will be interacted with
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap.  The map will be automatically freed by the
 * device management code.
 */
struct regmap *devm_regmap_init_spi(struct spi_device *spi,
				    const struct regmap_config *config)
{
	return devm_regmap_init(&spi->dev, &regmap_spi, &spi->dev, config);
}
EXPORT_SYMBOL_GPL(devm_regmap_init_spi);

MODULE_LICENSE("GPL");
Commit	Line	Data
a676f083 MB	1	/*
	2	* Register map access API - SPI support
	3	*
	4	* Copyright 2011 Wolfson Microelectronics plc
	5	*
	6	* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
	13	#include <linux/regmap.h>
	14	#include <linux/spi/spi.h>
	15	#include <linux/init.h>
b5ddbf46	16	#include <linux/module.h>
a676f083	17
0135bbcc	18	static int regmap_spi_write(void context, const void data, size_t count)
a676f083	19	{
0135bbcc	20	struct device *dev = context;
a676f083 MB	21	struct spi_device *spi = to_spi_device(dev);
	22
	23	return spi_write(spi, data, count);
	24	}
	25
0135bbcc	26	static int regmap_spi_gather_write(void *context,
a676f083 MB	27	const void *reg, size_t reg_len,
	28	const void *val, size_t val_len)
	29	{
0135bbcc	30	struct device *dev = context;
a676f083 MB	31	struct spi_device *spi = to_spi_device(dev);
	32	struct spi_message m;
	33	struct spi_transfer t[2] = { { .tx_buf = reg, .len = reg_len, },
	34	{ .tx_buf = val, .len = val_len, }, };
	35
	36	spi_message_init(&m);
	37	spi_message_add_tail(&t[0], &m);
	38	spi_message_add_tail(&t[1], &m);
	39
	40	return spi_sync(spi, &m);
	41	}
	42
0135bbcc	43	static int regmap_spi_read(void *context,
a676f083 MB	44	const void *reg, size_t reg_size,
	45	void *val, size_t val_size)
	46	{
0135bbcc	47	struct device *dev = context;
a676f083 MB	48	struct spi_device *spi = to_spi_device(dev);
	49
	50	return spi_write_then_read(spi, reg, reg_size, val, val_size);
	51	}
	52
	53	static struct regmap_bus regmap_spi = {
a676f083 MB	54	.write = regmap_spi_write,
	55	.gather_write = regmap_spi_gather_write,
	56	.read = regmap_spi_read,
a676f083 MB	57	.read_flag_mask = 0x80,
	58	};
	59
	60	/**
	61	* regmap_init_spi(): Initialise register map
	62	*
	63	* @spi: Device that will be interacted with
	64	* @config: Configuration for register map
	65	*
	66	* The return value will be an ERR_PTR() on error or a valid pointer to
	67	* a struct regmap.
	68	*/
	69	struct regmap regmap_init_spi(struct spi_device spi,
	70	const struct regmap_config *config)
	71	{
0135bbcc	72	return regmap_init(&spi->dev, &regmap_spi, &spi->dev, config);
a676f083 MB	73	}
a676f083 MB	74	EXPORT_SYMBOL_GPL(regmap_init_spi);
b33f9cbd	75
c0eb4676 MB	76	/**
	77	* devm_regmap_init_spi(): Initialise register map
	78	*
	79	* @spi: Device that will be interacted with
	80	* @config: Configuration for register map
	81	*
	82	* The return value will be an ERR_PTR() on error or a valid pointer
	83	* to a struct regmap. The map will be automatically freed by the
	84	* device management code.
	85	*/
	86	struct regmap devm_regmap_init_spi(struct spi_device spi,
	87	const struct regmap_config *config)
	88	{
0135bbcc	89	return devm_regmap_init(&spi->dev, &regmap_spi, &spi->dev, config);
c0eb4676 MB	90	}
	91	EXPORT_SYMBOL_GPL(devm_regmap_init_spi);
	92
b33f9cbd	93	MODULE_LICENSE("GPL");