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

/*
 * Register map access API
 *
 * 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/slab.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/err.h>

#include <linux/regmap.h>

struct regmap;

struct regmap_format {
	size_t buf_size;
	size_t reg_bytes;
	size_t val_bytes;
	void (*format_write)(struct regmap *map,
			     unsigned int reg, unsigned int val);
	void (*format_reg)(void *buf, unsigned int reg);
	void (*format_val)(void *buf, unsigned int val);
	unsigned int (*parse_val)(void *buf);
};

struct regmap {
	struct mutex lock;

	struct device *dev; /* Device we do I/O on */
	void *work_buf;     /* Scratch buffer used to format I/O */
	struct regmap_format format;  /* Buffer format */
	const struct regmap_bus *bus;
};

static void regmap_format_4_12_write(struct regmap *map,
				     unsigned int reg, unsigned int val)
{
	__be16 *out = map->work_buf;
	*out = cpu_to_be16((reg << 12) | val);
}

static void regmap_format_7_9_write(struct regmap *map,
				    unsigned int reg, unsigned int val)
{
	__be16 *out = map->work_buf;
	*out = cpu_to_be16((reg << 9) | val);
}

static void regmap_format_8(void *buf, unsigned int val)
{
	u8 *b = buf;

	b[0] = val;
}

static void regmap_format_16(void *buf, unsigned int val)
{
	__be16 *b = buf;

	b[0] = cpu_to_be16(val);
}

static unsigned int regmap_parse_8(void *buf)
{
	u8 *b = buf;

	return b[0];
}

static unsigned int regmap_parse_16(void *buf)
{
	__be16 *b = buf;

	b[0] = be16_to_cpu(b[0]);

	return b[0];
}

/**
 * regmap_init(): Initialise register map
 *
 * @dev: Device that will be interacted with
 * @bus: Bus-specific callbacks to use with device
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.  This function should generally not be called
 * directly, it should be called by bus-specific init functions.
 */
struct regmap *regmap_init(struct device *dev,
			   const struct regmap_bus *bus,
			   const struct regmap_config *config)
{
	struct regmap *map;
	int ret = -EINVAL;

	if (!bus || !config)
		return NULL;

	map = kzalloc(sizeof(*map), GFP_KERNEL);
	if (map == NULL) {
		ret = -ENOMEM;
		goto err;
	}

	mutex_init(&map->lock);
	map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
	map->format.reg_bytes = config->reg_bits / 8;
	map->format.val_bytes = config->val_bits / 8;
	map->dev = dev;
	map->bus = bus;

	switch (config->reg_bits) {
	case 4:
		switch (config->val_bits) {
		case 12:
			map->format.format_write = regmap_format_4_12_write;
			break;
		default:
			goto err_map;
		}
		break;

	case 7:
		switch (config->val_bits) {
		case 9:
			map->format.format_write = regmap_format_7_9_write;
			break;
		default:
			goto err_map;
		}
		break;

	case 8:
		map->format.format_reg = regmap_format_8;
		break;

	case 16:
		map->format.format_reg = regmap_format_16;
		break;

	default:
		goto err_map;
	}

	switch (config->val_bits) {
	case 8:
		map->format.format_val = regmap_format_8;
		map->format.parse_val = regmap_parse_8;
		break;
	case 16:
		map->format.format_val = regmap_format_16;
		map->format.parse_val = regmap_parse_16;
		break;
	}

	if (!map->format.format_write &&
	    !(map->format.format_reg && map->format.format_val))
		goto err_map;

	map->work_buf = kmalloc(map->format.buf_size, GFP_KERNEL);
	if (map->work_buf == NULL) {
		ret = -ENOMEM;
		goto err_bus;
	}

	return map;

err_bus:
	module_put(map->bus->owner);
err_map:
	kfree(map);
err:
	return ERR_PTR(ret);
}
EXPORT_SYMBOL_GPL(regmap_init);

/**
 * regmap_exit(): Free a previously allocated register map
 */
void regmap_exit(struct regmap *map)
{
	kfree(map->work_buf);
	module_put(map->bus->owner);
	kfree(map);
}
EXPORT_SYMBOL_GPL(regmap_exit);

static int _regmap_raw_write(struct regmap *map, unsigned int reg,
			     const void *val, size_t val_len)
{
	void *buf;
	int ret = -ENOTSUPP;
	size_t len;

	map->format.format_reg(map->work_buf, reg);

	/* Try to do a gather write if we can */
	if (map->bus->gather_write)
		ret = map->bus->gather_write(map->dev, map->work_buf,
					     map->format.reg_bytes,
					     val, val_len);

	/* Otherwise fall back on linearising by hand. */
	if (ret == -ENOTSUPP) {
		len = map->format.reg_bytes + val_len;
		buf = kmalloc(len, GFP_KERNEL);
		if (!buf)
			return -ENOMEM;

		memcpy(buf, map->work_buf, map->format.reg_bytes);
		memcpy(buf + map->format.reg_bytes, val, val_len);
		ret = map->bus->write(map->dev, buf, len);

		kfree(buf);
	}

	return ret;
}

static int _regmap_write(struct regmap *map, unsigned int reg,
			 unsigned int val)
{
	BUG_ON(!map->format.format_write && !map->format.format_val);

	if (map->format.format_write) {
		map->format.format_write(map, reg, val);

		return map->bus->write(map->dev, map->work_buf,
				       map->format.buf_size);
	} else {
		map->format.format_val(map->work_buf + map->format.reg_bytes,
				       val);
		return _regmap_raw_write(map, reg,
					 map->work_buf + map->format.reg_bytes,
					 map->format.val_bytes);
	}
}

/**
 * regmap_write(): Write a value to a single register
 *
 * @map: Register map to write to
 * @reg: Register to write to
 * @val: Value to be written
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
{
	int ret;

	mutex_lock(&map->lock);

	ret = _regmap_write(map, reg, val);

	mutex_unlock(&map->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_write);

/**
 * regmap_raw_write(): Write raw values to one or more registers
 *
 * @map: Register map to write to
 * @reg: Initial register to write to
 * @val: Block of data to be written, laid out for direct transmission to the
 *       device
 * @val_len: Length of data pointed to by val.
 *
 * This function is intended to be used for things like firmware
 * download where a large block of data needs to be transferred to the
 * device.  No formatting will be done on the data provided.
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_raw_write(struct regmap *map, unsigned int reg,
		     const void *val, size_t val_len)
{
	int ret;

	mutex_lock(&map->lock);

	ret = _regmap_raw_write(map, reg, val, val_len);

	mutex_unlock(&map->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_raw_write);

static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
			    unsigned int val_len)
{
	u8 *u8 = map->work_buf;
	int ret;

	map->format.format_reg(map->work_buf, reg);

	/*
	 * Some buses flag reads by setting the high bits in the
	 * register addresss; since it's always the high bits for all
	 * current formats we can do this here rather than in
	 * formatting.  This may break if we get interesting formats.
	 */
	if (map->bus->read_flag_mask)
		u8[0] |= map->bus->read_flag_mask;

	ret = map->bus->read(map->dev, map->work_buf, map->format.reg_bytes,
			     val, map->format.val_bytes);
	if (ret != 0)
		return ret;

	return 0;
}

static int _regmap_read(struct regmap *map, unsigned int reg,
			unsigned int *val)
{
	int ret;

	if (!map->format.parse_val)
		return -EINVAL;

	ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
	if (ret == 0)
		*val = map->format.parse_val(map->work_buf);

	return ret;
}

/**
 * regmap_read(): Read a value from a single register
 *
 * @map: Register map to write to
 * @reg: Register to be read from
 * @val: Pointer to store read value
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
{
	int ret;

	mutex_lock(&map->lock);

	ret = _regmap_read(map, reg, val);

	mutex_unlock(&map->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_read);

/**
 * regmap_raw_read(): Read raw data from the device
 *
 * @map: Register map to write to
 * @reg: First register to be read from
 * @val: Pointer to store read value
 * @val_len: Size of data to read
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
		    size_t val_len)
{
	int ret;

	mutex_lock(&map->lock);

	ret = _regmap_raw_read(map, reg, val, val_len);

	mutex_unlock(&map->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_raw_read);

/**
 * regmap_bulk_read(): Read multiple registers from the device
 *
 * @map: Register map to write to
 * @reg: First register to be read from
 * @val: Pointer to store read value, in native register size for device
 * @val_count: Number of registers to read
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
		     size_t val_count)
{
	int ret, i;
	size_t val_bytes = map->format.val_bytes;

	if (!map->format.parse_val)
		return -EINVAL;

	ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
	if (ret != 0)
		return ret;

	for (i = 0; i < val_count * val_bytes; i += val_bytes)
		map->format.parse_val(val + i);

	return 0;
}
EXPORT_SYMBOL_GPL(regmap_bulk_read);

/**
 * remap_update_bits: Perform a read/modify/write cycle on the register map
 *
 * @map: Register map to update
 * @reg: Register to update
 * @mask: Bitmask to change
 * @val: New value for bitmask
 *
 * Returns zero for success, a negative number on error.
 */
int regmap_update_bits(struct regmap *map, unsigned int reg,
		       unsigned int mask, unsigned int val)
{
	int ret;
	unsigned int tmp;

	mutex_lock(&map->lock);

	ret = _regmap_read(map, reg, &tmp);
	if (ret != 0)
		goto out;

	tmp &= ~mask;
	tmp |= val & mask;

	ret = _regmap_write(map, reg, tmp);

out:
	mutex_unlock(&map->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_update_bits);
Commit	Line	Data
b83a313b MB	1	/*
	2	* Register map access API
	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/slab.h>
	14	#include <linux/module.h>
	15	#include <linux/mutex.h>
	16	#include <linux/err.h>
	17
	18	#include <linux/regmap.h>
	19
	20	struct regmap;
	21
	22	struct regmap_format {
	23	size_t buf_size;
	24	size_t reg_bytes;
	25	size_t val_bytes;
	26	void (format_write)(struct regmap map,
	27	unsigned int reg, unsigned int val);
	28	void (format_reg)(void buf, unsigned int reg);
	29	void (format_val)(void buf, unsigned int val);
	30	unsigned int (parse_val)(void buf);
	31	};
	32
	33	struct regmap {
	34	struct mutex lock;
	35
	36	struct device dev; / Device we do I/O on */
	37	void work_buf; / Scratch buffer used to format I/O */
	38	struct regmap_format format; /* Buffer format */
	39	const struct regmap_bus *bus;
	40	};
	41
	42	static void regmap_format_4_12_write(struct regmap *map,
	43	unsigned int reg, unsigned int val)
	44	{
	45	__be16 *out = map->work_buf;
	46	*out = cpu_to_be16((reg << 12) \| val);
	47	}
	48
	49	static void regmap_format_7_9_write(struct regmap *map,
	50	unsigned int reg, unsigned int val)
	51	{
	52	__be16 *out = map->work_buf;
	53	*out = cpu_to_be16((reg << 9) \| val);
	54	}
	55
	56	static void regmap_format_8(void *buf, unsigned int val)
	57	{
	58	u8 *b = buf;
	59
	60	b[0] = val;
	61	}
	62
	63	static void regmap_format_16(void *buf, unsigned int val)
	64	{
65	__be16 *b = buf;
66
67	b[0] = cpu_to_be16(val);
68	}
69
70	static unsigned int regmap_parse_8(void *buf)
71	{
72	u8 *b = buf;
73
74	return b[0];
75	}
76
77	static unsigned int regmap_parse_16(void *buf)
78	{
79	__be16 *b = buf;
80
81	b[0] = be16_to_cpu(b[0]);
82
83	return b[0];
84	}
85
86	/**
87	* regmap_init(): Initialise register map
88	*
89	* @dev: Device that will be interacted with
90	* @bus: Bus-specific callbacks to use with device
91	* @config: Configuration for register map
92	*
93	* The return value will be an ERR_PTR() on error or a valid pointer to
94	* a struct regmap. This function should generally not be called
95	* directly, it should be called by bus-specific init functions.
96	*/
97	struct regmap regmap_init(struct device dev,
98	const struct regmap_bus *bus,
99	const struct regmap_config *config)
100	{
101	struct regmap *map;
102	int ret = -EINVAL;
103
104	if (!bus \|\| !config)
105	return NULL;
106
107	map = kzalloc(sizeof(*map), GFP_KERNEL);
108	if (map == NULL) {
109	ret = -ENOMEM;
110	goto err;
111	}
112
113	mutex_init(&map->lock);
114	map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
115	map->format.reg_bytes = config->reg_bits / 8;
116	map->format.val_bytes = config->val_bits / 8;
117	map->dev = dev;
118	map->bus = bus;
119
120	switch (config->reg_bits) {
121	case 4:
122	switch (config->val_bits) {
123	case 12:
124	map->format.format_write = regmap_format_4_12_write;
125	break;
126	default:
127	goto err_map;
128	}
129	break;
130
131	case 7:
132	switch (config->val_bits) {
133	case 9:
134	map->format.format_write = regmap_format_7_9_write;
135	break;
136	default:
137	goto err_map;
138	}
139	break;
140
141	case 8:
142	map->format.format_reg = regmap_format_8;
143	break;
144
145	case 16:
146	map->format.format_reg = regmap_format_16;
147	break;
148
149	default:
150	goto err_map;
151	}
152
153	switch (config->val_bits) {
154	case 8:
155	map->format.format_val = regmap_format_8;
156	map->format.parse_val = regmap_parse_8;
157	break;
158	case 16:
159	map->format.format_val = regmap_format_16;
160	map->format.parse_val = regmap_parse_16;
161	break;
162	}
163
164	if (!map->format.format_write &&
165	!(map->format.format_reg && map->format.format_val))
166	goto err_map;
167
168	map->work_buf = kmalloc(map->format.buf_size, GFP_KERNEL);
169	if (map->work_buf == NULL) {
170	ret = -ENOMEM;
171	goto err_bus;
172	}
173
174	return map;
175
176	err_bus:
177	module_put(map->bus->owner);
178	err_map:
179	kfree(map);
180	err:
181	return ERR_PTR(ret);
182	}
183	EXPORT_SYMBOL_GPL(regmap_init);
184
185	/**
186	* regmap_exit(): Free a previously allocated register map
187	*/
188	void regmap_exit(struct regmap *map)
189	{
190	kfree(map->work_buf);
191	module_put(map->bus->owner);
192	kfree(map);
193	}
194	EXPORT_SYMBOL_GPL(regmap_exit);
195
196	static int _regmap_raw_write(struct regmap *map, unsigned int reg,
197	const void *val, size_t val_len)
198	{
199	void *buf;
200	int ret = -ENOTSUPP;
201	size_t len;
202
203	map->format.format_reg(map->work_buf, reg);
204
205	/* Try to do a gather write if we can */
206	if (map->bus->gather_write)
207	ret = map->bus->gather_write(map->dev, map->work_buf,
208	map->format.reg_bytes,
209	val, val_len);
210
211	/* Otherwise fall back on linearising by hand. */
212	if (ret == -ENOTSUPP) {
213	len = map->format.reg_bytes + val_len;
214	buf = kmalloc(len, GFP_KERNEL);
215	if (!buf)
216	return -ENOMEM;
217
218	memcpy(buf, map->work_buf, map->format.reg_bytes);
219	memcpy(buf + map->format.reg_bytes, val, val_len);
220	ret = map->bus->write(map->dev, buf, len);
221
222	kfree(buf);
223	}
224
225	return ret;
226	}
227
228	static int _regmap_write(struct regmap *map, unsigned int reg,
229	unsigned int val)
230	{
231	BUG_ON(!map->format.format_write && !map->format.format_val);
232
233	if (map->format.format_write) {
234	map->format.format_write(map, reg, val);
235
236	return map->bus->write(map->dev, map->work_buf,
237	map->format.buf_size);
238	} else {
239	map->format.format_val(map->work_buf + map->format.reg_bytes,
240	val);
241	return _regmap_raw_write(map, reg,
242	map->work_buf + map->format.reg_bytes,
243	map->format.val_bytes);
244	}
245	}
246
247	/**
248	* regmap_write(): Write a value to a single register
249	*
250	* @map: Register map to write to
251	* @reg: Register to write to
252	* @val: Value to be written
253	*
254	* A value of zero will be returned on success, a negative errno will
255	* be returned in error cases.
256	*/
257	int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
258	{
259	int ret;
260
261	mutex_lock(&map->lock);
262
263	ret = _regmap_write(map, reg, val);
264
265	mutex_unlock(&map->lock);
266
267	return ret;
268	}
269	EXPORT_SYMBOL_GPL(regmap_write);
270
271	/**
272	* regmap_raw_write(): Write raw values to one or more registers
273	*
274	* @map: Register map to write to
275	* @reg: Initial register to write to
276	* @val: Block of data to be written, laid out for direct transmission to the
277	* device
278	* @val_len: Length of data pointed to by val.
279	*
280	* This function is intended to be used for things like firmware
281	* download where a large block of data needs to be transferred to the
282	* device. No formatting will be done on the data provided.
283	*
284	* A value of zero will be returned on success, a negative errno will
285	* be returned in error cases.
286	*/
287	int regmap_raw_write(struct regmap *map, unsigned int reg,
288	const void *val, size_t val_len)
289	{
290	int ret;
291
292	mutex_lock(&map->lock);
293
294	ret = _regmap_raw_write(map, reg, val, val_len);
295
296	mutex_unlock(&map->lock);
297
298	return ret;
299	}
300	EXPORT_SYMBOL_GPL(regmap_raw_write);
301
302	static int _regmap_raw_read(struct regmap map, unsigned int reg, void val,
303	unsigned int val_len)
304	{
305	u8 *u8 = map->work_buf;
306	int ret;
307
308	map->format.format_reg(map->work_buf, reg);
309
310	/*
311	* Some buses flag reads by setting the high bits in the
312	* register addresss; since it's always the high bits for all
313	* current formats we can do this here rather than in
314	* formatting. This may break if we get interesting formats.
315	*/
316	if (map->bus->read_flag_mask)
317	u8[0] \|= map->bus->read_flag_mask;
318
319	ret = map->bus->read(map->dev, map->work_buf, map->format.reg_bytes,
320	val, map->format.val_bytes);
321	if (ret != 0)
322	return ret;
323
324	return 0;
325	}
326
327	static int _regmap_read(struct regmap *map, unsigned int reg,
328	unsigned int *val)
329	{
330	int ret;
331
332	if (!map->format.parse_val)
333	return -EINVAL;
334
335	ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
336	if (ret == 0)
337	*val = map->format.parse_val(map->work_buf);
338
339	return ret;
340	}
341
342	/**
343	* regmap_read(): Read a value from a single register
344	*
345	* @map: Register map to write to
346	* @reg: Register to be read from
347	* @val: Pointer to store read value
348	*
349	* A value of zero will be returned on success, a negative errno will
350	* be returned in error cases.
351	*/
352	int regmap_read(struct regmap map, unsigned int reg, unsigned int val)
353	{
354	int ret;
355
356	mutex_lock(&map->lock);
357
358	ret = _regmap_read(map, reg, val);
359
360	mutex_unlock(&map->lock);
361
362	return ret;
363	}
364	EXPORT_SYMBOL_GPL(regmap_read);
365
366	/**
367	* regmap_raw_read(): Read raw data from the device
368	*
369	* @map: Register map to write to
370	* @reg: First register to be read from
371	* @val: Pointer to store read value
372	* @val_len: Size of data to read
373	*
374	* A value of zero will be returned on success, a negative errno will
375	* be returned in error cases.
376	*/
377	int regmap_raw_read(struct regmap map, unsigned int reg, void val,
378	size_t val_len)
379	{
380	int ret;
381
382	mutex_lock(&map->lock);
383
384	ret = _regmap_raw_read(map, reg, val, val_len);
385
386	mutex_unlock(&map->lock);
387
388	return ret;
389	}
390	EXPORT_SYMBOL_GPL(regmap_raw_read);
391
392	/**
393	* regmap_bulk_read(): Read multiple registers from the device
394	*
395	* @map: Register map to write to
396	* @reg: First register to be read from
397	* @val: Pointer to store read value, in native register size for device
398	* @val_count: Number of registers to read
399	*
400	* A value of zero will be returned on success, a negative errno will
401	* be returned in error cases.
402	*/
403	int regmap_bulk_read(struct regmap map, unsigned int reg, void val,
404	size_t val_count)
405	{
406	int ret, i;
407	size_t val_bytes = map->format.val_bytes;
408
409	if (!map->format.parse_val)
410	return -EINVAL;
411
412	ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
413	if (ret != 0)
414	return ret;
415
416	for (i = 0; i < val_count * val_bytes; i += val_bytes)
417	map->format.parse_val(val + i);
418
419	return 0;
420	}
421	EXPORT_SYMBOL_GPL(regmap_bulk_read);
422
423	/**
424	* remap_update_bits: Perform a read/modify/write cycle on the register map
425	*
426	* @map: Register map to update
427	* @reg: Register to update
428	* @mask: Bitmask to change
429	* @val: New value for bitmask
430	*
431	* Returns zero for success, a negative number on error.
432	*/
433	int regmap_update_bits(struct regmap *map, unsigned int reg,
434	unsigned int mask, unsigned int val)
435	{
436	int ret;
437	unsigned int tmp;
438
439	mutex_lock(&map->lock);
440
441	ret = _regmap_read(map, reg, &tmp);
442	if (ret != 0)
443	goto out;
444
445	tmp &= ~mask;
446	tmp \|= val & mask;
447
448	ret = _regmap_write(map, reg, tmp);
449
450	out:
451	mutex_unlock(&map->lock);
452
453	return ret;
454	}
455	EXPORT_SYMBOL_GPL(regmap_update_bits);