~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/soc-ac97.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * soc-ac97.c  --  ALSA SoC Audio Layer AC97 support
  3  *
  4  * Copyright 2005 Wolfson Microelectronics PLC.
  5  * Copyright 2005 Openedhand Ltd.
  6  * Copyright (C) 2010 Slimlogic Ltd.
  7  * Copyright (C) 2010 Texas Instruments Inc.
  8  *
  9  * Author: Liam Girdwood <lrg@slimlogic.co.uk>
 10  *         with code, comments and ideas from :-
 11  *         Richard Purdie <richard@openedhand.com>
 12  *
 13  *  This program is free software; you can redistribute  it and/or modify it
 14  *  under  the terms of  the GNU General  Public License as published by the
 15  *  Free Software Foundation;  either version 2 of the  License, or (at your
 16  *  option) any later version.
 17  */
 18 
 19 #include <linux/ctype.h>
 20 #include <linux/delay.h>
 21 #include <linux/export.h>
 22 #include <linux/gpio.h>
 23 #include <linux/gpio/driver.h>
 24 #include <linux/init.h>
 25 #include <linux/of_gpio.h>
 26 #include <linux/of.h>
 27 #include <linux/pinctrl/consumer.h>
 28 #include <linux/slab.h>
 29 #include <sound/ac97_codec.h>
 30 #include <sound/soc.h>
 31 
 32 struct snd_ac97_reset_cfg {
 33         struct pinctrl *pctl;
 34         struct pinctrl_state *pstate_reset;
 35         struct pinctrl_state *pstate_warm_reset;
 36         struct pinctrl_state *pstate_run;
 37         int gpio_sdata;
 38         int gpio_sync;
 39         int gpio_reset;
 40 };
 41 
 42 struct snd_ac97_gpio_priv {
 43 #ifdef CONFIG_GPIOLIB
 44         struct gpio_chip gpio_chip;
 45 #endif
 46         unsigned int gpios_set;
 47         struct snd_soc_codec *codec;
 48 };
 49 
 50 static struct snd_ac97_bus soc_ac97_bus = {
 51         .ops = NULL, /* Gets initialized in snd_soc_set_ac97_ops() */
 52 };
 53 
 54 static void soc_ac97_device_release(struct device *dev)
 55 {
 56         kfree(to_ac97_t(dev));
 57 }
 58 
 59 #ifdef CONFIG_GPIOLIB
 60 static inline struct snd_soc_codec *gpio_to_codec(struct gpio_chip *chip)
 61 {
 62         struct snd_ac97_gpio_priv *gpio_priv = gpiochip_get_data(chip);
 63 
 64         return gpio_priv->codec;
 65 }
 66 
 67 static int snd_soc_ac97_gpio_request(struct gpio_chip *chip, unsigned offset)
 68 {
 69         if (offset >= AC97_NUM_GPIOS)
 70                 return -EINVAL;
 71 
 72         return 0;
 73 }
 74 
 75 static int snd_soc_ac97_gpio_direction_in(struct gpio_chip *chip,
 76                                           unsigned offset)
 77 {
 78         struct snd_soc_codec *codec = gpio_to_codec(chip);
 79 
 80         dev_dbg(codec->dev, "set gpio %d to output\n", offset);
 81         return snd_soc_update_bits(codec, AC97_GPIO_CFG,
 82                                    1 << offset, 1 << offset);
 83 }
 84 
 85 static int snd_soc_ac97_gpio_get(struct gpio_chip *chip, unsigned offset)
 86 {
 87         struct snd_soc_codec *codec = gpio_to_codec(chip);
 88         int ret;
 89 
 90         ret = snd_soc_read(codec, AC97_GPIO_STATUS);
 91         dev_dbg(codec->dev, "get gpio %d : %d\n", offset,
 92                 ret < 0 ? ret : ret & (1 << offset));
 93 
 94         return ret < 0 ? ret : !!(ret & (1 << offset));
 95 }
 96 
 97 static void snd_soc_ac97_gpio_set(struct gpio_chip *chip, unsigned offset,
 98                                   int value)
 99 {
100         struct snd_ac97_gpio_priv *gpio_priv = gpiochip_get_data(chip);
101         struct snd_soc_codec *codec = gpio_to_codec(chip);
102 
103         gpio_priv->gpios_set &= ~(1 << offset);
104         gpio_priv->gpios_set |= (!!value) << offset;
105         snd_soc_write(codec, AC97_GPIO_STATUS, gpio_priv->gpios_set);
106         dev_dbg(codec->dev, "set gpio %d to %d\n", offset, !!value);
107 }
108 
109 static int snd_soc_ac97_gpio_direction_out(struct gpio_chip *chip,
110                                      unsigned offset, int value)
111 {
112         struct snd_soc_codec *codec = gpio_to_codec(chip);
113 
114         dev_dbg(codec->dev, "set gpio %d to output\n", offset);
115         snd_soc_ac97_gpio_set(chip, offset, value);
116         return snd_soc_update_bits(codec, AC97_GPIO_CFG, 1 << offset, 0);
117 }
118 
119 static struct gpio_chip snd_soc_ac97_gpio_chip = {
120         .label                  = "snd_soc_ac97",
121         .owner                  = THIS_MODULE,
122         .request                = snd_soc_ac97_gpio_request,
123         .direction_input        = snd_soc_ac97_gpio_direction_in,
124         .get                    = snd_soc_ac97_gpio_get,
125         .direction_output       = snd_soc_ac97_gpio_direction_out,
126         .set                    = snd_soc_ac97_gpio_set,
127         .can_sleep              = 1,
128 };
129 
130 static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
131                                   struct snd_soc_codec *codec)
132 {
133         struct snd_ac97_gpio_priv *gpio_priv;
134         int ret;
135 
136         gpio_priv = devm_kzalloc(codec->dev, sizeof(*gpio_priv), GFP_KERNEL);
137         if (!gpio_priv)
138                 return -ENOMEM;
139         ac97->gpio_priv = gpio_priv;
140         gpio_priv->codec = codec;
141         gpio_priv->gpio_chip = snd_soc_ac97_gpio_chip;
142         gpio_priv->gpio_chip.ngpio = AC97_NUM_GPIOS;
143         gpio_priv->gpio_chip.parent = codec->dev;
144         gpio_priv->gpio_chip.base = -1;
145 
146         ret = gpiochip_add_data(&gpio_priv->gpio_chip, gpio_priv);
147         if (ret != 0)
148                 dev_err(codec->dev, "Failed to add GPIOs: %d\n", ret);
149         return ret;
150 }
151 
152 static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
153 {
154         gpiochip_remove(&ac97->gpio_priv->gpio_chip);
155 }
156 #else
157 static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
158                                   struct snd_soc_codec *codec)
159 {
160         return 0;
161 }
162 
163 static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
164 {
165 }
166 #endif
167 
168 /**
169  * snd_soc_alloc_ac97_codec() - Allocate new a AC'97 device
170  * @codec: The CODEC for which to create the AC'97 device
171  *
172  * Allocated a new snd_ac97 device and intializes it, but does not yet register
173  * it. The caller is responsible to either call device_add(&ac97->dev) to
174  * register the device, or to call put_device(&ac97->dev) to free the device.
175  *
176  * Returns: A snd_ac97 device or a PTR_ERR in case of an error.
177  */
178 struct snd_ac97 *snd_soc_alloc_ac97_codec(struct snd_soc_codec *codec)
179 {
180         struct snd_ac97 *ac97;
181 
182         ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
183         if (ac97 == NULL)
184                 return ERR_PTR(-ENOMEM);
185 
186         ac97->bus = &soc_ac97_bus;
187         ac97->num = 0;
188 
189         ac97->dev.bus = &ac97_bus_type;
190         ac97->dev.parent = codec->component.card->dev;
191         ac97->dev.release = soc_ac97_device_release;
192 
193         dev_set_name(&ac97->dev, "%d-%d:%s",
194                      codec->component.card->snd_card->number, 0,
195                      codec->component.name);
196 
197         device_initialize(&ac97->dev);
198 
199         return ac97;
200 }
201 EXPORT_SYMBOL(snd_soc_alloc_ac97_codec);
202 
203 /**
204  * snd_soc_new_ac97_codec - initailise AC97 device
205  * @codec: audio codec
206  * @id: The expected device ID
207  * @id_mask: Mask that is applied to the device ID before comparing with @id
208  *
209  * Initialises AC97 codec resources for use by ad-hoc devices only.
210  *
211  * If @id is not 0 this function will reset the device, then read the ID from
212  * the device and check if it matches the expected ID. If it doesn't match an
213  * error will be returned and device will not be registered.
214  *
215  * Returns: A PTR_ERR() on failure or a valid snd_ac97 struct on success.
216  */
217 struct snd_ac97 *snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
218         unsigned int id, unsigned int id_mask)
219 {
220         struct snd_ac97 *ac97;
221         int ret;
222 
223         ac97 = snd_soc_alloc_ac97_codec(codec);
224         if (IS_ERR(ac97))
225                 return ac97;
226 
227         if (id) {
228                 ret = snd_ac97_reset(ac97, false, id, id_mask);
229                 if (ret < 0) {
230                         dev_err(codec->dev, "Failed to reset AC97 device: %d\n",
231                                 ret);
232                         goto err_put_device;
233                 }
234         }
235 
236         ret = device_add(&ac97->dev);
237         if (ret)
238                 goto err_put_device;
239 
240         ret = snd_soc_ac97_init_gpio(ac97, codec);
241         if (ret)
242                 goto err_put_device;
243 
244         return ac97;
245 
246 err_put_device:
247         put_device(&ac97->dev);
248         return ERR_PTR(ret);
249 }
250 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
251 
252 /**
253  * snd_soc_free_ac97_codec - free AC97 codec device
254  * @codec: audio codec
255  *
256  * Frees AC97 codec device resources.
257  */
258 void snd_soc_free_ac97_codec(struct snd_ac97 *ac97)
259 {
260         snd_soc_ac97_free_gpio(ac97);
261         device_del(&ac97->dev);
262         ac97->bus = NULL;
263         put_device(&ac97->dev);
264 }
265 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
266 
267 static struct snd_ac97_reset_cfg snd_ac97_rst_cfg;
268 
269 static void snd_soc_ac97_warm_reset(struct snd_ac97 *ac97)
270 {
271         struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;
272 
273         pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_warm_reset);
274 
275         gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 1);
276 
277         udelay(10);
278 
279         gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
280 
281         pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
282         msleep(2);
283 }
284 
285 static void snd_soc_ac97_reset(struct snd_ac97 *ac97)
286 {
287         struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;
288 
289         pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_reset);
290 
291         gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
292         gpio_direction_output(snd_ac97_rst_cfg.gpio_sdata, 0);
293         gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 0);
294 
295         udelay(10);
296 
297         gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 1);
298 
299         pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
300         msleep(2);
301 }
302 
303 static int snd_soc_ac97_parse_pinctl(struct device *dev,
304                 struct snd_ac97_reset_cfg *cfg)
305 {
306         struct pinctrl *p;
307         struct pinctrl_state *state;
308         int gpio;
309         int ret;
310 
311         p = devm_pinctrl_get(dev);
312         if (IS_ERR(p)) {
313                 dev_err(dev, "Failed to get pinctrl\n");
314                 return PTR_ERR(p);
315         }
316         cfg->pctl = p;
317 
318         state = pinctrl_lookup_state(p, "ac97-reset");
319         if (IS_ERR(state)) {
320                 dev_err(dev, "Can't find pinctrl state ac97-reset\n");
321                 return PTR_ERR(state);
322         }
323         cfg->pstate_reset = state;
324 
325         state = pinctrl_lookup_state(p, "ac97-warm-reset");
326         if (IS_ERR(state)) {
327                 dev_err(dev, "Can't find pinctrl state ac97-warm-reset\n");
328                 return PTR_ERR(state);
329         }
330         cfg->pstate_warm_reset = state;
331 
332         state = pinctrl_lookup_state(p, "ac97-running");
333         if (IS_ERR(state)) {
334                 dev_err(dev, "Can't find pinctrl state ac97-running\n");
335                 return PTR_ERR(state);
336         }
337         cfg->pstate_run = state;
338 
339         gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 0);
340         if (gpio < 0) {
341                 dev_err(dev, "Can't find ac97-sync gpio\n");
342                 return gpio;
343         }
344         ret = devm_gpio_request(dev, gpio, "AC97 link sync");
345         if (ret) {
346                 dev_err(dev, "Failed requesting ac97-sync gpio\n");
347                 return ret;
348         }
349         cfg->gpio_sync = gpio;
350 
351         gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 1);
352         if (gpio < 0) {
353                 dev_err(dev, "Can't find ac97-sdata gpio %d\n", gpio);
354                 return gpio;
355         }
356         ret = devm_gpio_request(dev, gpio, "AC97 link sdata");
357         if (ret) {
358                 dev_err(dev, "Failed requesting ac97-sdata gpio\n");
359                 return ret;
360         }
361         cfg->gpio_sdata = gpio;
362 
363         gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 2);
364         if (gpio < 0) {
365                 dev_err(dev, "Can't find ac97-reset gpio\n");
366                 return gpio;
367         }
368         ret = devm_gpio_request(dev, gpio, "AC97 link reset");
369         if (ret) {
370                 dev_err(dev, "Failed requesting ac97-reset gpio\n");
371                 return ret;
372         }
373         cfg->gpio_reset = gpio;
374 
375         return 0;
376 }
377 
378 struct snd_ac97_bus_ops *soc_ac97_ops;
379 EXPORT_SYMBOL_GPL(soc_ac97_ops);
380 
381 int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
382 {
383         if (ops == soc_ac97_ops)
384                 return 0;
385 
386         if (soc_ac97_ops && ops)
387                 return -EBUSY;
388 
389         soc_ac97_ops = ops;
390         soc_ac97_bus.ops = ops;
391 
392         return 0;
393 }
394 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops);
395 
396 /**
397  * snd_soc_set_ac97_ops_of_reset - Set ac97 ops with generic ac97 reset functions
398  *
399  * This function sets the reset and warm_reset properties of ops and parses
400  * the device node of pdev to get pinctrl states and gpio numbers to use.
401  */
402 int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
403                 struct platform_device *pdev)
404 {
405         struct device *dev = &pdev->dev;
406         struct snd_ac97_reset_cfg cfg;
407         int ret;
408 
409         ret = snd_soc_ac97_parse_pinctl(dev, &cfg);
410         if (ret)
411                 return ret;
412 
413         ret = snd_soc_set_ac97_ops(ops);
414         if (ret)
415                 return ret;
416 
417         ops->warm_reset = snd_soc_ac97_warm_reset;
418         ops->reset = snd_soc_ac97_reset;
419 
420         snd_ac97_rst_cfg = cfg;
421         return 0;
422 }
423 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops_of_reset);
424 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp