1/*
2 * soc-io.c  --  ASoC register I/O helpers
3 *
4 * Copyright 2009-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 it
9 *  under  the terms of  the GNU General  Public License as published by the
10 *  Free Software Foundation;  either version 2 of the  License, or (at your
11 *  option) any later version.
12 */
13
14#include <linux/i2c.h>
15#include <linux/spi/spi.h>
16#include <linux/regmap.h>
17#include <linux/export.h>
18#include <sound/soc.h>
19
20/**
21 * snd_soc_component_read() - Read register value
22 * @component: Component to read from
23 * @reg: Register to read
24 * @val: Pointer to where the read value is stored
25 *
26 * Return: 0 on success, a negative error code otherwise.
27 */
28int snd_soc_component_read(struct snd_soc_component *component,
29	unsigned int reg, unsigned int *val)
30{
31	int ret;
32
33	if (component->regmap)
34		ret = regmap_read(component->regmap, reg, val);
35	else if (component->read)
36		ret = component->read(component, reg, val);
37	else
38		ret = -EIO;
39
40	return ret;
41}
42EXPORT_SYMBOL_GPL(snd_soc_component_read);
43
44/**
45 * snd_soc_component_write() - Write register value
46 * @component: Component to write to
47 * @reg: Register to write
48 * @val: Value to write to the register
49 *
50 * Return: 0 on success, a negative error code otherwise.
51 */
52int snd_soc_component_write(struct snd_soc_component *component,
53	unsigned int reg, unsigned int val)
54{
55	if (component->regmap)
56		return regmap_write(component->regmap, reg, val);
57	else if (component->write)
58		return component->write(component, reg, val);
59	else
60		return -EIO;
61}
62EXPORT_SYMBOL_GPL(snd_soc_component_write);
63
64static int snd_soc_component_update_bits_legacy(
65	struct snd_soc_component *component, unsigned int reg,
66	unsigned int mask, unsigned int val, bool *change)
67{
68	unsigned int old, new;
69	int ret;
70
71	if (!component->read || !component->write)
72		return -EIO;
73
74	mutex_lock(&component->io_mutex);
75
76	ret = component->read(component, reg, &old);
77	if (ret < 0)
78		goto out_unlock;
79
80	new = (old & ~mask) | (val & mask);
81	*change = old != new;
82	if (*change)
83		ret = component->write(component, reg, new);
84out_unlock:
85	mutex_unlock(&component->io_mutex);
86
87	return ret;
88}
89
90/**
91 * snd_soc_component_update_bits() - Perform read/modify/write cycle
92 * @component: Component to update
93 * @reg: Register to update
94 * @mask: Mask that specifies which bits to update
95 * @val: New value for the bits specified by mask
96 *
97 * Return: 1 if the operation was successful and the value of the register
98 * changed, 0 if the operation was successful, but the value did not change.
99 * Returns a negative error code otherwise.
100 */
101int snd_soc_component_update_bits(struct snd_soc_component *component,
102	unsigned int reg, unsigned int mask, unsigned int val)
103{
104	bool change;
105	int ret;
106
107	if (component->regmap)
108		ret = regmap_update_bits_check(component->regmap, reg, mask,
109			val, &change);
110	else
111		ret = snd_soc_component_update_bits_legacy(component, reg,
112			mask, val, &change);
113
114	if (ret < 0)
115		return ret;
116	return change;
117}
118EXPORT_SYMBOL_GPL(snd_soc_component_update_bits);
119
120/**
121 * snd_soc_component_update_bits_async() - Perform asynchronous
122 *  read/modify/write cycle
123 * @component: Component to update
124 * @reg: Register to update
125 * @mask: Mask that specifies which bits to update
126 * @val: New value for the bits specified by mask
127 *
128 * This function is similar to snd_soc_component_update_bits(), but the update
129 * operation is scheduled asynchronously. This means it may not be completed
130 * when the function returns. To make sure that all scheduled updates have been
131 * completed snd_soc_component_async_complete() must be called.
132 *
133 * Return: 1 if the operation was successful and the value of the register
134 * changed, 0 if the operation was successful, but the value did not change.
135 * Returns a negative error code otherwise.
136 */
137int snd_soc_component_update_bits_async(struct snd_soc_component *component,
138	unsigned int reg, unsigned int mask, unsigned int val)
139{
140	bool change;
141	int ret;
142
143	if (component->regmap)
144		ret = regmap_update_bits_check_async(component->regmap, reg,
145			mask, val, &change);
146	else
147		ret = snd_soc_component_update_bits_legacy(component, reg,
148			mask, val, &change);
149
150	if (ret < 0)
151		return ret;
152	return change;
153}
154EXPORT_SYMBOL_GPL(snd_soc_component_update_bits_async);
155
156/**
157 * snd_soc_component_async_complete() - Ensure asynchronous I/O has completed
158 * @component: Component for which to wait
159 *
160 * This function blocks until all asynchronous I/O which has previously been
161 * scheduled using snd_soc_component_update_bits_async() has completed.
162 */
163void snd_soc_component_async_complete(struct snd_soc_component *component)
164{
165	if (component->regmap)
166		regmap_async_complete(component->regmap);
167}
168EXPORT_SYMBOL_GPL(snd_soc_component_async_complete);
169
170/**
171 * snd_soc_component_test_bits - Test register for change
172 * @component: component
173 * @reg: Register to test
174 * @mask: Mask that specifies which bits to test
175 * @value: Value to test against
176 *
177 * Tests a register with a new value and checks if the new value is
178 * different from the old value.
179 *
180 * Return: 1 for change, otherwise 0.
181 */
182int snd_soc_component_test_bits(struct snd_soc_component *component,
183	unsigned int reg, unsigned int mask, unsigned int value)
184{
185	unsigned int old, new;
186	int ret;
187
188	ret = snd_soc_component_read(component, reg, &old);
189	if (ret < 0)
190		return ret;
191	new = (old & ~mask) | value;
192	return old != new;
193}
194EXPORT_SYMBOL_GPL(snd_soc_component_test_bits);
195
196unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg)
197{
198	unsigned int val;
199	int ret;
200
201	ret = snd_soc_component_read(&codec->component, reg, &val);
202	if (ret < 0)
203		return -1;
204
205	return val;
206}
207EXPORT_SYMBOL_GPL(snd_soc_read);
208
209int snd_soc_write(struct snd_soc_codec *codec, unsigned int reg,
210	unsigned int val)
211{
212	return snd_soc_component_write(&codec->component, reg, val);
213}
214EXPORT_SYMBOL_GPL(snd_soc_write);
215
216/**
217 * snd_soc_update_bits - update codec register bits
218 * @codec: audio codec
219 * @reg: codec register
220 * @mask: register mask
221 * @value: new value
222 *
223 * Writes new register value.
224 *
225 * Returns 1 for change, 0 for no change, or negative error code.
226 */
227int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned int reg,
228				unsigned int mask, unsigned int value)
229{
230	return snd_soc_component_update_bits(&codec->component, reg, mask,
231		value);
232}
233EXPORT_SYMBOL_GPL(snd_soc_update_bits);
234
235/**
236 * snd_soc_test_bits - test register for change
237 * @codec: audio codec
238 * @reg: codec register
239 * @mask: register mask
240 * @value: new value
241 *
242 * Tests a register with a new value and checks if the new value is
243 * different from the old value.
244 *
245 * Returns 1 for change else 0.
246 */
247int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned int reg,
248				unsigned int mask, unsigned int value)
249{
250	return snd_soc_component_test_bits(&codec->component, reg, mask, value);
251}
252EXPORT_SYMBOL_GPL(snd_soc_test_bits);
253
254int snd_soc_platform_read(struct snd_soc_platform *platform,
255					unsigned int reg)
256{
257	unsigned int val;
258	int ret;
259
260	ret = snd_soc_component_read(&platform->component, reg, &val);
261	if (ret < 0)
262		return -1;
263
264	return val;
265}
266EXPORT_SYMBOL_GPL(snd_soc_platform_read);
267
268int snd_soc_platform_write(struct snd_soc_platform *platform,
269					 unsigned int reg, unsigned int val)
270{
271	return snd_soc_component_write(&platform->component, reg, val);
272}
273EXPORT_SYMBOL_GPL(snd_soc_platform_write);
274