This source file includes following definitions.
- soc_ac97_device_release
- gpio_to_component
- snd_soc_ac97_gpio_request
- snd_soc_ac97_gpio_direction_in
- snd_soc_ac97_gpio_get
- snd_soc_ac97_gpio_set
- snd_soc_ac97_gpio_direction_out
- snd_soc_ac97_init_gpio
- snd_soc_ac97_free_gpio
- snd_soc_ac97_init_gpio
- snd_soc_ac97_free_gpio
- snd_soc_alloc_ac97_component
- snd_soc_new_ac97_component
- snd_soc_free_ac97_component
- snd_soc_ac97_warm_reset
- snd_soc_ac97_reset
- snd_soc_ac97_parse_pinctl
- snd_soc_set_ac97_ops
- snd_soc_set_ac97_ops_of_reset
1
2
3
4
5
6
7
8
9
10
11
12
13
14 #include <linux/ctype.h>
15 #include <linux/delay.h>
16 #include <linux/export.h>
17 #include <linux/gpio.h>
18 #include <linux/gpio/driver.h>
19 #include <linux/init.h>
20 #include <linux/of_gpio.h>
21 #include <linux/of.h>
22 #include <linux/pinctrl/consumer.h>
23 #include <linux/slab.h>
24 #include <sound/ac97_codec.h>
25 #include <sound/soc.h>
26
27 struct snd_ac97_reset_cfg {
28 struct pinctrl *pctl;
29 struct pinctrl_state *pstate_reset;
30 struct pinctrl_state *pstate_warm_reset;
31 struct pinctrl_state *pstate_run;
32 int gpio_sdata;
33 int gpio_sync;
34 int gpio_reset;
35 };
36
37 struct snd_ac97_gpio_priv {
38 #ifdef CONFIG_GPIOLIB
39 struct gpio_chip gpio_chip;
40 #endif
41 unsigned int gpios_set;
42 struct snd_soc_component *component;
43 };
44
45 static struct snd_ac97_bus soc_ac97_bus = {
46 .ops = NULL,
47 };
48
49 static void soc_ac97_device_release(struct device *dev)
50 {
51 kfree(to_ac97_t(dev));
52 }
53
54 #ifdef CONFIG_GPIOLIB
55 static inline struct snd_soc_component *gpio_to_component(struct gpio_chip *chip)
56 {
57 struct snd_ac97_gpio_priv *gpio_priv = gpiochip_get_data(chip);
58
59 return gpio_priv->component;
60 }
61
62 static int snd_soc_ac97_gpio_request(struct gpio_chip *chip, unsigned offset)
63 {
64 if (offset >= AC97_NUM_GPIOS)
65 return -EINVAL;
66
67 return 0;
68 }
69
70 static int snd_soc_ac97_gpio_direction_in(struct gpio_chip *chip,
71 unsigned offset)
72 {
73 struct snd_soc_component *component = gpio_to_component(chip);
74
75 dev_dbg(component->dev, "set gpio %d to output\n", offset);
76 return snd_soc_component_update_bits(component, AC97_GPIO_CFG,
77 1 << offset, 1 << offset);
78 }
79
80 static int snd_soc_ac97_gpio_get(struct gpio_chip *chip, unsigned offset)
81 {
82 struct snd_soc_component *component = gpio_to_component(chip);
83 int ret;
84
85 if (snd_soc_component_read(component, AC97_GPIO_STATUS, &ret) < 0)
86 ret = -1;
87
88 dev_dbg(component->dev, "get gpio %d : %d\n", offset,
89 ret < 0 ? ret : ret & (1 << offset));
90
91 return ret < 0 ? ret : !!(ret & (1 << offset));
92 }
93
94 static void snd_soc_ac97_gpio_set(struct gpio_chip *chip, unsigned offset,
95 int value)
96 {
97 struct snd_ac97_gpio_priv *gpio_priv = gpiochip_get_data(chip);
98 struct snd_soc_component *component = gpio_to_component(chip);
99
100 gpio_priv->gpios_set &= ~(1 << offset);
101 gpio_priv->gpios_set |= (!!value) << offset;
102 snd_soc_component_write(component, AC97_GPIO_STATUS,
103 gpio_priv->gpios_set);
104 dev_dbg(component->dev, "set gpio %d to %d\n", offset, !!value);
105 }
106
107 static int snd_soc_ac97_gpio_direction_out(struct gpio_chip *chip,
108 unsigned offset, int value)
109 {
110 struct snd_soc_component *component = gpio_to_component(chip);
111
112 dev_dbg(component->dev, "set gpio %d to output\n", offset);
113 snd_soc_ac97_gpio_set(chip, offset, value);
114 return snd_soc_component_update_bits(component, AC97_GPIO_CFG,
115 1 << offset, 0);
116 }
117
118 static const struct gpio_chip snd_soc_ac97_gpio_chip = {
119 .label = "snd_soc_ac97",
120 .owner = THIS_MODULE,
121 .request = snd_soc_ac97_gpio_request,
122 .direction_input = snd_soc_ac97_gpio_direction_in,
123 .get = snd_soc_ac97_gpio_get,
124 .direction_output = snd_soc_ac97_gpio_direction_out,
125 .set = snd_soc_ac97_gpio_set,
126 .can_sleep = 1,
127 };
128
129 static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
130 struct snd_soc_component *component)
131 {
132 struct snd_ac97_gpio_priv *gpio_priv;
133 int ret;
134
135 gpio_priv = devm_kzalloc(component->dev, sizeof(*gpio_priv), GFP_KERNEL);
136 if (!gpio_priv)
137 return -ENOMEM;
138 ac97->gpio_priv = gpio_priv;
139 gpio_priv->component = component;
140 gpio_priv->gpio_chip = snd_soc_ac97_gpio_chip;
141 gpio_priv->gpio_chip.ngpio = AC97_NUM_GPIOS;
142 gpio_priv->gpio_chip.parent = component->dev;
143 gpio_priv->gpio_chip.base = -1;
144
145 ret = gpiochip_add_data(&gpio_priv->gpio_chip, gpio_priv);
146 if (ret != 0)
147 dev_err(component->dev, "Failed to add GPIOs: %d\n", ret);
148 return ret;
149 }
150
151 static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
152 {
153 gpiochip_remove(&ac97->gpio_priv->gpio_chip);
154 }
155 #else
156 static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
157 struct snd_soc_component *component)
158 {
159 return 0;
160 }
161
162 static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
163 {
164 }
165 #endif
166
167
168
169
170
171
172
173
174
175
176
177 struct snd_ac97 *snd_soc_alloc_ac97_component(struct snd_soc_component *component)
178 {
179 struct snd_ac97 *ac97;
180
181 ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
182 if (ac97 == NULL)
183 return ERR_PTR(-ENOMEM);
184
185 ac97->bus = &soc_ac97_bus;
186 ac97->num = 0;
187
188 ac97->dev.bus = &ac97_bus_type;
189 ac97->dev.parent = component->card->dev;
190 ac97->dev.release = soc_ac97_device_release;
191
192 dev_set_name(&ac97->dev, "%d-%d:%s",
193 component->card->snd_card->number, 0,
194 component->name);
195
196 device_initialize(&ac97->dev);
197
198 return ac97;
199 }
200 EXPORT_SYMBOL(snd_soc_alloc_ac97_component);
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216 struct snd_ac97 *snd_soc_new_ac97_component(struct snd_soc_component *component,
217 unsigned int id, unsigned int id_mask)
218 {
219 struct snd_ac97 *ac97;
220 int ret;
221
222 ac97 = snd_soc_alloc_ac97_component(component);
223 if (IS_ERR(ac97))
224 return ac97;
225
226 if (id) {
227 ret = snd_ac97_reset(ac97, false, id, id_mask);
228 if (ret < 0) {
229 dev_err(component->dev, "Failed to reset AC97 device: %d\n",
230 ret);
231 goto err_put_device;
232 }
233 }
234
235 ret = device_add(&ac97->dev);
236 if (ret)
237 goto err_put_device;
238
239 ret = snd_soc_ac97_init_gpio(ac97, component);
240 if (ret)
241 goto err_put_device;
242
243 return ac97;
244
245 err_put_device:
246 put_device(&ac97->dev);
247 return ERR_PTR(ret);
248 }
249 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_component);
250
251
252
253
254
255
256
257 void snd_soc_free_ac97_component(struct snd_ac97 *ac97)
258 {
259 snd_soc_ac97_free_gpio(ac97);
260 device_del(&ac97->dev);
261 ac97->bus = NULL;
262 put_device(&ac97->dev);
263 }
264 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_component);
265
266 static struct snd_ac97_reset_cfg snd_ac97_rst_cfg;
267
268 static void snd_soc_ac97_warm_reset(struct snd_ac97 *ac97)
269 {
270 struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;
271
272 pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_warm_reset);
273
274 gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 1);
275
276 udelay(10);
277
278 gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
279
280 pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
281 msleep(2);
282 }
283
284 static void snd_soc_ac97_reset(struct snd_ac97 *ac97)
285 {
286 struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;
287
288 pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_reset);
289
290 gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
291 gpio_direction_output(snd_ac97_rst_cfg.gpio_sdata, 0);
292 gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 0);
293
294 udelay(10);
295
296 gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 1);
297
298 pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
299 msleep(2);
300 }
301
302 static int snd_soc_ac97_parse_pinctl(struct device *dev,
303 struct snd_ac97_reset_cfg *cfg)
304 {
305 struct pinctrl *p;
306 struct pinctrl_state *state;
307 int gpio;
308 int ret;
309
310 p = devm_pinctrl_get(dev);
311 if (IS_ERR(p)) {
312 dev_err(dev, "Failed to get pinctrl\n");
313 return PTR_ERR(p);
314 }
315 cfg->pctl = p;
316
317 state = pinctrl_lookup_state(p, "ac97-reset");
318 if (IS_ERR(state)) {
319 dev_err(dev, "Can't find pinctrl state ac97-reset\n");
320 return PTR_ERR(state);
321 }
322 cfg->pstate_reset = state;
323
324 state = pinctrl_lookup_state(p, "ac97-warm-reset");
325 if (IS_ERR(state)) {
326 dev_err(dev, "Can't find pinctrl state ac97-warm-reset\n");
327 return PTR_ERR(state);
328 }
329 cfg->pstate_warm_reset = state;
330
331 state = pinctrl_lookup_state(p, "ac97-running");
332 if (IS_ERR(state)) {
333 dev_err(dev, "Can't find pinctrl state ac97-running\n");
334 return PTR_ERR(state);
335 }
336 cfg->pstate_run = state;
337
338 gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 0);
339 if (gpio < 0) {
340 dev_err(dev, "Can't find ac97-sync gpio\n");
341 return gpio;
342 }
343 ret = devm_gpio_request(dev, gpio, "AC97 link sync");
344 if (ret) {
345 dev_err(dev, "Failed requesting ac97-sync gpio\n");
346 return ret;
347 }
348 cfg->gpio_sync = gpio;
349
350 gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 1);
351 if (gpio < 0) {
352 dev_err(dev, "Can't find ac97-sdata gpio %d\n", gpio);
353 return gpio;
354 }
355 ret = devm_gpio_request(dev, gpio, "AC97 link sdata");
356 if (ret) {
357 dev_err(dev, "Failed requesting ac97-sdata gpio\n");
358 return ret;
359 }
360 cfg->gpio_sdata = gpio;
361
362 gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 2);
363 if (gpio < 0) {
364 dev_err(dev, "Can't find ac97-reset gpio\n");
365 return gpio;
366 }
367 ret = devm_gpio_request(dev, gpio, "AC97 link reset");
368 if (ret) {
369 dev_err(dev, "Failed requesting ac97-reset gpio\n");
370 return ret;
371 }
372 cfg->gpio_reset = gpio;
373
374 return 0;
375 }
376
377 struct snd_ac97_bus_ops *soc_ac97_ops;
378 EXPORT_SYMBOL_GPL(soc_ac97_ops);
379
380 int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
381 {
382 if (ops == soc_ac97_ops)
383 return 0;
384
385 if (soc_ac97_ops && ops)
386 return -EBUSY;
387
388 soc_ac97_ops = ops;
389 soc_ac97_bus.ops = ops;
390
391 return 0;
392 }
393 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops);
394
395
396
397
398
399
400
401 int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
402 struct platform_device *pdev)
403 {
404 struct device *dev = &pdev->dev;
405 struct snd_ac97_reset_cfg cfg;
406 int ret;
407
408 ret = snd_soc_ac97_parse_pinctl(dev, &cfg);
409 if (ret)
410 return ret;
411
412 ret = snd_soc_set_ac97_ops(ops);
413 if (ret)
414 return ret;
415
416 ops->warm_reset = snd_soc_ac97_warm_reset;
417 ops->reset = snd_soc_ac97_reset;
418
419 snd_ac97_rst_cfg = cfg;
420 return 0;
421 }
422 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops_of_reset);