Loading...
Note: File does not exist in v6.8.
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);