Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/sound/soc/soc-core.c

  1 /*
  2  * soc-core.c  --  ALSA SoC Audio Layer
  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  *  TODO:
 19  *   o Add hw rules to enforce rates, etc.
 20  *   o More testing with other codecs/machines.
 21  *   o Add more codecs and platforms to ensure good API coverage.
 22  *   o Support TDM on PCM and I2S
 23  */
 24 
 25 #include <linux/module.h>
 26 #include <linux/moduleparam.h>
 27 #include <linux/init.h>
 28 #include <linux/delay.h>
 29 #include <linux/pm.h>
 30 #include <linux/bitops.h>
 31 #include <linux/debugfs.h>
 32 #include <linux/platform_device.h>
 33 #include <linux/pinctrl/consumer.h>
 34 #include <linux/ctype.h>
 35 #include <linux/slab.h>
 36 #include <linux/of.h>
 37 #include <linux/gpio.h>
 38 #include <linux/of_gpio.h>
 39 #include <sound/ac97_codec.h>
 40 #include <sound/core.h>
 41 #include <sound/jack.h>
 42 #include <sound/pcm.h>
 43 #include <sound/pcm_params.h>
 44 #include <sound/soc.h>
 45 #include <sound/soc-dpcm.h>
 46 #include <sound/initval.h>
 47 
 48 #define CREATE_TRACE_POINTS
 49 #include <trace/events/asoc.h>
 50 
 51 #define NAME_SIZE       32
 52 
 53 #ifdef CONFIG_DEBUG_FS
 54 struct dentry *snd_soc_debugfs_root;
 55 EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
 56 #endif
 57 
 58 static DEFINE_MUTEX(client_mutex);
 59 static LIST_HEAD(platform_list);
 60 static LIST_HEAD(codec_list);
 61 static LIST_HEAD(component_list);
 62 
 63 /*
 64  * This is a timeout to do a DAPM powerdown after a stream is closed().
 65  * It can be used to eliminate pops between different playback streams, e.g.
 66  * between two audio tracks.
 67  */
 68 static int pmdown_time = 5000;
 69 module_param(pmdown_time, int, 0);
 70 MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
 71 
 72 struct snd_ac97_reset_cfg {
 73         struct pinctrl *pctl;
 74         struct pinctrl_state *pstate_reset;
 75         struct pinctrl_state *pstate_warm_reset;
 76         struct pinctrl_state *pstate_run;
 77         int gpio_sdata;
 78         int gpio_sync;
 79         int gpio_reset;
 80 };
 81 
 82 /* returns the minimum number of bytes needed to represent
 83  * a particular given value */
 84 static int min_bytes_needed(unsigned long val)
 85 {
 86         int c = 0;
 87         int i;
 88 
 89         for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
 90                 if (val & (1UL << i))
 91                         break;
 92         c = (sizeof val * 8) - c;
 93         if (!c || (c % 8))
 94                 c = (c + 8) / 8;
 95         else
 96                 c /= 8;
 97         return c;
 98 }
 99 
100 /* fill buf which is 'len' bytes with a formatted
101  * string of the form 'reg: value\n' */
102 static int format_register_str(struct snd_soc_codec *codec,
103                                unsigned int reg, char *buf, size_t len)
104 {
105         int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
106         int regsize = codec->driver->reg_word_size * 2;
107         int ret;
108         char tmpbuf[len + 1];
109         char regbuf[regsize + 1];
110 
111         /* since tmpbuf is allocated on the stack, warn the callers if they
112          * try to abuse this function */
113         WARN_ON(len > 63);
114 
115         /* +2 for ': ' and + 1 for '\n' */
116         if (wordsize + regsize + 2 + 1 != len)
117                 return -EINVAL;
118 
119         ret = snd_soc_read(codec, reg);
120         if (ret < 0) {
121                 memset(regbuf, 'X', regsize);
122                 regbuf[regsize] = '\0';
123         } else {
124                 snprintf(regbuf, regsize + 1, "%.*x", regsize, ret);
125         }
126 
127         /* prepare the buffer */
128         snprintf(tmpbuf, len + 1, "%.*x: %s\n", wordsize, reg, regbuf);
129         /* copy it back to the caller without the '\0' */
130         memcpy(buf, tmpbuf, len);
131 
132         return 0;
133 }
134 
135 /* codec register dump */
136 static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
137                                   size_t count, loff_t pos)
138 {
139         int i, step = 1;
140         int wordsize, regsize;
141         int len;
142         size_t total = 0;
143         loff_t p = 0;
144 
145         wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
146         regsize = codec->driver->reg_word_size * 2;
147 
148         len = wordsize + regsize + 2 + 1;
149 
150         if (!codec->driver->reg_cache_size)
151                 return 0;
152 
153         if (codec->driver->reg_cache_step)
154                 step = codec->driver->reg_cache_step;
155 
156         for (i = 0; i < codec->driver->reg_cache_size; i += step) {
157                 /* only support larger than PAGE_SIZE bytes debugfs
158                  * entries for the default case */
159                 if (p >= pos) {
160                         if (total + len >= count - 1)
161                                 break;
162                         format_register_str(codec, i, buf + total, len);
163                         total += len;
164                 }
165                 p += len;
166         }
167 
168         total = min(total, count - 1);
169 
170         return total;
171 }
172 
173 static ssize_t codec_reg_show(struct device *dev,
174         struct device_attribute *attr, char *buf)
175 {
176         struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
177 
178         return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
179 }
180 
181 static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
182 
183 static ssize_t pmdown_time_show(struct device *dev,
184                                 struct device_attribute *attr, char *buf)
185 {
186         struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
187 
188         return sprintf(buf, "%ld\n", rtd->pmdown_time);
189 }
190 
191 static ssize_t pmdown_time_set(struct device *dev,
192                                struct device_attribute *attr,
193                                const char *buf, size_t count)
194 {
195         struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
196         int ret;
197 
198         ret = kstrtol(buf, 10, &rtd->pmdown_time);
199         if (ret)
200                 return ret;
201 
202         return count;
203 }
204 
205 static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
206 
207 #ifdef CONFIG_DEBUG_FS
208 static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
209                                    size_t count, loff_t *ppos)
210 {
211         ssize_t ret;
212         struct snd_soc_codec *codec = file->private_data;
213         char *buf;
214 
215         if (*ppos < 0 || !count)
216                 return -EINVAL;
217 
218         buf = kmalloc(count, GFP_KERNEL);
219         if (!buf)
220                 return -ENOMEM;
221 
222         ret = soc_codec_reg_show(codec, buf, count, *ppos);
223         if (ret >= 0) {
224                 if (copy_to_user(user_buf, buf, ret)) {
225                         kfree(buf);
226                         return -EFAULT;
227                 }
228                 *ppos += ret;
229         }
230 
231         kfree(buf);
232         return ret;
233 }
234 
235 static ssize_t codec_reg_write_file(struct file *file,
236                 const char __user *user_buf, size_t count, loff_t *ppos)
237 {
238         char buf[32];
239         size_t buf_size;
240         char *start = buf;
241         unsigned long reg, value;
242         struct snd_soc_codec *codec = file->private_data;
243         int ret;
244 
245         buf_size = min(count, (sizeof(buf)-1));
246         if (copy_from_user(buf, user_buf, buf_size))
247                 return -EFAULT;
248         buf[buf_size] = 0;
249 
250         while (*start == ' ')
251                 start++;
252         reg = simple_strtoul(start, &start, 16);
253         while (*start == ' ')
254                 start++;
255         ret = kstrtoul(start, 16, &value);
256         if (ret)
257                 return ret;
258 
259         /* Userspace has been fiddling around behind the kernel's back */
260         add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
261 
262         snd_soc_write(codec, reg, value);
263         return buf_size;
264 }
265 
266 static const struct file_operations codec_reg_fops = {
267         .open = simple_open,
268         .read = codec_reg_read_file,
269         .write = codec_reg_write_file,
270         .llseek = default_llseek,
271 };
272 
273 static void soc_init_component_debugfs(struct snd_soc_component *component)
274 {
275         if (component->debugfs_prefix) {
276                 char *name;
277 
278                 name = kasprintf(GFP_KERNEL, "%s:%s",
279                         component->debugfs_prefix, component->name);
280                 if (name) {
281                         component->debugfs_root = debugfs_create_dir(name,
282                                 component->card->debugfs_card_root);
283                         kfree(name);
284                 }
285         } else {
286                 component->debugfs_root = debugfs_create_dir(component->name,
287                                 component->card->debugfs_card_root);
288         }
289 
290         if (!component->debugfs_root) {
291                 dev_warn(component->dev,
292                         "ASoC: Failed to create component debugfs directory\n");
293                 return;
294         }
295 
296         snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),
297                 component->debugfs_root);
298 
299         if (component->init_debugfs)
300                 component->init_debugfs(component);
301 }
302 
303 static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
304 {
305         debugfs_remove_recursive(component->debugfs_root);
306 }
307 
308 static void soc_init_codec_debugfs(struct snd_soc_component *component)
309 {
310         struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
311 
312         debugfs_create_bool("cache_sync", 0444, codec->component.debugfs_root,
313                             &codec->cache_sync);
314 
315         codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
316                                                  codec->component.debugfs_root,
317                                                  codec, &codec_reg_fops);
318         if (!codec->debugfs_reg)
319                 dev_warn(codec->dev,
320                         "ASoC: Failed to create codec register debugfs file\n");
321 }
322 
323 static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
324                                     size_t count, loff_t *ppos)
325 {
326         char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
327         ssize_t len, ret = 0;
328         struct snd_soc_codec *codec;
329 
330         if (!buf)
331                 return -ENOMEM;
332 
333         list_for_each_entry(codec, &codec_list, list) {
334                 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
335                                codec->component.name);
336                 if (len >= 0)
337                         ret += len;
338                 if (ret > PAGE_SIZE) {
339                         ret = PAGE_SIZE;
340                         break;
341                 }
342         }
343 
344         if (ret >= 0)
345                 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
346 
347         kfree(buf);
348 
349         return ret;
350 }
351 
352 static const struct file_operations codec_list_fops = {
353         .read = codec_list_read_file,
354         .llseek = default_llseek,/* read accesses f_pos */
355 };
356 
357 static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
358                                   size_t count, loff_t *ppos)
359 {
360         char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
361         ssize_t len, ret = 0;
362         struct snd_soc_component *component;
363         struct snd_soc_dai *dai;
364 
365         if (!buf)
366                 return -ENOMEM;
367 
368         list_for_each_entry(component, &component_list, list) {
369                 list_for_each_entry(dai, &component->dai_list, list) {
370                         len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
371                                 dai->name);
372                         if (len >= 0)
373                                 ret += len;
374                         if (ret > PAGE_SIZE) {
375                                 ret = PAGE_SIZE;
376                                 break;
377                         }
378                 }
379         }
380 
381         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
382 
383         kfree(buf);
384 
385         return ret;
386 }
387 
388 static const struct file_operations dai_list_fops = {
389         .read = dai_list_read_file,
390         .llseek = default_llseek,/* read accesses f_pos */
391 };
392 
393 static ssize_t platform_list_read_file(struct file *file,
394                                        char __user *user_buf,
395                                        size_t count, loff_t *ppos)
396 {
397         char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
398         ssize_t len, ret = 0;
399         struct snd_soc_platform *platform;
400 
401         if (!buf)
402                 return -ENOMEM;
403 
404         list_for_each_entry(platform, &platform_list, list) {
405                 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
406                                platform->component.name);
407                 if (len >= 0)
408                         ret += len;
409                 if (ret > PAGE_SIZE) {
410                         ret = PAGE_SIZE;
411                         break;
412                 }
413         }
414 
415         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
416 
417         kfree(buf);
418 
419         return ret;
420 }
421 
422 static const struct file_operations platform_list_fops = {
423         .read = platform_list_read_file,
424         .llseek = default_llseek,/* read accesses f_pos */
425 };
426 
427 static void soc_init_card_debugfs(struct snd_soc_card *card)
428 {
429         card->debugfs_card_root = debugfs_create_dir(card->name,
430                                                      snd_soc_debugfs_root);
431         if (!card->debugfs_card_root) {
432                 dev_warn(card->dev,
433                          "ASoC: Failed to create card debugfs directory\n");
434                 return;
435         }
436 
437         card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
438                                                     card->debugfs_card_root,
439                                                     &card->pop_time);
440         if (!card->debugfs_pop_time)
441                 dev_warn(card->dev,
442                        "ASoC: Failed to create pop time debugfs file\n");
443 }
444 
445 static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
446 {
447         debugfs_remove_recursive(card->debugfs_card_root);
448 }
449 
450 #else
451 
452 #define soc_init_codec_debugfs NULL
453 
454 static inline void soc_init_component_debugfs(
455         struct snd_soc_component *component)
456 {
457 }
458 
459 static inline void soc_cleanup_component_debugfs(
460         struct snd_soc_component *component)
461 {
462 }
463 
464 static inline void soc_init_card_debugfs(struct snd_soc_card *card)
465 {
466 }
467 
468 static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
469 {
470 }
471 #endif
472 
473 struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
474                 const char *dai_link, int stream)
475 {
476         int i;
477 
478         for (i = 0; i < card->num_links; i++) {
479                 if (card->rtd[i].dai_link->no_pcm &&
480                         !strcmp(card->rtd[i].dai_link->name, dai_link))
481                         return card->rtd[i].pcm->streams[stream].substream;
482         }
483         dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link);
484         return NULL;
485 }
486 EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
487 
488 struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
489                 const char *dai_link)
490 {
491         int i;
492 
493         for (i = 0; i < card->num_links; i++) {
494                 if (!strcmp(card->rtd[i].dai_link->name, dai_link))
495                         return &card->rtd[i];
496         }
497         dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
498         return NULL;
499 }
500 EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
501 
502 #ifdef CONFIG_SND_SOC_AC97_BUS
503 /* unregister ac97 codec */
504 static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
505 {
506         if (codec->ac97->dev.bus)
507                 device_unregister(&codec->ac97->dev);
508         return 0;
509 }
510 
511 /* stop no dev release warning */
512 static void soc_ac97_device_release(struct device *dev){}
513 
514 /* register ac97 codec to bus */
515 static int soc_ac97_dev_register(struct snd_soc_codec *codec)
516 {
517         int err;
518 
519         codec->ac97->dev.bus = &ac97_bus_type;
520         codec->ac97->dev.parent = codec->component.card->dev;
521         codec->ac97->dev.release = soc_ac97_device_release;
522 
523         dev_set_name(&codec->ac97->dev, "%d-%d:%s",
524                      codec->component.card->snd_card->number, 0,
525                      codec->component.name);
526         err = device_register(&codec->ac97->dev);
527         if (err < 0) {
528                 dev_err(codec->dev, "ASoC: Can't register ac97 bus\n");
529                 codec->ac97->dev.bus = NULL;
530                 return err;
531         }
532         return 0;
533 }
534 #endif
535 
536 static void codec2codec_close_delayed_work(struct work_struct *work)
537 {
538         /* Currently nothing to do for c2c links
539          * Since c2c links are internal nodes in the DAPM graph and
540          * don't interface with the outside world or application layer
541          * we don't have to do any special handling on close.
542          */
543 }
544 
545 #ifdef CONFIG_PM_SLEEP
546 /* powers down audio subsystem for suspend */
547 int snd_soc_suspend(struct device *dev)
548 {
549         struct snd_soc_card *card = dev_get_drvdata(dev);
550         struct snd_soc_codec *codec;
551         int i, j;
552 
553         /* If the card is not initialized yet there is nothing to do */
554         if (!card->instantiated)
555                 return 0;
556 
557         /* Due to the resume being scheduled into a workqueue we could
558         * suspend before that's finished - wait for it to complete.
559          */
560         snd_power_lock(card->snd_card);
561         snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
562         snd_power_unlock(card->snd_card);
563 
564         /* we're going to block userspace touching us until resume completes */
565         snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
566 
567         /* mute any active DACs */
568         for (i = 0; i < card->num_rtd; i++) {
569 
570                 if (card->rtd[i].dai_link->ignore_suspend)
571                         continue;
572 
573                 for (j = 0; j < card->rtd[i].num_codecs; j++) {
574                         struct snd_soc_dai *dai = card->rtd[i].codec_dais[j];
575                         struct snd_soc_dai_driver *drv = dai->driver;
576 
577                         if (drv->ops->digital_mute && dai->playback_active)
578                                 drv->ops->digital_mute(dai, 1);
579                 }
580         }
581 
582         /* suspend all pcms */
583         for (i = 0; i < card->num_rtd; i++) {
584                 if (card->rtd[i].dai_link->ignore_suspend)
585                         continue;
586 
587                 snd_pcm_suspend_all(card->rtd[i].pcm);
588         }
589 
590         if (card->suspend_pre)
591                 card->suspend_pre(card);
592 
593         for (i = 0; i < card->num_rtd; i++) {
594                 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
595                 struct snd_soc_platform *platform = card->rtd[i].platform;
596 
597                 if (card->rtd[i].dai_link->ignore_suspend)
598                         continue;
599 
600                 if (cpu_dai->driver->suspend && !cpu_dai->driver->ac97_control)
601                         cpu_dai->driver->suspend(cpu_dai);
602                 if (platform->driver->suspend && !platform->suspended) {
603                         platform->driver->suspend(cpu_dai);
604                         platform->suspended = 1;
605                 }
606         }
607 
608         /* close any waiting streams and save state */
609         for (i = 0; i < card->num_rtd; i++) {
610                 struct snd_soc_dai **codec_dais = card->rtd[i].codec_dais;
611                 flush_delayed_work(&card->rtd[i].delayed_work);
612                 for (j = 0; j < card->rtd[i].num_codecs; j++) {
613                         codec_dais[j]->codec->dapm.suspend_bias_level =
614                                         codec_dais[j]->codec->dapm.bias_level;
615                 }
616         }
617 
618         for (i = 0; i < card->num_rtd; i++) {
619 
620                 if (card->rtd[i].dai_link->ignore_suspend)
621                         continue;
622 
623                 snd_soc_dapm_stream_event(&card->rtd[i],
624                                           SNDRV_PCM_STREAM_PLAYBACK,
625                                           SND_SOC_DAPM_STREAM_SUSPEND);
626 
627                 snd_soc_dapm_stream_event(&card->rtd[i],
628                                           SNDRV_PCM_STREAM_CAPTURE,
629                                           SND_SOC_DAPM_STREAM_SUSPEND);
630         }
631 
632         /* Recheck all analogue paths too */
633         dapm_mark_io_dirty(&card->dapm);
634         snd_soc_dapm_sync(&card->dapm);
635 
636         /* suspend all CODECs */
637         list_for_each_entry(codec, &card->codec_dev_list, card_list) {
638                 /* If there are paths active then the CODEC will be held with
639                  * bias _ON and should not be suspended. */
640                 if (!codec->suspended) {
641                         switch (codec->dapm.bias_level) {
642                         case SND_SOC_BIAS_STANDBY:
643                                 /*
644                                  * If the CODEC is capable of idle
645                                  * bias off then being in STANDBY
646                                  * means it's doing something,
647                                  * otherwise fall through.
648                                  */
649                                 if (codec->dapm.idle_bias_off) {
650                                         dev_dbg(codec->dev,
651                                                 "ASoC: idle_bias_off CODEC on over suspend\n");
652                                         break;
653                                 }
654 
655                         case SND_SOC_BIAS_OFF:
656                                 if (codec->driver->suspend)
657                                         codec->driver->suspend(codec);
658                                 codec->suspended = 1;
659                                 codec->cache_sync = 1;
660                                 if (codec->component.regmap)
661                                         regcache_mark_dirty(codec->component.regmap);
662                                 /* deactivate pins to sleep state */
663                                 pinctrl_pm_select_sleep_state(codec->dev);
664                                 break;
665                         default:
666                                 dev_dbg(codec->dev,
667                                         "ASoC: CODEC is on over suspend\n");
668                                 break;
669                         }
670                 }
671         }
672 
673         for (i = 0; i < card->num_rtd; i++) {
674                 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
675 
676                 if (card->rtd[i].dai_link->ignore_suspend)
677                         continue;
678 
679                 if (cpu_dai->driver->suspend && cpu_dai->driver->ac97_control)
680                         cpu_dai->driver->suspend(cpu_dai);
681 
682                 /* deactivate pins to sleep state */
683                 pinctrl_pm_select_sleep_state(cpu_dai->dev);
684         }
685 
686         if (card->suspend_post)
687                 card->suspend_post(card);
688 
689         return 0;
690 }
691 EXPORT_SYMBOL_GPL(snd_soc_suspend);
692 
693 /* deferred resume work, so resume can complete before we finished
694  * setting our codec back up, which can be very slow on I2C
695  */
696 static void soc_resume_deferred(struct work_struct *work)
697 {
698         struct snd_soc_card *card =
699                         container_of(work, struct snd_soc_card, deferred_resume_work);
700         struct snd_soc_codec *codec;
701         int i, j;
702 
703         /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
704          * so userspace apps are blocked from touching us
705          */
706 
707         dev_dbg(card->dev, "ASoC: starting resume work\n");
708 
709         /* Bring us up into D2 so that DAPM starts enabling things */
710         snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
711 
712         if (card->resume_pre)
713                 card->resume_pre(card);
714 
715         /* resume AC97 DAIs */
716         for (i = 0; i < card->num_rtd; i++) {
717                 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
718 
719                 if (card->rtd[i].dai_link->ignore_suspend)
720                         continue;
721 
722                 if (cpu_dai->driver->resume && cpu_dai->driver->ac97_control)
723                         cpu_dai->driver->resume(cpu_dai);
724         }
725 
726         list_for_each_entry(codec, &card->codec_dev_list, card_list) {
727                 /* If the CODEC was idle over suspend then it will have been
728                  * left with bias OFF or STANDBY and suspended so we must now
729                  * resume.  Otherwise the suspend was suppressed.
730                  */
731                 if (codec->suspended) {
732                         switch (codec->dapm.bias_level) {
733                         case SND_SOC_BIAS_STANDBY:
734                         case SND_SOC_BIAS_OFF:
735                                 if (codec->driver->resume)
736                                         codec->driver->resume(codec);
737                                 codec->suspended = 0;
738                                 break;
739                         default:
740                                 dev_dbg(codec->dev,
741                                         "ASoC: CODEC was on over suspend\n");
742                                 break;
743                         }
744                 }
745         }
746 
747         for (i = 0; i < card->num_rtd; i++) {
748 
749                 if (card->rtd[i].dai_link->ignore_suspend)
750                         continue;
751 
752                 snd_soc_dapm_stream_event(&card->rtd[i],
753                                           SNDRV_PCM_STREAM_PLAYBACK,
754                                           SND_SOC_DAPM_STREAM_RESUME);
755 
756                 snd_soc_dapm_stream_event(&card->rtd[i],
757                                           SNDRV_PCM_STREAM_CAPTURE,
758                                           SND_SOC_DAPM_STREAM_RESUME);
759         }
760 
761         /* unmute any active DACs */
762         for (i = 0; i < card->num_rtd; i++) {
763 
764                 if (card->rtd[i].dai_link->ignore_suspend)
765                         continue;
766 
767                 for (j = 0; j < card->rtd[i].num_codecs; j++) {
768                         struct snd_soc_dai *dai = card->rtd[i].codec_dais[j];
769                         struct snd_soc_dai_driver *drv = dai->driver;
770 
771                         if (drv->ops->digital_mute && dai->playback_active)
772                                 drv->ops->digital_mute(dai, 0);
773                 }
774         }
775 
776         for (i = 0; i < card->num_rtd; i++) {
777                 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
778                 struct snd_soc_platform *platform = card->rtd[i].platform;
779 
780                 if (card->rtd[i].dai_link->ignore_suspend)
781                         continue;
782 
783                 if (cpu_dai->driver->resume && !cpu_dai->driver->ac97_control)
784                         cpu_dai->driver->resume(cpu_dai);
785                 if (platform->driver->resume && platform->suspended) {
786                         platform->driver->resume(cpu_dai);
787                         platform->suspended = 0;
788                 }
789         }
790 
791         if (card->resume_post)
792                 card->resume_post(card);
793 
794         dev_dbg(card->dev, "ASoC: resume work completed\n");
795 
796         /* userspace can access us now we are back as we were before */
797         snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
798 
799         /* Recheck all analogue paths too */
800         dapm_mark_io_dirty(&card->dapm);
801         snd_soc_dapm_sync(&card->dapm);
802 }
803 
804 /* powers up audio subsystem after a suspend */
805 int snd_soc_resume(struct device *dev)
806 {
807         struct snd_soc_card *card = dev_get_drvdata(dev);
808         int i, ac97_control = 0;
809 
810         /* If the card is not initialized yet there is nothing to do */
811         if (!card->instantiated)
812                 return 0;
813 
814         /* activate pins from sleep state */
815         for (i = 0; i < card->num_rtd; i++) {
816                 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
817                 struct snd_soc_dai **codec_dais = rtd->codec_dais;
818                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
819                 int j;
820 
821                 if (cpu_dai->active)
822                         pinctrl_pm_select_default_state(cpu_dai->dev);
823 
824                 for (j = 0; j < rtd->num_codecs; j++) {
825                         struct snd_soc_dai *codec_dai = codec_dais[j];
826                         if (codec_dai->active)
827                                 pinctrl_pm_select_default_state(codec_dai->dev);
828                 }
829         }
830 
831         /* AC97 devices might have other drivers hanging off them so
832          * need to resume immediately.  Other drivers don't have that
833          * problem and may take a substantial amount of time to resume
834          * due to I/O costs and anti-pop so handle them out of line.
835          */
836         for (i = 0; i < card->num_rtd; i++) {
837                 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
838                 ac97_control |= cpu_dai->driver->ac97_control;
839         }
840         if (ac97_control) {
841                 dev_dbg(dev, "ASoC: Resuming AC97 immediately\n");
842                 soc_resume_deferred(&card->deferred_resume_work);
843         } else {
844                 dev_dbg(dev, "ASoC: Scheduling resume work\n");
845                 if (!schedule_work(&card->deferred_resume_work))
846                         dev_err(dev, "ASoC: resume work item may be lost\n");
847         }
848 
849         return 0;
850 }
851 EXPORT_SYMBOL_GPL(snd_soc_resume);
852 #else
853 #define snd_soc_suspend NULL
854 #define snd_soc_resume NULL
855 #endif
856 
857 static const struct snd_soc_dai_ops null_dai_ops = {
858 };
859 
860 static struct snd_soc_component *soc_find_component(
861         const struct device_node *of_node, const char *name)
862 {
863         struct snd_soc_component *component;
864 
865         list_for_each_entry(component, &component_list, list) {
866                 if (of_node) {
867                         if (component->dev->of_node == of_node)
868                                 return component;
869                 } else if (strcmp(component->name, name) == 0) {
870                         return component;
871                 }
872         }
873 
874         return NULL;
875 }
876 
877 static struct snd_soc_dai *snd_soc_find_dai(
878         const struct snd_soc_dai_link_component *dlc)
879 {
880         struct snd_soc_component *component;
881         struct snd_soc_dai *dai;
882 
883         /* Find CPU DAI from registered DAIs*/
884         list_for_each_entry(component, &component_list, list) {
885                 if (dlc->of_node && component->dev->of_node != dlc->of_node)
886                         continue;
887                 if (dlc->name && strcmp(component->name, dlc->name))
888                         continue;
889                 list_for_each_entry(dai, &component->dai_list, list) {
890                         if (dlc->dai_name && strcmp(dai->name, dlc->dai_name))
891                                 continue;
892 
893                         return dai;
894                 }
895         }
896 
897         return NULL;
898 }
899 
900 static int soc_bind_dai_link(struct snd_soc_card *card, int num)
901 {
902         struct snd_soc_dai_link *dai_link = &card->dai_link[num];
903         struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
904         struct snd_soc_dai_link_component *codecs = dai_link->codecs;
905         struct snd_soc_dai_link_component cpu_dai_component;
906         struct snd_soc_dai **codec_dais = rtd->codec_dais;
907         struct snd_soc_platform *platform;
908         const char *platform_name;
909         int i;
910 
911         dev_dbg(card->dev, "ASoC: binding %s at idx %d\n", dai_link->name, num);
912 
913         cpu_dai_component.name = dai_link->cpu_name;
914         cpu_dai_component.of_node = dai_link->cpu_of_node;
915         cpu_dai_component.dai_name = dai_link->cpu_dai_name;
916         rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);
917         if (!rtd->cpu_dai) {
918                 dev_err(card->dev, "ASoC: CPU DAI %s not registered\n",
919                         dai_link->cpu_dai_name);
920                 return -EPROBE_DEFER;
921         }
922 
923         rtd->num_codecs = dai_link->num_codecs;
924 
925         /* Find CODEC from registered CODECs */
926         for (i = 0; i < rtd->num_codecs; i++) {
927                 codec_dais[i] = snd_soc_find_dai(&codecs[i]);
928                 if (!codec_dais[i]) {
929                         dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
930                                 codecs[i].dai_name);
931                         return -EPROBE_DEFER;
932                 }
933         }
934 
935         /* Single codec links expect codec and codec_dai in runtime data */
936         rtd->codec_dai = codec_dais[0];
937         rtd->codec = rtd->codec_dai->codec;
938 
939         /* if there's no platform we match on the empty platform */
940         platform_name = dai_link->platform_name;
941         if (!platform_name && !dai_link->platform_of_node)
942                 platform_name = "snd-soc-dummy";
943 
944         /* find one from the set of registered platforms */
945         list_for_each_entry(platform, &platform_list, list) {
946                 if (dai_link->platform_of_node) {
947                         if (platform->dev->of_node !=
948                             dai_link->platform_of_node)
949                                 continue;
950                 } else {
951                         if (strcmp(platform->component.name, platform_name))
952                                 continue;
953                 }
954 
955                 rtd->platform = platform;
956         }
957         if (!rtd->platform) {
958                 dev_err(card->dev, "ASoC: platform %s not registered\n",
959                         dai_link->platform_name);
960                 return -EPROBE_DEFER;
961         }
962 
963         card->num_rtd++;
964 
965         return 0;
966 }
967 
968 static void soc_remove_component(struct snd_soc_component *component)
969 {
970         if (!component->probed)
971                 return;
972 
973         /* This is a HACK and will be removed soon */
974         if (component->codec)
975                 list_del(&component->codec->card_list);
976 
977         if (component->remove)
978                 component->remove(component);
979 
980         snd_soc_dapm_free(snd_soc_component_get_dapm(component));
981 
982         soc_cleanup_component_debugfs(component);
983         component->probed = 0;
984         module_put(component->dev->driver->owner);
985 }
986 
987 static void soc_remove_dai(struct snd_soc_dai *dai, int order)
988 {
989         int err;
990 
991         if (dai && dai->probed &&
992                         dai->driver->remove_order == order) {
993                 if (dai->driver->remove) {
994                         err = dai->driver->remove(dai);
995                         if (err < 0)
996                                 dev_err(dai->dev,
997                                         "ASoC: failed to remove %s: %d\n",
998                                         dai->name, err);
999                 }
1000                 dai->probed = 0;
1001         }
1002 }
1003 
1004 static void soc_remove_link_dais(struct snd_soc_card *card, int num, int order)
1005 {
1006         struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1007         int i;
1008 
1009         /* unregister the rtd device */
1010         if (rtd->dev_registered) {
1011                 device_remove_file(rtd->dev, &dev_attr_pmdown_time);
1012                 device_remove_file(rtd->dev, &dev_attr_codec_reg);
1013                 device_unregister(rtd->dev);
1014                 rtd->dev_registered = 0;
1015         }
1016 
1017         /* remove the CODEC DAI */
1018         for (i = 0; i < rtd->num_codecs; i++)
1019                 soc_remove_dai(rtd->codec_dais[i], order);
1020 
1021         soc_remove_dai(rtd->cpu_dai, order);
1022 }
1023 
1024 static void soc_remove_link_components(struct snd_soc_card *card, int num,
1025                                        int order)
1026 {
1027         struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1028         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1029         struct snd_soc_platform *platform = rtd->platform;
1030         struct snd_soc_component *component;
1031         int i;
1032 
1033         /* remove the platform */
1034         if (platform && platform->component.driver->remove_order == order)
1035                 soc_remove_component(&platform->component);
1036 
1037         /* remove the CODEC-side CODEC */
1038         for (i = 0; i < rtd->num_codecs; i++) {
1039                 component = rtd->codec_dais[i]->component;
1040                 if (component->driver->remove_order == order)
1041                         soc_remove_component(component);
1042         }
1043 
1044         /* remove any CPU-side CODEC */
1045         if (cpu_dai) {
1046                 if (cpu_dai->component->driver->remove_order == order)
1047                         soc_remove_component(cpu_dai->component);
1048         }
1049 }
1050 
1051 static void soc_remove_dai_links(struct snd_soc_card *card)
1052 {
1053         int dai, order;
1054 
1055         for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1056                         order++) {
1057                 for (dai = 0; dai < card->num_rtd; dai++)
1058                         soc_remove_link_dais(card, dai, order);
1059         }
1060 
1061         for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1062                         order++) {
1063                 for (dai = 0; dai < card->num_rtd; dai++)
1064                         soc_remove_link_components(card, dai, order);
1065         }
1066 
1067         card->num_rtd = 0;
1068 }
1069 
1070 static void soc_set_name_prefix(struct snd_soc_card *card,
1071                                 struct snd_soc_component *component)
1072 {
1073         int i;
1074 
1075         if (card->codec_conf == NULL)
1076                 return;
1077 
1078         for (i = 0; i < card->num_configs; i++) {
1079                 struct snd_soc_codec_conf *map = &card->codec_conf[i];
1080                 if (map->of_node && component->dev->of_node != map->of_node)
1081                         continue;
1082                 if (map->dev_name && strcmp(component->name, map->dev_name))
1083                         continue;
1084                 component->name_prefix = map->name_prefix;
1085                 break;
1086         }
1087 }
1088 
1089 static int soc_probe_component(struct snd_soc_card *card,
1090         struct snd_soc_component *component)
1091 {
1092         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
1093         struct snd_soc_dai *dai;
1094         int ret;
1095 
1096         if (component->probed)
1097                 return 0;
1098 
1099         component->card = card;
1100         dapm->card = card;
1101         soc_set_name_prefix(card, component);
1102 
1103         if (!try_module_get(component->dev->driver->owner))
1104                 return -ENODEV;
1105 
1106         soc_init_component_debugfs(component);
1107 
1108         if (component->dapm_widgets) {
1109                 ret = snd_soc_dapm_new_controls(dapm, component->dapm_widgets,
1110                         component->num_dapm_widgets);
1111 
1112                 if (ret != 0) {
1113                         dev_err(component->dev,
1114                                 "Failed to create new controls %d\n", ret);
1115                         goto err_probe;
1116                 }
1117         }
1118 
1119         list_for_each_entry(dai, &component->dai_list, list) {
1120                 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
1121                 if (ret != 0) {
1122                         dev_err(component->dev,
1123                                 "Failed to create DAI widgets %d\n", ret);
1124                         goto err_probe;
1125                 }
1126         }
1127 
1128         if (component->probe) {
1129                 ret = component->probe(component);
1130                 if (ret < 0) {
1131                         dev_err(component->dev,
1132                                 "ASoC: failed to probe component %d\n", ret);
1133                         goto err_probe;
1134                 }
1135 
1136                 WARN(dapm->idle_bias_off &&
1137                         dapm->bias_level != SND_SOC_BIAS_OFF,
1138                         "codec %s can not start from non-off bias with idle_bias_off==1\n",
1139                         component->name);
1140         }
1141 
1142         if (component->controls)
1143                 snd_soc_add_component_controls(component, component->controls,
1144                                      component->num_controls);
1145         if (component->dapm_routes)
1146                 snd_soc_dapm_add_routes(dapm, component->dapm_routes,
1147                                         component->num_dapm_routes);
1148 
1149         component->probed = 1;
1150         list_add(&dapm->list, &card->dapm_list);
1151 
1152         /* This is a HACK and will be removed soon */
1153         if (component->codec)
1154                 list_add(&component->codec->card_list, &card->codec_dev_list);
1155 
1156         return 0;
1157 
1158 err_probe:
1159         soc_cleanup_component_debugfs(component);
1160         module_put(component->dev->driver->owner);
1161 
1162         return ret;
1163 }
1164 
1165 static void rtd_release(struct device *dev)
1166 {
1167         kfree(dev);
1168 }
1169 
1170 static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
1171         const char *name)
1172 {
1173         int ret = 0;
1174 
1175         /* register the rtd device */
1176         rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1177         if (!rtd->dev)
1178                 return -ENOMEM;
1179         device_initialize(rtd->dev);
1180         rtd->dev->parent = rtd->card->dev;
1181         rtd->dev->release = rtd_release;
1182         dev_set_name(rtd->dev, "%s", name);
1183         dev_set_drvdata(rtd->dev, rtd);
1184         mutex_init(&rtd->pcm_mutex);
1185         INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
1186         INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
1187         INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
1188         INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
1189         ret = device_add(rtd->dev);
1190         if (ret < 0) {
1191                 /* calling put_device() here to free the rtd->dev */
1192                 put_device(rtd->dev);
1193                 dev_err(rtd->card->dev,
1194                         "ASoC: failed to register runtime device: %d\n", ret);
1195                 return ret;
1196         }
1197         rtd->dev_registered = 1;
1198 
1199         if (rtd->codec) {
1200                 /* add DAPM sysfs entries for this codec */
1201                 ret = snd_soc_dapm_sys_add(rtd->dev);
1202                 if (ret < 0)
1203                         dev_err(rtd->dev,
1204                                 "ASoC: failed to add codec dapm sysfs entries: %d\n",
1205                                 ret);
1206 
1207                 /* add codec sysfs entries */
1208                 ret = device_create_file(rtd->dev, &dev_attr_codec_reg);
1209                 if (ret < 0)
1210                         dev_err(rtd->dev,
1211                                 "ASoC: failed to add codec sysfs files: %d\n",
1212                                 ret);
1213         }
1214 
1215         return 0;
1216 }
1217 
1218 static int soc_probe_link_components(struct snd_soc_card *card, int num,
1219                                      int order)
1220 {
1221         struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1222         struct snd_soc_platform *platform = rtd->platform;
1223         struct snd_soc_component *component;
1224         int i, ret;
1225 
1226         /* probe the CPU-side component, if it is a CODEC */
1227         component = rtd->cpu_dai->component;
1228         if (component->driver->probe_order == order) {
1229                 ret = soc_probe_component(card, component);
1230                 if (ret < 0)
1231                         return ret;
1232         }
1233 
1234         /* probe the CODEC-side components */
1235         for (i = 0; i < rtd->num_codecs; i++) {
1236                 component = rtd->codec_dais[i]->component;
1237                 if (component->driver->probe_order == order) {
1238                         ret = soc_probe_component(card, component);
1239                         if (ret < 0)
1240                                 return ret;
1241                 }
1242         }
1243 
1244         /* probe the platform */
1245         if (platform->component.driver->probe_order == order) {
1246                 ret = soc_probe_component(card, &platform->component);
1247                 if (ret < 0)
1248                         return ret;
1249         }
1250 
1251         return 0;
1252 }
1253 
1254 static int soc_probe_codec_dai(struct snd_soc_card *card,
1255                                struct snd_soc_dai *codec_dai,
1256                                int order)
1257 {
1258         int ret;
1259 
1260         if (!codec_dai->probed && codec_dai->driver->probe_order == order) {
1261                 if (codec_dai->driver->probe) {
1262                         ret = codec_dai->driver->probe(codec_dai);
1263                         if (ret < 0) {
1264                                 dev_err(codec_dai->dev,
1265                                         "ASoC: failed to probe CODEC DAI %s: %d\n",
1266                                         codec_dai->name, ret);
1267                                 return ret;
1268                         }
1269                 }
1270 
1271                 /* mark codec_dai as probed and add to card dai list */
1272                 codec_dai->probed = 1;
1273         }
1274 
1275         return 0;
1276 }
1277 
1278 static int soc_link_dai_widgets(struct snd_soc_card *card,
1279                                 struct snd_soc_dai_link *dai_link,
1280                                 struct snd_soc_pcm_runtime *rtd)
1281 {
1282         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1283         struct snd_soc_dai *codec_dai = rtd->codec_dai;
1284         struct snd_soc_dapm_widget *play_w, *capture_w;
1285         int ret;
1286 
1287         if (rtd->num_codecs > 1)
1288                 dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");
1289 
1290         /* link the DAI widgets */
1291         play_w = codec_dai->playback_widget;
1292         capture_w = cpu_dai->capture_widget;
1293         if (play_w && capture_w) {
1294                 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
1295                                            capture_w, play_w);
1296                 if (ret != 0) {
1297                         dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1298                                 play_w->name, capture_w->name, ret);
1299                         return ret;
1300                 }
1301         }
1302 
1303         play_w = cpu_dai->playback_widget;
1304         capture_w = codec_dai->capture_widget;
1305         if (play_w && capture_w) {
1306                 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
1307                                            capture_w, play_w);
1308                 if (ret != 0) {
1309                         dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1310                                 play_w->name, capture_w->name, ret);
1311                         return ret;
1312                 }
1313         }
1314 
1315         return 0;
1316 }
1317 
1318 static int soc_probe_link_dais(struct snd_soc_card *card, int num, int order)
1319 {
1320         struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1321         struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1322         struct snd_soc_platform *platform = rtd->platform;
1323         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1324         int i, ret;
1325 
1326         dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
1327                         card->name, num, order);
1328 
1329         /* config components */
1330         cpu_dai->platform = platform;
1331         cpu_dai->card = card;
1332         for (i = 0; i < rtd->num_codecs; i++)
1333                 rtd->codec_dais[i]->card = card;
1334 
1335         /* set default power off timeout */
1336         rtd->pmdown_time = pmdown_time;
1337 
1338         /* probe the cpu_dai */
1339         if (!cpu_dai->probed &&
1340                         cpu_dai->driver->probe_order == order) {
1341                 if (cpu_dai->driver->probe) {
1342                         ret = cpu_dai->driver->probe(cpu_dai);
1343                         if (ret < 0) {
1344                                 dev_err(cpu_dai->dev,
1345                                         "ASoC: failed to probe CPU DAI %s: %d\n",
1346                                         cpu_dai->name, ret);
1347                                 return ret;
1348                         }
1349                 }
1350                 cpu_dai->probed = 1;
1351         }
1352 
1353         /* probe the CODEC DAI */
1354         for (i = 0; i < rtd->num_codecs; i++) {
1355                 ret = soc_probe_codec_dai(card, rtd->codec_dais[i], order);
1356                 if (ret)
1357                         return ret;
1358         }
1359 
1360         /* complete DAI probe during last probe */
1361         if (order != SND_SOC_COMP_ORDER_LAST)
1362                 return 0;
1363 
1364         /* do machine specific initialization */
1365         if (dai_link->init) {
1366                 ret = dai_link->init(rtd);
1367                 if (ret < 0) {
1368                         dev_err(card->dev, "ASoC: failed to init %s: %d\n",
1369                                 dai_link->name, ret);
1370                         return ret;
1371                 }
1372         }
1373 
1374         ret = soc_post_component_init(rtd, dai_link->name);
1375         if (ret)
1376                 return ret;
1377 
1378 #ifdef CONFIG_DEBUG_FS
1379         /* add DPCM sysfs entries */
1380         if (dai_link->dynamic) {
1381                 ret = soc_dpcm_debugfs_add(rtd);
1382                 if (ret < 0) {
1383                         dev_err(rtd->dev,
1384                                 "ASoC: failed to add dpcm sysfs entries: %d\n",
1385                                 ret);
1386                         return ret;
1387                 }
1388         }
1389 #endif
1390 
1391         ret = device_create_file(rtd->dev, &dev_attr_pmdown_time);
1392         if (ret < 0)
1393                 dev_warn(rtd->dev, "ASoC: failed to add pmdown_time sysfs: %d\n",
1394                         ret);
1395 
1396         if (cpu_dai->driver->compress_dai) {
1397                 /*create compress_device"*/
1398                 ret = soc_new_compress(rtd, num);
1399                 if (ret < 0) {
1400                         dev_err(card->dev, "ASoC: can't create compress %s\n",
1401                                          dai_link->stream_name);
1402                         return ret;
1403                 }
1404         } else {
1405 
1406                 if (!dai_link->params) {
1407                         /* create the pcm */
1408                         ret = soc_new_pcm(rtd, num);
1409                         if (ret < 0) {
1410                                 dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
1411                                        dai_link->stream_name, ret);
1412                                 return ret;
1413                         }
1414                 } else {
1415                         INIT_DELAYED_WORK(&rtd->delayed_work,
1416                                                 codec2codec_close_delayed_work);
1417 
1418                         /* link the DAI widgets */
1419                         ret = soc_link_dai_widgets(card, dai_link, rtd);
1420                         if (ret)
1421                                 return ret;
1422                 }
1423         }
1424 
1425         /* add platform data for AC97 devices */
1426         for (i = 0; i < rtd->num_codecs; i++) {
1427                 if (rtd->codec_dais[i]->driver->ac97_control)
1428                         snd_ac97_dev_add_pdata(rtd->codec_dais[i]->codec->ac97,
1429                                                rtd->cpu_dai->ac97_pdata);
1430         }
1431 
1432         return 0;
1433 }
1434 
1435 #ifdef CONFIG_SND_SOC_AC97_BUS
1436 static int soc_register_ac97_codec(struct snd_soc_codec *codec,
1437                                    struct snd_soc_dai *codec_dai)
1438 {
1439         int ret;
1440 
1441         /* Only instantiate AC97 if not already done by the adaptor
1442          * for the generic AC97 subsystem.
1443          */
1444         if (codec_dai->driver->ac97_control && !codec->ac97_registered) {
1445                 /*
1446                  * It is possible that the AC97 device is already registered to
1447                  * the device subsystem. This happens when the device is created
1448                  * via snd_ac97_mixer(). Currently only SoC codec that does so
1449                  * is the generic AC97 glue but others migh emerge.
1450                  *
1451                  * In those cases we don't try to register the device again.
1452                  */
1453                 if (!codec->ac97_created)
1454                         return 0;
1455 
1456                 ret = soc_ac97_dev_register(codec);
1457                 if (ret < 0) {
1458                         dev_err(codec->dev,
1459                                 "ASoC: AC97 device register failed: %d\n", ret);
1460                         return ret;
1461                 }
1462 
1463                 codec->ac97_registered = 1;
1464         }
1465         return 0;
1466 }
1467 
1468 static void soc_unregister_ac97_codec(struct snd_soc_codec *codec)
1469 {
1470         if (codec->ac97_registered) {
1471                 soc_ac97_dev_unregister(codec);
1472                 codec->ac97_registered = 0;
1473         }
1474 }
1475 
1476 static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime *rtd)
1477 {
1478         int i, ret;
1479 
1480         for (i = 0; i < rtd->num_codecs; i++) {
1481                 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
1482 
1483                 ret = soc_register_ac97_codec(codec_dai->codec, codec_dai);
1484                 if (ret) {
1485                         while (--i >= 0)
1486                                 soc_unregister_ac97_codec(codec_dai->codec);
1487                         return ret;
1488                 }
1489         }
1490 
1491         return 0;
1492 }
1493 
1494 static void soc_unregister_ac97_dai_link(struct snd_soc_pcm_runtime *rtd)
1495 {
1496         int i;
1497 
1498         for (i = 0; i < rtd->num_codecs; i++)
1499                 soc_unregister_ac97_codec(rtd->codec_dais[i]->codec);
1500 }
1501 #endif
1502 
1503 static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
1504 {
1505         struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
1506         struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
1507         const char *name = aux_dev->codec_name;
1508 
1509         rtd->component = soc_find_component(aux_dev->codec_of_node, name);
1510         if (!rtd->component) {
1511                 if (aux_dev->codec_of_node)
1512                         name = of_node_full_name(aux_dev->codec_of_node);
1513 
1514                 dev_err(card->dev, "ASoC: %s not registered\n", name);
1515                 return -EPROBE_DEFER;
1516         }
1517 
1518         /*
1519          * Some places still reference rtd->codec, so we have to keep that
1520          * initialized if the component is a CODEC. Once all those references
1521          * have been removed, this code can be removed as well.
1522          */
1523          rtd->codec = rtd->component->codec;
1524 
1525         return 0;
1526 }
1527 
1528 static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
1529 {
1530         struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
1531         struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
1532         int ret;
1533 
1534         ret = soc_probe_component(card, rtd->component);
1535         if (ret < 0)
1536                 return ret;
1537 
1538         /* do machine specific initialization */
1539         if (aux_dev->init) {
1540                 ret = aux_dev->init(rtd->component);
1541                 if (ret < 0) {
1542                         dev_err(card->dev, "ASoC: failed to init %s: %d\n",
1543                                 aux_dev->name, ret);
1544                         return ret;
1545                 }
1546         }
1547 
1548         return soc_post_component_init(rtd, aux_dev->name);
1549 }
1550 
1551 static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
1552 {
1553         struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
1554         struct snd_soc_component *component = rtd->component;
1555 
1556         /* unregister the rtd device */
1557         if (rtd->dev_registered) {
1558                 device_remove_file(rtd->dev, &dev_attr_codec_reg);
1559                 device_unregister(rtd->dev);
1560                 rtd->dev_registered = 0;
1561         }
1562 
1563         if (component && component->probed)
1564                 soc_remove_component(component);
1565 }
1566 
1567 static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
1568 {
1569         int ret;
1570 
1571         if (codec->cache_init)
1572                 return 0;
1573 
1574         ret = snd_soc_cache_init(codec);
1575         if (ret < 0) {
1576                 dev_err(codec->dev,
1577                         "ASoC: Failed to set cache compression type: %d\n",
1578                         ret);
1579                 return ret;
1580         }
1581         codec->cache_init = 1;
1582         return 0;
1583 }
1584 
1585 static int snd_soc_instantiate_card(struct snd_soc_card *card)
1586 {
1587         struct snd_soc_codec *codec;
1588         struct snd_soc_dai_link *dai_link;
1589         int ret, i, order, dai_fmt;
1590 
1591         mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
1592 
1593         /* bind DAIs */
1594         for (i = 0; i < card->num_links; i++) {
1595                 ret = soc_bind_dai_link(card, i);
1596                 if (ret != 0)
1597                         goto base_error;
1598         }
1599 
1600         /* bind aux_devs too */
1601         for (i = 0; i < card->num_aux_devs; i++) {
1602                 ret = soc_bind_aux_dev(card, i);
1603                 if (ret != 0)
1604                         goto base_error;
1605         }
1606 
1607         /* initialize the register cache for each available codec */
1608         list_for_each_entry(codec, &codec_list, list) {
1609                 if (codec->cache_init)
1610                         continue;
1611                 ret = snd_soc_init_codec_cache(codec);
1612                 if (ret < 0)
1613                         goto base_error;
1614         }
1615 
1616         /* card bind complete so register a sound card */
1617         ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
1618                         card->owner, 0, &card->snd_card);
1619         if (ret < 0) {
1620                 dev_err(card->dev,
1621                         "ASoC: can't create sound card for card %s: %d\n",
1622                         card->name, ret);
1623                 goto base_error;
1624         }
1625 
1626         card->dapm.bias_level = SND_SOC_BIAS_OFF;
1627         card->dapm.dev = card->dev;
1628         card->dapm.card = card;
1629         list_add(&card->dapm.list, &card->dapm_list);
1630 
1631 #ifdef CONFIG_DEBUG_FS
1632         snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
1633 #endif
1634 
1635 #ifdef CONFIG_PM_SLEEP
1636         /* deferred resume work */
1637         INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
1638 #endif
1639 
1640         if (card->dapm_widgets)
1641                 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
1642                                           card->num_dapm_widgets);
1643 
1644         /* initialise the sound card only once */
1645         if (card->probe) {
1646                 ret = card->probe(card);
1647                 if (ret < 0)
1648                         goto card_probe_error;
1649         }
1650 
1651         /* probe all components used by DAI links on this card */
1652         for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1653                         order++) {
1654                 for (i = 0; i < card->num_links; i++) {
1655                         ret = soc_probe_link_components(card, i, order);
1656                         if (ret < 0) {
1657                                 dev_err(card->dev,
1658                                         "ASoC: failed to instantiate card %d\n",
1659                                         ret);
1660                                 goto probe_dai_err;
1661                         }
1662                 }
1663         }
1664 
1665         /* probe all DAI links on this card */
1666         for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1667                         order++) {
1668                 for (i = 0; i < card->num_links; i++) {
1669                         ret = soc_probe_link_dais(card, i, order);
1670                         if (ret < 0) {
1671                                 dev_err(card->dev,
1672                                         "ASoC: failed to instantiate card %d\n",
1673                                         ret);
1674                                 goto probe_dai_err;
1675                         }
1676                 }
1677         }
1678 
1679         for (i = 0; i < card->num_aux_devs; i++) {
1680                 ret = soc_probe_aux_dev(card, i);
1681                 if (ret < 0) {
1682                         dev_err(card->dev,
1683                                 "ASoC: failed to add auxiliary devices %d\n",
1684                                 ret);
1685                         goto probe_aux_dev_err;
1686                 }
1687         }
1688 
1689         snd_soc_dapm_link_dai_widgets(card);
1690         snd_soc_dapm_connect_dai_link_widgets(card);
1691 
1692         if (card->controls)
1693                 snd_soc_add_card_controls(card, card->controls, card->num_controls);
1694 
1695         if (card->dapm_routes)
1696                 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
1697                                         card->num_dapm_routes);
1698 
1699         for (i = 0; i < card->num_links; i++) {
1700                 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1701                 dai_link = &card->dai_link[i];
1702                 dai_fmt = dai_link->dai_fmt;
1703 
1704                 if (dai_fmt) {
1705                         struct snd_soc_dai **codec_dais = rtd->codec_dais;
1706                         int j;
1707 
1708                         for (j = 0; j < rtd->num_codecs; j++) {
1709                                 struct snd_soc_dai *codec_dai = codec_dais[j];
1710 
1711                                 ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
1712                                 if (ret != 0 && ret != -ENOTSUPP)
1713                                         dev_warn(codec_dai->dev,
1714                                                  "ASoC: Failed to set DAI format: %d\n",
1715                                                  ret);
1716                         }
1717                 }
1718 
1719                 /* If this is a regular CPU link there will be a platform */
1720                 if (dai_fmt &&
1721                     (dai_link->platform_name || dai_link->platform_of_node)) {
1722                         ret = snd_soc_dai_set_fmt(card->rtd[i].cpu_dai,
1723                                                   dai_fmt);
1724                         if (ret != 0 && ret != -ENOTSUPP)
1725                                 dev_warn(card->rtd[i].cpu_dai->dev,
1726                                          "ASoC: Failed to set DAI format: %d\n",
1727                                          ret);
1728                 } else if (dai_fmt) {
1729                         /* Flip the polarity for the "CPU" end */
1730                         dai_fmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
1731                         switch (dai_link->dai_fmt &
1732                                 SND_SOC_DAIFMT_MASTER_MASK) {
1733                         case SND_SOC_DAIFMT_CBM_CFM:
1734                                 dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
1735                                 break;
1736                         case SND_SOC_DAIFMT_CBM_CFS:
1737                                 dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
1738                                 break;
1739                         case SND_SOC_DAIFMT_CBS_CFM:
1740                                 dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
1741                                 break;
1742                         case SND_SOC_DAIFMT_CBS_CFS:
1743                                 dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
1744                                 break;
1745                         }
1746 
1747                         ret = snd_soc_dai_set_fmt(card->rtd[i].cpu_dai,
1748                                                   dai_fmt);
1749                         if (ret != 0 && ret != -ENOTSUPP)
1750                                 dev_warn(card->rtd[i].cpu_dai->dev,
1751                                          "ASoC: Failed to set DAI format: %d\n",
1752                                          ret);
1753                 }
1754         }
1755 
1756         snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
1757                  "%s", card->name);
1758         snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
1759                  "%s", card->long_name ? card->long_name : card->name);
1760         snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
1761                  "%s", card->driver_name ? card->driver_name : card->name);
1762         for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
1763                 switch (card->snd_card->driver[i]) {
1764                 case '_':
1765                 case '-':
1766                 case '\0':
1767                         break;
1768                 default:
1769                         if (!isalnum(card->snd_card->driver[i]))
1770                                 card->snd_card->driver[i] = '_';
1771                         break;
1772                 }
1773         }
1774 
1775         if (card->late_probe) {
1776                 ret = card->late_probe(card);
1777                 if (ret < 0) {
1778                         dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
1779                                 card->name, ret);
1780                         goto probe_aux_dev_err;
1781                 }
1782         }
1783 
1784         if (card->fully_routed)
1785                 snd_soc_dapm_auto_nc_pins(card);
1786 
1787         snd_soc_dapm_new_widgets(card);
1788 
1789         ret = snd_card_register(card->snd_card);
1790         if (ret < 0) {
1791                 dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
1792                                 ret);
1793                 goto probe_aux_dev_err;
1794         }
1795 
1796 #ifdef CONFIG_SND_SOC_AC97_BUS
1797         /* register any AC97 codecs */
1798         for (i = 0; i < card->num_rtd; i++) {
1799                 ret = soc_register_ac97_dai_link(&card->rtd[i]);
1800                 if (ret < 0) {
1801                         dev_err(card->dev,
1802                                 "ASoC: failed to register AC97: %d\n", ret);
1803                         while (--i >= 0)
1804                                 soc_unregister_ac97_dai_link(&card->rtd[i]);
1805                         goto probe_aux_dev_err;
1806                 }
1807         }
1808 #endif
1809 
1810         card->instantiated = 1;
1811         snd_soc_dapm_sync(&card->dapm);
1812         mutex_unlock(&card->mutex);
1813 
1814         return 0;
1815 
1816 probe_aux_dev_err:
1817         for (i = 0; i < card->num_aux_devs; i++)
1818                 soc_remove_aux_dev(card, i);
1819 
1820 probe_dai_err:
1821         soc_remove_dai_links(card);
1822 
1823 card_probe_error:
1824         if (card->remove)
1825                 card->remove(card);
1826 
1827         snd_card_free(card->snd_card);
1828 
1829 base_error:
1830         mutex_unlock(&card->mutex);
1831 
1832         return ret;
1833 }
1834 
1835 /* probes a new socdev */
1836 static int soc_probe(struct platform_device *pdev)
1837 {
1838         struct snd_soc_card *card = platform_get_drvdata(pdev);
1839 
1840         /*
1841          * no card, so machine driver should be registering card
1842          * we should not be here in that case so ret error
1843          */
1844         if (!card)
1845                 return -EINVAL;
1846 
1847         dev_warn(&pdev->dev,
1848                  "ASoC: machine %s should use snd_soc_register_card()\n",
1849                  card->name);
1850 
1851         /* Bodge while we unpick instantiation */
1852         card->dev = &pdev->dev;
1853 
1854         return snd_soc_register_card(card);
1855 }
1856 
1857 static int soc_cleanup_card_resources(struct snd_soc_card *card)
1858 {
1859         int i;
1860 
1861         /* make sure any delayed work runs */
1862         for (i = 0; i < card->num_rtd; i++) {
1863                 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1864                 flush_delayed_work(&rtd->delayed_work);
1865         }
1866 
1867         /* remove auxiliary devices */
1868         for (i = 0; i < card->num_aux_devs; i++)
1869                 soc_remove_aux_dev(card, i);
1870 
1871         /* remove and free each DAI */
1872         soc_remove_dai_links(card);
1873 
1874         soc_cleanup_card_debugfs(card);
1875 
1876         /* remove the card */
1877         if (card->remove)
1878                 card->remove(card);
1879 
1880         snd_soc_dapm_free(&card->dapm);
1881 
1882         snd_card_free(card->snd_card);
1883         return 0;
1884 
1885 }
1886 
1887 /* removes a socdev */
1888 static int soc_remove(struct platform_device *pdev)
1889 {
1890         struct snd_soc_card *card = platform_get_drvdata(pdev);
1891 
1892         snd_soc_unregister_card(card);
1893         return 0;
1894 }
1895 
1896 int snd_soc_poweroff(struct device *dev)
1897 {
1898         struct snd_soc_card *card = dev_get_drvdata(dev);
1899         int i;
1900 
1901         if (!card->instantiated)
1902                 return 0;
1903 
1904         /* Flush out pmdown_time work - we actually do want to run it
1905          * now, we're shutting down so no imminent restart. */
1906         for (i = 0; i < card->num_rtd; i++) {
1907                 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1908                 flush_delayed_work(&rtd->delayed_work);
1909         }
1910 
1911         snd_soc_dapm_shutdown(card);
1912 
1913         /* deactivate pins to sleep state */
1914         for (i = 0; i < card->num_rtd; i++) {
1915                 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1916                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1917                 int j;
1918 
1919                 pinctrl_pm_select_sleep_state(cpu_dai->dev);
1920                 for (j = 0; j < rtd->num_codecs; j++) {
1921                         struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
1922                         pinctrl_pm_select_sleep_state(codec_dai->dev);
1923                 }
1924         }
1925 
1926         return 0;
1927 }
1928 EXPORT_SYMBOL_GPL(snd_soc_poweroff);
1929 
1930 const struct dev_pm_ops snd_soc_pm_ops = {
1931         .suspend = snd_soc_suspend,
1932         .resume = snd_soc_resume,
1933         .freeze = snd_soc_suspend,
1934         .thaw = snd_soc_resume,
1935         .poweroff = snd_soc_poweroff,
1936         .restore = snd_soc_resume,
1937 };
1938 EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
1939 
1940 /* ASoC platform driver */
1941 static struct platform_driver soc_driver = {
1942         .driver         = {
1943                 .name           = "soc-audio",
1944                 .owner          = THIS_MODULE,
1945                 .pm             = &snd_soc_pm_ops,
1946         },
1947         .probe          = soc_probe,
1948         .remove         = soc_remove,
1949 };
1950 
1951 /**
1952  * snd_soc_new_ac97_codec - initailise AC97 device
1953  * @codec: audio codec
1954  * @ops: AC97 bus operations
1955  * @num: AC97 codec number
1956  *
1957  * Initialises AC97 codec resources for use by ad-hoc devices only.
1958  */
1959 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
1960         struct snd_ac97_bus_ops *ops, int num)
1961 {
1962         codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
1963         if (codec->ac97 == NULL)
1964                 return -ENOMEM;
1965 
1966         codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
1967         if (codec->ac97->bus == NULL) {
1968                 kfree(codec->ac97);
1969                 codec->ac97 = NULL;
1970                 return -ENOMEM;
1971         }
1972 
1973         codec->ac97->bus->ops = ops;
1974         codec->ac97->num = num;
1975 
1976         /*
1977          * Mark the AC97 device to be created by us. This way we ensure that the
1978          * device will be registered with the device subsystem later on.
1979          */
1980         codec->ac97_created = 1;
1981 
1982         return 0;
1983 }
1984 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
1985 
1986 static struct snd_ac97_reset_cfg snd_ac97_rst_cfg;
1987 
1988 static void snd_soc_ac97_warm_reset(struct snd_ac97 *ac97)
1989 {
1990         struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;
1991 
1992         pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_warm_reset);
1993 
1994         gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 1);
1995 
1996         udelay(10);
1997 
1998         gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
1999 
2000         pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
2001         msleep(2);
2002 }
2003 
2004 static void snd_soc_ac97_reset(struct snd_ac97 *ac97)
2005 {
2006         struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;
2007 
2008         pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_reset);
2009 
2010         gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
2011         gpio_direction_output(snd_ac97_rst_cfg.gpio_sdata, 0);
2012         gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 0);
2013 
2014         udelay(10);
2015 
2016         gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 1);
2017 
2018         pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
2019         msleep(2);
2020 }
2021 
2022 static int snd_soc_ac97_parse_pinctl(struct device *dev,
2023                 struct snd_ac97_reset_cfg *cfg)
2024 {
2025         struct pinctrl *p;
2026         struct pinctrl_state *state;
2027         int gpio;
2028         int ret;
2029 
2030         p = devm_pinctrl_get(dev);
2031         if (IS_ERR(p)) {
2032                 dev_err(dev, "Failed to get pinctrl\n");
2033                 return PTR_ERR(p);
2034         }
2035         cfg->pctl = p;
2036 
2037         state = pinctrl_lookup_state(p, "ac97-reset");
2038         if (IS_ERR(state)) {
2039                 dev_err(dev, "Can't find pinctrl state ac97-reset\n");
2040                 return PTR_ERR(state);
2041         }
2042         cfg->pstate_reset = state;
2043 
2044         state = pinctrl_lookup_state(p, "ac97-warm-reset");
2045         if (IS_ERR(state)) {
2046                 dev_err(dev, "Can't find pinctrl state ac97-warm-reset\n");
2047                 return PTR_ERR(state);
2048         }
2049         cfg->pstate_warm_reset = state;
2050 
2051         state = pinctrl_lookup_state(p, "ac97-running");
2052         if (IS_ERR(state)) {
2053                 dev_err(dev, "Can't find pinctrl state ac97-running\n");
2054                 return PTR_ERR(state);
2055         }
2056         cfg->pstate_run = state;
2057 
2058         gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 0);
2059         if (gpio < 0) {
2060                 dev_err(dev, "Can't find ac97-sync gpio\n");
2061                 return gpio;
2062         }
2063         ret = devm_gpio_request(dev, gpio, "AC97 link sync");
2064         if (ret) {
2065                 dev_err(dev, "Failed requesting ac97-sync gpio\n");
2066                 return ret;
2067         }
2068         cfg->gpio_sync = gpio;
2069 
2070         gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 1);
2071         if (gpio < 0) {
2072                 dev_err(dev, "Can't find ac97-sdata gpio %d\n", gpio);
2073                 return gpio;
2074         }
2075         ret = devm_gpio_request(dev, gpio, "AC97 link sdata");
2076         if (ret) {
2077                 dev_err(dev, "Failed requesting ac97-sdata gpio\n");
2078                 return ret;
2079         }
2080         cfg->gpio_sdata = gpio;
2081 
2082         gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 2);
2083         if (gpio < 0) {
2084                 dev_err(dev, "Can't find ac97-reset gpio\n");
2085                 return gpio;
2086         }
2087         ret = devm_gpio_request(dev, gpio, "AC97 link reset");
2088         if (ret) {
2089                 dev_err(dev, "Failed requesting ac97-reset gpio\n");
2090                 return ret;
2091         }
2092         cfg->gpio_reset = gpio;
2093 
2094         return 0;
2095 }
2096 
2097 struct snd_ac97_bus_ops *soc_ac97_ops;
2098 EXPORT_SYMBOL_GPL(soc_ac97_ops);
2099 
2100 int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
2101 {
2102         if (ops == soc_ac97_ops)
2103                 return 0;
2104 
2105         if (soc_ac97_ops && ops)
2106                 return -EBUSY;
2107 
2108         soc_ac97_ops = ops;
2109 
2110         return 0;
2111 }
2112 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops);
2113 
2114 /**
2115  * snd_soc_set_ac97_ops_of_reset - Set ac97 ops with generic ac97 reset functions
2116  *
2117  * This function sets the reset and warm_reset properties of ops and parses
2118  * the device node of pdev to get pinctrl states and gpio numbers to use.
2119  */
2120 int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
2121                 struct platform_device *pdev)
2122 {
2123         struct device *dev = &pdev->dev;
2124         struct snd_ac97_reset_cfg cfg;
2125         int ret;
2126 
2127         ret = snd_soc_ac97_parse_pinctl(dev, &cfg);
2128         if (ret)
2129                 return ret;
2130 
2131         ret = snd_soc_set_ac97_ops(ops);
2132         if (ret)
2133                 return ret;
2134 
2135         ops->warm_reset = snd_soc_ac97_warm_reset;
2136         ops->reset = snd_soc_ac97_reset;
2137 
2138         snd_ac97_rst_cfg = cfg;
2139         return 0;
2140 }
2141 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops_of_reset);
2142 
2143 /**
2144  * snd_soc_free_ac97_codec - free AC97 codec device
2145  * @codec: audio codec
2146  *
2147  * Frees AC97 codec device resources.
2148  */
2149 void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
2150 {
2151 #ifdef CONFIG_SND_SOC_AC97_BUS
2152         soc_unregister_ac97_codec(codec);
2153 #endif
2154         kfree(codec->ac97->bus);
2155         kfree(codec->ac97);
2156         codec->ac97 = NULL;
2157         codec->ac97_created = 0;
2158 }
2159 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
2160 
2161 /**
2162  * snd_soc_cnew - create new control
2163  * @_template: control template
2164  * @data: control private data
2165  * @long_name: control long name
2166  * @prefix: control name prefix
2167  *
2168  * Create a new mixer control from a template control.
2169  *
2170  * Returns 0 for success, else error.
2171  */
2172 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
2173                                   void *data, const char *long_name,
2174                                   const char *prefix)
2175 {
2176         struct snd_kcontrol_new template;
2177         struct snd_kcontrol *kcontrol;
2178         char *name = NULL;
2179 
2180         memcpy(&template, _template, sizeof(template));
2181         template.index = 0;
2182 
2183         if (!long_name)
2184                 long_name = template.name;
2185 
2186         if (prefix) {
2187                 name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
2188                 if (!name)
2189                         return NULL;
2190 
2191                 template.name = name;
2192         } else {
2193                 template.name = long_name;
2194         }
2195 
2196         kcontrol = snd_ctl_new1(&template, data);
2197 
2198         kfree(name);
2199 
2200         return kcontrol;
2201 }
2202 EXPORT_SYMBOL_GPL(snd_soc_cnew);
2203 
2204 static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
2205         const struct snd_kcontrol_new *controls, int num_controls,
2206         const char *prefix, void *data)
2207 {
2208         int err, i;
2209 
2210         for (i = 0; i < num_controls; i++) {
2211                 const struct snd_kcontrol_new *control = &controls[i];
2212                 err = snd_ctl_add(card, snd_soc_cnew(control, data,
2213                                                      control->name, prefix));
2214                 if (err < 0) {
2215                         dev_err(dev, "ASoC: Failed to add %s: %d\n",
2216                                 control->name, err);
2217                         return err;
2218                 }
2219         }
2220 
2221         return 0;
2222 }
2223 
2224 struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
2225                                                const char *name)
2226 {
2227         struct snd_card *card = soc_card->snd_card;
2228         struct snd_kcontrol *kctl;
2229 
2230         if (unlikely(!name))
2231                 return NULL;
2232 
2233         list_for_each_entry(kctl, &card->controls, list)
2234                 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))
2235                         return kctl;
2236         return NULL;
2237 }
2238 EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);
2239 
2240 /**
2241  * snd_soc_add_component_controls - Add an array of controls to a component.
2242  *
2243  * @component: Component to add controls to
2244  * @controls: Array of controls to add
2245  * @num_controls: Number of elements in the array
2246  *
2247  * Return: 0 for success, else error.
2248  */
2249 int snd_soc_add_component_controls(struct snd_soc_component *component,
2250         const struct snd_kcontrol_new *controls, unsigned int num_controls)
2251 {
2252         struct snd_card *card = component->card->snd_card;
2253 
2254         return snd_soc_add_controls(card, component->dev, controls,
2255                         num_controls, component->name_prefix, component);
2256 }
2257 EXPORT_SYMBOL_GPL(snd_soc_add_component_controls);
2258 
2259 /**
2260  * snd_soc_add_codec_controls - add an array of controls to a codec.
2261  * Convenience function to add a list of controls. Many codecs were
2262  * duplicating this code.
2263  *
2264  * @codec: codec to add controls to
2265  * @controls: array of controls to add
2266  * @num_controls: number of elements in the array
2267  *
2268  * Return 0 for success, else error.
2269  */
2270 int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
2271         const struct snd_kcontrol_new *controls, unsigned int num_controls)
2272 {
2273         return snd_soc_add_component_controls(&codec->component, controls,
2274                 num_controls);
2275 }
2276 EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
2277 
2278 /**
2279  * snd_soc_add_platform_controls - add an array of controls to a platform.
2280  * Convenience function to add a list of controls.
2281  *
2282  * @platform: platform to add controls to
2283  * @controls: array of controls to add
2284  * @num_controls: number of elements in the array
2285  *
2286  * Return 0 for success, else error.
2287  */
2288 int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
2289         const struct snd_kcontrol_new *controls, unsigned int num_controls)
2290 {
2291         return snd_soc_add_component_controls(&platform->component, controls,
2292                 num_controls);
2293 }
2294 EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
2295 
2296 /**
2297  * snd_soc_add_card_controls - add an array of controls to a SoC card.
2298  * Convenience function to add a list of controls.
2299  *
2300  * @soc_card: SoC card to add controls to
2301  * @controls: array of controls to add
2302  * @num_controls: number of elements in the array
2303  *
2304  * Return 0 for success, else error.
2305  */
2306 int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
2307         const struct snd_kcontrol_new *controls, int num_controls)
2308 {
2309         struct snd_card *card = soc_card->snd_card;
2310 
2311         return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
2312                         NULL, soc_card);
2313 }
2314 EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
2315 
2316 /**
2317  * snd_soc_add_dai_controls - add an array of controls to a DAI.
2318  * Convienience function to add a list of controls.
2319  *
2320  * @dai: DAI to add controls to
2321  * @controls: array of controls to add
2322  * @num_controls: number of elements in the array
2323  *
2324  * Return 0 for success, else error.
2325  */
2326 int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
2327         const struct snd_kcontrol_new *controls, int num_controls)
2328 {
2329         struct snd_card *card = dai->card->snd_card;
2330 
2331         return snd_soc_add_controls(card, dai->dev, controls, num_controls,
2332                         NULL, dai);
2333 }
2334 EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
2335 
2336 /**
2337  * snd_soc_info_enum_double - enumerated double mixer info callback
2338  * @kcontrol: mixer control
2339  * @uinfo: control element information
2340  *
2341  * Callback to provide information about a double enumerated
2342  * mixer control.
2343  *
2344  * Returns 0 for success.
2345  */
2346 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
2347         struct snd_ctl_elem_info *uinfo)
2348 {
2349         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2350 
2351         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2352         uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
2353         uinfo->value.enumerated.items = e->items;
2354 
2355         if (uinfo->value.enumerated.item >= e->items)
2356                 uinfo->value.enumerated.item = e->items - 1;
2357         strlcpy(uinfo->value.enumerated.name,
2358                 e->texts[uinfo->value.enumerated.item],
2359                 sizeof(uinfo->value.enumerated.name));
2360         return 0;
2361 }
2362 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
2363 
2364 /**
2365  * snd_soc_get_enum_double - enumerated double mixer get callback
2366  * @kcontrol: mixer control
2367  * @ucontrol: control element information
2368  *
2369  * Callback to get the value of a double enumerated mixer.
2370  *
2371  * Returns 0 for success.
2372  */
2373 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
2374         struct snd_ctl_elem_value *ucontrol)
2375 {
2376         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2377         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2378         unsigned int val, item;
2379         unsigned int reg_val;
2380         int ret;
2381 
2382         ret = snd_soc_component_read(component, e->reg, &reg_val);
2383         if (ret)
2384                 return ret;
2385         val = (reg_val >> e->shift_l) & e->mask;
2386         item = snd_soc_enum_val_to_item(e, val);
2387         ucontrol->value.enumerated.item[0] = item;
2388         if (e->shift_l != e->shift_r) {
2389                 val = (reg_val >> e->shift_l) & e->mask;
2390                 item = snd_soc_enum_val_to_item(e, val);
2391                 ucontrol->value.enumerated.item[1] = item;
2392         }
2393 
2394         return 0;
2395 }
2396 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
2397 
2398 /**
2399  * snd_soc_put_enum_double - enumerated double mixer put callback
2400  * @kcontrol: mixer control
2401  * @ucontrol: control element information
2402  *
2403  * Callback to set the value of a double enumerated mixer.
2404  *
2405  * Returns 0 for success.
2406  */
2407 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
2408         struct snd_ctl_elem_value *ucontrol)
2409 {
2410         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2411         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2412         unsigned int *item = ucontrol->value.enumerated.item;
2413         unsigned int val;
2414         unsigned int mask;
2415 
2416         if (item[0] >= e->items)
2417                 return -EINVAL;
2418         val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
2419         mask = e->mask << e->shift_l;
2420         if (e->shift_l != e->shift_r) {
2421                 if (item[1] >= e->items)
2422                         return -EINVAL;
2423                 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r;
2424                 mask |= e->mask << e->shift_r;
2425         }
2426 
2427         return snd_soc_component_update_bits(component, e->reg, mask, val);
2428 }
2429 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
2430 
2431 /**
2432  * snd_soc_read_signed - Read a codec register and interprete as signed value
2433  * @component: component
2434  * @reg: Register to read
2435  * @mask: Mask to use after shifting the register value
2436  * @shift: Right shift of register value
2437  * @sign_bit: Bit that describes if a number is negative or not.
2438  * @signed_val: Pointer to where the read value should be stored
2439  *
2440  * This functions reads a codec register. The register value is shifted right
2441  * by 'shift' bits and masked with the given 'mask'. Afterwards it translates
2442  * the given registervalue into a signed integer if sign_bit is non-zero.
2443  *
2444  * Returns 0 on sucess, otherwise an error value
2445  */
2446 static int snd_soc_read_signed(struct snd_soc_component *component,
2447         unsigned int reg, unsigned int mask, unsigned int shift,
2448         unsigned int sign_bit, int *signed_val)
2449 {
2450         int ret;
2451         unsigned int val;
2452 
2453         ret = snd_soc_component_read(component, reg, &val);
2454         if (ret < 0)
2455                 return ret;
2456 
2457         val = (val >> shift) & mask;
2458 
2459         if (!sign_bit) {
2460                 *signed_val = val;
2461                 return 0;
2462         }
2463 
2464         /* non-negative number */
2465         if (!(val & BIT(sign_bit))) {
2466                 *signed_val = val;
2467                 return 0;
2468         }
2469 
2470         ret = val;
2471 
2472         /*
2473          * The register most probably does not contain a full-sized int.
2474          * Instead we have an arbitrary number of bits in a signed
2475          * representation which has to be translated into a full-sized int.
2476          * This is done by filling up all bits above the sign-bit.
2477          */
2478         ret |= ~((int)(BIT(sign_bit) - 1));
2479 
2480         *signed_val = ret;
2481 
2482         return 0;
2483 }
2484 
2485 /**
2486  * snd_soc_info_volsw - single mixer info callback
2487  * @kcontrol: mixer control
2488  * @uinfo: control element information
2489  *
2490  * Callback to provide information about a single mixer control, or a double
2491  * mixer control that spans 2 registers.
2492  *
2493  * Returns 0 for success.
2494  */
2495 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
2496         struct snd_ctl_elem_info *uinfo)
2497 {
2498         struct soc_mixer_control *mc =
2499                 (struct soc_mixer_control *)kcontrol->private_value;
2500         int platform_max;
2501 
2502         if (!mc->platform_max)
2503                 mc->platform_max = mc->max;
2504         platform_max = mc->platform_max;
2505 
2506         if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
2507                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2508         else
2509                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2510 
2511         uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
2512         uinfo->value.integer.min = 0;
2513         uinfo->value.integer.max = platform_max - mc->min;
2514         return 0;
2515 }
2516 EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
2517 
2518 /**
2519  * snd_soc_get_volsw - single mixer get callback
2520  * @kcontrol: mixer control
2521  * @ucontrol: control element information
2522  *
2523  * Callback to get the value of a single mixer control, or a double mixer
2524  * control that spans 2 registers.
2525  *
2526  * Returns 0 for success.
2527  */
2528 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
2529         struct snd_ctl_elem_value *ucontrol)
2530 {
2531         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2532         struct soc_mixer_control *mc =
2533                 (struct soc_mixer_control *)kcontrol->private_value;
2534         unsigned int reg = mc->reg;
2535         unsigned int reg2 = mc->rreg;
2536         unsigned int shift = mc->shift;
2537         unsigned int rshift = mc->rshift;
2538         int max = mc->max;
2539         int min = mc->min;
2540         int sign_bit = mc->sign_bit;
2541         unsigned int mask = (1 << fls(max)) - 1;
2542         unsigned int invert = mc->invert;
2543         int val;
2544         int ret;
2545 
2546         if (sign_bit)
2547                 mask = BIT(sign_bit + 1) - 1;
2548 
2549         ret = snd_soc_read_signed(component, reg, mask, shift, sign_bit, &val);
2550         if (ret)
2551                 return ret;
2552 
2553         ucontrol->value.integer.value[0] = val - min;
2554         if (invert)
2555                 ucontrol->value.integer.value[0] =
2556                         max - ucontrol->value.integer.value[0];
2557 
2558         if (snd_soc_volsw_is_stereo(mc)) {
2559                 if (reg == reg2)
2560                         ret = snd_soc_read_signed(component, reg, mask, rshift,
2561                                 sign_bit, &val);
2562                 else
2563                         ret = snd_soc_read_signed(component, reg2, mask, shift,
2564                                 sign_bit, &val);
2565                 if (ret)
2566                         return ret;
2567 
2568                 ucontrol->value.integer.value[1] = val - min;
2569                 if (invert)
2570                         ucontrol->value.integer.value[1] =
2571                                 max - ucontrol->value.integer.value[1];
2572         }
2573 
2574         return 0;
2575 }
2576 EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
2577 
2578 /**
2579  * snd_soc_put_volsw - single mixer put callback
2580  * @kcontrol: mixer control
2581  * @ucontrol: control element information
2582  *
2583  * Callback to set the value of a single mixer control, or a double mixer
2584  * control that spans 2 registers.
2585  *
2586  * Returns 0 for success.
2587  */
2588 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
2589         struct snd_ctl_elem_value *ucontrol)
2590 {
2591         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2592         struct soc_mixer_control *mc =
2593                 (struct soc_mixer_control *)kcontrol->private_value;
2594         unsigned int reg = mc->reg;
2595         unsigned int reg2 = mc->rreg;
2596         unsigned int shift = mc->shift;
2597         unsigned int rshift = mc->rshift;
2598         int max = mc->max;
2599         int min = mc->min;
2600         unsigned int sign_bit = mc->sign_bit;
2601         unsigned int mask = (1 << fls(max)) - 1;
2602         unsigned int invert = mc->invert;
2603         int err;
2604         bool type_2r = false;
2605         unsigned int val2 = 0;
2606         unsigned int val, val_mask;
2607 
2608         if (sign_bit)
2609                 mask = BIT(sign_bit + 1) - 1;
2610 
2611         val = ((ucontrol->value.integer.value[0] + min) & mask);
2612         if (invert)
2613                 val = max - val;
2614         val_mask = mask << shift;
2615         val = val << shift;
2616         if (snd_soc_volsw_is_stereo(mc)) {
2617                 val2 = ((ucontrol->value.integer.value[1] + min) & mask);
2618                 if (invert)
2619                         val2 = max - val2;
2620                 if (reg == reg2) {
2621                         val_mask |= mask << rshift;
2622                         val |= val2 << rshift;
2623                 } else {
2624                         val2 = val2 << shift;
2625                         type_2r = true;
2626                 }
2627         }
2628         err = snd_soc_component_update_bits(component, reg, val_mask, val);
2629         if (err < 0)
2630                 return err;
2631 
2632         if (type_2r)
2633                 err = snd_soc_component_update_bits(component, reg2, val_mask,
2634                         val2);
2635 
2636         return err;
2637 }
2638 EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
2639 
2640 /**
2641  * snd_soc_get_volsw_sx - single mixer get callback
2642  * @kcontrol: mixer control
2643  * @ucontrol: control element information
2644  *
2645  * Callback to get the value of a single mixer control, or a double mixer
2646  * control that spans 2 registers.
2647  *
2648  * Returns 0 for success.
2649  */
2650 int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol,
2651                       struct snd_ctl_elem_value *ucontrol)
2652 {
2653         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2654         struct soc_mixer_control *mc =
2655             (struct soc_mixer_control *)kcontrol->private_value;
2656         unsigned int reg = mc->reg;
2657         unsigned int reg2 = mc->rreg;
2658         unsigned int shift = mc->shift;
2659         unsigned int rshift = mc->rshift;
2660         int max = mc->max;
2661         int min = mc->min;
2662         int mask = (1 << (fls(min + max) - 1)) - 1;
2663         unsigned int val;
2664         int ret;
2665 
2666         ret = snd_soc_component_read(component, reg, &val);
2667         if (ret < 0)
2668                 return ret;
2669 
2670         ucontrol->value.integer.value[0] = ((val >> shift) - min) & mask;
2671 
2672         if (snd_soc_volsw_is_stereo(mc)) {
2673                 ret = snd_soc_component_read(component, reg2, &val);
2674                 if (ret < 0)
2675                         return ret;
2676 
2677                 val = ((val >> rshift) - min) & mask;
2678                 ucontrol->value.integer.value[1] = val;
2679         }
2680 
2681         return 0;
2682 }
2683 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx);
2684 
2685 /**
2686  * snd_soc_put_volsw_sx - double mixer set callback
2687  * @kcontrol: mixer control
2688  * @uinfo: control element information
2689  *
2690  * Callback to set the value of a double mixer control that spans 2 registers.
2691  *
2692  * Returns 0 for success.
2693  */
2694 int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol,
2695                          struct snd_ctl_elem_value *ucontrol)
2696 {
2697         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2698         struct soc_mixer_control *mc =
2699             (struct soc_mixer_control *)kcontrol->private_value;
2700 
2701         unsigned int reg = mc->reg;
2702         unsigned int reg2 = mc->rreg;
2703         unsigned int shift = mc->shift;
2704         unsigned int rshift = mc->rshift;
2705         int max = mc->max;
2706         int min = mc->min;
2707         int mask = (1 << (fls(min + max) - 1)) - 1;
2708         int err = 0;
2709         unsigned int val, val_mask, val2 = 0;
2710 
2711         val_mask = mask << shift;
2712         val = (ucontrol->value.integer.value[0] + min) & mask;
2713         val = val << shift;
2714 
2715         err = snd_soc_component_update_bits(component, reg, val_mask, val);
2716         if (err < 0)
2717                 return err;
2718 
2719         if (snd_soc_volsw_is_stereo(mc)) {
2720                 val_mask = mask << rshift;
2721                 val2 = (ucontrol->value.integer.value[1] + min) & mask;
2722                 val2 = val2 << rshift;
2723 
2724                 err = snd_soc_component_update_bits(component, reg2, val_mask,
2725                         val2);
2726         }
2727         return err;
2728 }
2729 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx);
2730 
2731 /**
2732  * snd_soc_info_volsw_s8 - signed mixer info callback
2733  * @kcontrol: mixer control
2734  * @uinfo: control element information
2735  *
2736  * Callback to provide information about a signed mixer control.
2737  *
2738  * Returns 0 for success.
2739  */
2740 int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
2741         struct snd_ctl_elem_info *uinfo)
2742 {
2743         struct soc_mixer_control *mc =
2744                 (struct soc_mixer_control *)kcontrol->private_value;
2745         int platform_max;
2746         int min = mc->min;
2747 
2748         if (!mc->platform_max)
2749                 mc->platform_max = mc->max;
2750         platform_max = mc->platform_max;
2751 
2752         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2753         uinfo->count = 2;
2754         uinfo->value.integer.min = 0;
2755         uinfo->value.integer.max = platform_max - min;
2756         return 0;
2757 }
2758 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
2759 
2760 /**
2761  * snd_soc_get_volsw_s8 - signed mixer get callback
2762  * @kcontrol: mixer control
2763  * @ucontrol: control element information
2764  *
2765  * Callback to get the value of a signed mixer control.
2766  *
2767  * Returns 0 for success.
2768  */
2769 int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
2770         struct snd_ctl_elem_value *ucontrol)
2771 {
2772         struct soc_mixer_control *mc =
2773                 (struct soc_mixer_control *)kcontrol->private_value;
2774         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2775         unsigned int reg = mc->reg;
2776         unsigned int val;
2777         int min = mc->min;
2778         int ret;
2779 
2780         ret = snd_soc_component_read(component, reg, &val);
2781         if (ret)
2782                 return ret;
2783 
2784         ucontrol->value.integer.value[0] =
2785                 ((signed char)(val & 0xff))-min;
2786         ucontrol->value.integer.value[1] =
2787                 ((signed char)((val >> 8) & 0xff))-min;
2788         return 0;
2789 }
2790 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
2791 
2792 /**
2793  * snd_soc_put_volsw_sgn - signed mixer put callback
2794  * @kcontrol: mixer control
2795  * @ucontrol: control element information
2796  *
2797  * Callback to set the value of a signed mixer control.
2798  *
2799  * Returns 0 for success.
2800  */
2801 int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
2802         struct snd_ctl_elem_value *ucontrol)
2803 {
2804         struct soc_mixer_control *mc =
2805                 (struct soc_mixer_control *)kcontrol->private_value;
2806         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2807         unsigned int reg = mc->reg;
2808         int min = mc->min;
2809         unsigned int val;
2810 
2811         val = (ucontrol->value.integer.value[0]+min) & 0xff;
2812         val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
2813 
2814         return snd_soc_component_update_bits(component, reg, 0xffff, val);
2815 }
2816 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
2817 
2818 /**
2819  * snd_soc_info_volsw_range - single mixer info callback with range.
2820  * @kcontrol: mixer control
2821  * @uinfo: control element information
2822  *
2823  * Callback to provide information, within a range, about a single
2824  * mixer control.
2825  *
2826  * returns 0 for success.
2827  */
2828 int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol,
2829         struct snd_ctl_elem_info *uinfo)
2830 {
2831         struct soc_mixer_control *mc =
2832                 (struct soc_mixer_control *)kcontrol->private_value;
2833         int platform_max;
2834         int min = mc->min;
2835 
2836         if (!mc->platform_max)
2837                 mc->platform_max = mc->max;
2838         platform_max = mc->platform_max;
2839 
2840         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2841         uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
2842         uinfo->value.integer.min = 0;
2843         uinfo->value.integer.max = platform_max - min;
2844 
2845         return 0;
2846 }
2847 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range);
2848 
2849 /**
2850  * snd_soc_put_volsw_range - single mixer put value callback with range.
2851  * @kcontrol: mixer control
2852  * @ucontrol: control element information
2853  *
2854  * Callback to set the value, within a range, for a single mixer control.
2855  *
2856  * Returns 0 for success.
2857  */
2858 int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol,
2859         struct snd_ctl_elem_value *ucontrol)
2860 {
2861         struct soc_mixer_control *mc =
2862                 (struct soc_mixer_control *)kcontrol->private_value;
2863         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2864         unsigned int reg = mc->reg;
2865         unsigned int rreg = mc->rreg;
2866         unsigned int shift = mc->shift;
2867         int min = mc->min;
2868         int max = mc->max;
2869         unsigned int mask = (1 << fls(max)) - 1;
2870         unsigned int invert = mc->invert;
2871         unsigned int val, val_mask;
2872         int ret;
2873 
2874         if (invert)
2875                 val = (max - ucontrol->value.integer.value[0]) & mask;
2876         else
2877                 val = ((ucontrol->value.integer.value[0] + min) & mask);
2878         val_mask = mask << shift;
2879         val = val << shift;
2880 
2881         ret = snd_soc_component_update_bits(component, reg, val_mask, val);
2882         if (ret < 0)
2883                 return ret;
2884 
2885         if (snd_soc_volsw_is_stereo(mc)) {
2886                 if (invert)
2887                         val = (max - ucontrol->value.integer.value[1]) & mask;
2888                 else
2889                         val = ((ucontrol->value.integer.value[1] + min) & mask);
2890                 val_mask = mask << shift;
2891                 val = val << shift;
2892 
2893                 ret = snd_soc_component_update_bits(component, rreg, val_mask,
2894                         val);
2895         }
2896 
2897         return ret;
2898 }
2899 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range);
2900 
2901 /**
2902  * snd_soc_get_volsw_range - single mixer get callback with range
2903  * @kcontrol: mixer control
2904  * @ucontrol: control element information
2905  *
2906  * Callback to get the value, within a range, of a single mixer control.
2907  *
2908  * Returns 0 for success.
2909  */
2910 int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol,
2911         struct snd_ctl_elem_value *ucontrol)
2912 {
2913         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2914         struct soc_mixer_control *mc =
2915                 (struct soc_mixer_control *)kcontrol->private_value;
2916         unsigned int reg = mc->reg;
2917         unsigned int rreg = mc->rreg;
2918         unsigned int shift = mc->shift;
2919         int min = mc->min;
2920         int max = mc->max;
2921         unsigned int mask = (1 << fls(max)) - 1;
2922         unsigned int invert = mc->invert;
2923         unsigned int val;
2924         int ret;
2925 
2926         ret = snd_soc_component_read(component, reg, &val);
2927         if (ret)
2928                 return ret;
2929 
2930         ucontrol->value.integer.value[0] = (val >> shift) & mask;
2931         if (invert)
2932                 ucontrol->value.integer.value[0] =
2933                         max - ucontrol->value.integer.value[0];
2934         else
2935                 ucontrol->value.integer.value[0] =
2936                         ucontrol->value.integer.value[0] - min;
2937 
2938         if (snd_soc_volsw_is_stereo(mc)) {
2939                 ret = snd_soc_component_read(component, rreg, &val);
2940                 if (ret)
2941                         return ret;
2942 
2943                 ucontrol->value.integer.value[1] = (val >> shift) & mask;
2944                 if (invert)
2945                         ucontrol->value.integer.value[1] =
2946                                 max - ucontrol->value.integer.value[1];
2947                 else
2948                         ucontrol->value.integer.value[1] =
2949                                 ucontrol->value.integer.value[1] - min;
2950         }
2951 
2952         return 0;
2953 }
2954 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range);
2955 
2956 /**
2957  * snd_soc_limit_volume - Set new limit to an existing volume control.
2958  *
2959  * @codec: where to look for the control
2960  * @name: Name of the control
2961  * @max: new maximum limit
2962  *
2963  * Return 0 for success, else error.
2964  */
2965 int snd_soc_limit_volume(struct snd_soc_codec *codec,
2966         const char *name, int max)
2967 {
2968         struct snd_card *card = codec->component.card->snd_card;
2969         struct snd_kcontrol *kctl;
2970         struct soc_mixer_control *mc;
2971         int found = 0;
2972         int ret = -EINVAL;
2973 
2974         /* Sanity check for name and max */
2975         if (unlikely(!name || max <= 0))
2976                 return -EINVAL;
2977 
2978         list_for_each_entry(kctl, &card->controls, list) {
2979                 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
2980                         found = 1;
2981                         break;
2982                 }
2983         }
2984         if (found) {
2985                 mc = (struct soc_mixer_control *)kctl->private_value;
2986                 if (max <= mc->max) {
2987                         mc->platform_max = max;
2988                         ret = 0;
2989                 }
2990         }
2991         return ret;
2992 }
2993 EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
2994 
2995 int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
2996                        struct snd_ctl_elem_info *uinfo)
2997 {
2998         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
2999         struct soc_bytes *params = (void *)kcontrol->private_value;
3000 
3001         uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
3002         uinfo->count = params->num_regs * component->val_bytes;
3003 
3004         return 0;
3005 }
3006 EXPORT_SYMBOL_GPL(snd_soc_bytes_info);
3007 
3008 int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
3009                       struct snd_ctl_elem_value *ucontrol)
3010 {
3011         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
3012         struct soc_bytes *params = (void *)kcontrol->private_value;
3013         int ret;
3014 
3015         if (component->regmap)
3016                 ret = regmap_raw_read(component->regmap, params->base,
3017                                       ucontrol->value.bytes.data,
3018                                       params->num_regs * component->val_bytes);
3019         else
3020                 ret = -EINVAL;
3021 
3022         /* Hide any masked bytes to ensure consistent data reporting */
3023         if (ret == 0 && params->mask) {
3024                 switch (component->val_bytes) {
3025                 case 1:
3026                         ucontrol->value.bytes.data[0] &= ~params->mask;
3027                         break;
3028                 case 2:
3029                         ((u16 *)(&ucontrol->value.bytes.data))[0]
3030                                 &= cpu_to_be16(~params->mask);
3031                         break;
3032                 case 4:
3033                         ((u32 *)(&ucontrol->value.bytes.data))[0]
3034                                 &= cpu_to_be32(~params->mask);
3035                         break;
3036                 default:
3037                         return -EINVAL;
3038                 }
3039         }
3040 
3041         return ret;
3042 }
3043 EXPORT_SYMBOL_GPL(snd_soc_bytes_get);
3044 
3045 int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
3046                       struct snd_ctl_elem_value *ucontrol)
3047 {
3048         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
3049         struct soc_bytes *params = (void *)kcontrol->private_value;
3050         int ret, len;
3051         unsigned int val, mask;
3052         void *data;
3053 
3054         if (!component->regmap || !params->num_regs)
3055                 return -EINVAL;
3056 
3057         len = params->num_regs * component->val_bytes;
3058 
3059         data = kmemdup(ucontrol->value.bytes.data, len, GFP_KERNEL | GFP_DMA);
3060         if (!data)
3061                 return -ENOMEM;
3062 
3063         /*
3064          * If we've got a mask then we need to preserve the register
3065          * bits.  We shouldn't modify the incoming data so take a
3066          * copy.
3067          */
3068         if (params->mask) {
3069                 ret = regmap_read(component->regmap, params->base, &val);
3070                 if (ret != 0)
3071                         goto out;
3072 
3073                 val &= params->mask;
3074 
3075                 switch (component->val_bytes) {
3076                 case 1:
3077                         ((u8 *)data)[0] &= ~params->mask;
3078                         ((u8 *)data)[0] |= val;
3079                         break;
3080                 case 2:
3081                         mask = ~params->mask;
3082                         ret = regmap_parse_val(component->regmap,
3083                                                         &mask, &mask);
3084                         if (ret != 0)
3085                                 goto out;
3086 
3087                         ((u16 *)data)[0] &= mask;
3088 
3089                         ret = regmap_parse_val(component->regmap,
3090                                                         &val, &val);
3091                         if (ret != 0)
3092                                 goto out;
3093 
3094                         ((u16 *)data)[0] |= val;
3095                         break;
3096                 case 4:
3097                         mask = ~params->mask;
3098                         ret = regmap_parse_val(component->regmap,
3099                                                         &mask, &mask);
3100                         if (ret != 0)
3101                                 goto out;
3102 
3103                         ((u32 *)data)[0] &= mask;
3104 
3105                         ret = regmap_parse_val(component->regmap,
3106                                                         &val, &val);
3107                         if (ret != 0)
3108                                 goto out;
3109 
3110                         ((u32 *)data)[0] |= val;
3111                         break;
3112                 default:
3113                         ret = -EINVAL;
3114                         goto out;
3115                 }
3116         }
3117 
3118         ret = regmap_raw_write(component->regmap, params->base,
3119                                data, len);
3120 
3121 out:
3122         kfree(data);
3123 
3124         return ret;
3125 }
3126 EXPORT_SYMBOL_GPL(snd_soc_bytes_put);
3127 
3128 int snd_soc_bytes_info_ext(struct snd_kcontrol *kcontrol,
3129                         struct snd_ctl_elem_info *ucontrol)
3130 {
3131         struct soc_bytes_ext *params = (void *)kcontrol->private_value;
3132 
3133         ucontrol->type = SNDRV_CTL_ELEM_TYPE_BYTES;
3134         ucontrol->count = params->max;
3135 
3136         return 0;
3137 }
3138 EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext);
3139 
3140 int snd_soc_bytes_tlv_callback(struct snd_kcontrol *kcontrol, int op_flag,
3141                                 unsigned int size, unsigned int __user *tlv)
3142 {
3143         struct soc_bytes_ext *params = (void *)kcontrol->private_value;
3144         unsigned int count = size < params->max ? size : params->max;
3145         int ret = -ENXIO;
3146 
3147         switch (op_flag) {
3148         case SNDRV_CTL_TLV_OP_READ:
3149                 if (params->get)
3150                         ret = params->get(tlv, count);
3151                 break;
3152         case SNDRV_CTL_TLV_OP_WRITE:
3153                 if (params->put)
3154                         ret = params->put(tlv, count);
3155                 break;
3156         }
3157         return ret;
3158 }
3159 EXPORT_SYMBOL_GPL(snd_soc_bytes_tlv_callback);
3160 
3161 /**
3162  * snd_soc_info_xr_sx - signed multi register info callback
3163  * @kcontrol: mreg control
3164  * @uinfo: control element information
3165  *
3166  * Callback to provide information of a control that can
3167  * span multiple codec registers which together
3168  * forms a single signed value in a MSB/LSB manner.
3169  *
3170  * Returns 0 for success.
3171  */
3172 int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol,
3173         struct snd_ctl_elem_info *uinfo)
3174 {
3175         struct soc_mreg_control *mc =
3176                 (struct soc_mreg_control *)kcontrol->private_value;
3177         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3178         uinfo->count = 1;
3179         uinfo->value.integer.min = mc->min;
3180         uinfo->value.integer.max = mc->max;
3181 
3182         return 0;
3183 }
3184 EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx);
3185 
3186 /**
3187  * snd_soc_get_xr_sx - signed multi register get callback
3188  * @kcontrol: mreg control
3189  * @ucontrol: control element information
3190  *
3191  * Callback to get the value of a control that can span
3192  * multiple codec registers which together forms a single
3193  * signed value in a MSB/LSB manner. The control supports
3194  * specifying total no of bits used to allow for bitfields
3195  * across the multiple codec registers.
3196  *
3197  * Returns 0 for success.
3198  */
3199 int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol,
3200         struct snd_ctl_elem_value *ucontrol)
3201 {
3202         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
3203         struct soc_mreg_control *mc =
3204                 (struct soc_mreg_control *)kcontrol->private_value;
3205         unsigned int regbase = mc->regbase;
3206         unsigned int regcount = mc->regcount;
3207         unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;
3208         unsigned int regwmask = (1<<regwshift)-1;
3209         unsigned int invert = mc->invert;
3210         unsigned long mask = (1UL<<mc->nbits)-1;
3211         long min = mc->min;
3212         long max = mc->max;
3213         long val = 0;
3214         unsigned int regval;
3215         unsigned int i;
3216         int ret;
3217 
3218         for (i = 0; i < regcount; i++) {
3219                 ret = snd_soc_component_read(component, regbase+i, &regval);
3220                 if (ret)
3221                         return ret;
3222                 val |= (regval & regwmask) << (regwshift*(regcount-i-1));
3223         }
3224         val &= mask;
3225         if (min < 0 && val > max)
3226                 val |= ~mask;
3227         if (invert)
3228                 val = max - val;
3229         ucontrol->value.integer.value[0] = val;
3230 
3231         return 0;
3232 }
3233 EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx);
3234 
3235 /**
3236  * snd_soc_put_xr_sx - signed multi register get callback
3237  * @kcontrol: mreg control
3238  * @ucontrol: control element information
3239  *
3240  * Callback to set the value of a control that can span
3241  * multiple codec registers which together forms a single
3242  * signed value in a MSB/LSB manner. The control supports
3243  * specifying total no of bits used to allow for bitfields
3244  * across the multiple codec registers.
3245  *
3246  * Returns 0 for success.
3247  */
3248 int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol,
3249         struct snd_ctl_elem_value *ucontrol)
3250 {
3251         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
3252         struct soc_mreg_control *mc =
3253                 (struct soc_mreg_control *)kcontrol->private_value;
3254         unsigned int regbase = mc->regbase;
3255         unsigned int regcount = mc->regcount;
3256         unsigned int regwshift = component->val_bytes * BITS_PER_BYTE;
3257         unsigned int regwmask = (1<<regwshift)-1;
3258         unsigned int invert = mc->invert;
3259         unsigned long mask = (1UL<<mc->nbits)-1;
3260         long max = mc->max;
3261         long val = ucontrol->value.integer.value[0];
3262         unsigned int i, regval, regmask;
3263         int err;
3264 
3265         if (invert)
3266                 val = max - val;
3267         val &= mask;
3268         for (i = 0; i < regcount; i++) {
3269                 regval = (val >> (regwshift*(regcount-i-1))) & regwmask;
3270                 regmask = (mask >> (regwshift*(regcount-i-1))) & regwmask;
3271                 err = snd_soc_component_update_bits(component, regbase+i,
3272                                 regmask, regval);
3273                 if (err < 0)
3274                         return err;
3275         }
3276 
3277         return 0;
3278 }
3279 EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx);
3280 
3281 /**
3282  * snd_soc_get_strobe - strobe get callback
3283  * @kcontrol: mixer control
3284  * @ucontrol: control element information
3285  *
3286  * Callback get the value of a strobe mixer control.
3287  *
3288  * Returns 0 for success.
3289  */
3290 int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
3291         struct snd_ctl_elem_value *ucontrol)
3292 {
3293         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
3294         struct soc_mixer_control *mc =
3295                 (struct soc_mixer_control *)kcontrol->private_value;
3296         unsigned int reg = mc->reg;
3297         unsigned int shift = mc->shift;
3298         unsigned int mask = 1 << shift;
3299         unsigned int invert = mc->invert != 0;
3300         unsigned int val;
3301         int ret;
3302 
3303         ret = snd_soc_component_read(component, reg, &val);
3304         if (ret)
3305                 return ret;
3306 
3307         val &= mask;
3308 
3309         if (shift != 0 && val != 0)
3310                 val = val >> shift;
3311         ucontrol->value.enumerated.item[0] = val ^ invert;
3312 
3313         return 0;
3314 }
3315 EXPORT_SYMBOL_GPL(snd_soc_get_strobe);
3316 
3317 /**
3318  * snd_soc_put_strobe - strobe put callback
3319  * @kcontrol: mixer control
3320  * @ucontrol: control element information
3321  *
3322  * Callback strobe a register bit to high then low (or the inverse)
3323  * in one pass of a single mixer enum control.
3324  *
3325  * Returns 1 for success.
3326  */
3327 int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
3328         struct snd_ctl_elem_value *ucontrol)
3329 {
3330         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
3331         struct soc_mixer_control *mc =
3332                 (struct soc_mixer_control *)kcontrol->private_value;
3333         unsigned int reg = mc->reg;
3334         unsigned int shift = mc->shift;
3335         unsigned int mask = 1 << shift;
3336         unsigned int invert = mc->invert != 0;
3337         unsigned int strobe = ucontrol->value.enumerated.item[0] != 0;
3338         unsigned int val1 = (strobe ^ invert) ? mask : 0;
3339         unsigned int val2 = (strobe ^ invert) ? 0 : mask;
3340         int err;
3341 
3342         err = snd_soc_component_update_bits(component, reg, mask, val1);
3343         if (err < 0)
3344                 return err;
3345 
3346         return snd_soc_component_update_bits(component, reg, mask, val2);
3347 }
3348 EXPORT_SYMBOL_GPL(snd_soc_put_strobe);
3349 
3350 /**
3351  * snd_soc_dai_set_sysclk - configure DAI system or master clock.
3352  * @dai: DAI
3353  * @clk_id: DAI specific clock ID
3354  * @freq: new clock frequency in Hz
3355  * @dir: new clock direction - input/output.
3356  *
3357  * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
3358  */
3359 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
3360         unsigned int freq, int dir)
3361 {
3362         if (dai->driver && dai->driver->ops->set_sysclk)
3363                 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
3364         else if (dai->codec && dai->codec->driver->set_sysclk)
3365                 return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
3366                                                       freq, dir);
3367         else
3368                 return -ENOTSUPP;
3369 }
3370 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
3371 
3372 /**
3373  * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
3374  * @codec: CODEC
3375  * @clk_id: DAI specific clock ID
3376  * @source: Source for the clock
3377  * @freq: new clock frequency in Hz
3378  * @dir: new clock direction - input/output.
3379  *
3380  * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
3381  */
3382 int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
3383                              int source, unsigned int freq, int dir)
3384 {
3385         if (codec->driver->set_sysclk)
3386                 return codec->driver->set_sysclk(codec, clk_id, source,
3387                                                  freq, dir);
3388         else
3389                 return -ENOTSUPP;
3390 }
3391 EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
3392 
3393 /**
3394  * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
3395  * @dai: DAI
3396  * @div_id: DAI specific clock divider ID
3397  * @div: new clock divisor.
3398  *
3399  * Configures the clock dividers. This is used to derive the best DAI bit and
3400  * frame clocks from the system or master clock. It's best to set the DAI bit
3401  * and frame clocks as low as possible to save system power.
3402  */
3403 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
3404         int div_id, int div)
3405 {
3406         if (dai->driver && dai->driver->ops->set_clkdiv)
3407                 return dai->driver->ops->set_clkdiv(dai, div_id, div);
3408         else
3409                 return -EINVAL;
3410 }
3411 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
3412 
3413 /**
3414  * snd_soc_dai_set_pll - configure DAI PLL.
3415  * @dai: DAI
3416  * @pll_id: DAI specific PLL ID
3417  * @source: DAI specific source for the PLL
3418  * @freq_in: PLL input clock frequency in Hz
3419  * @freq_out: requested PLL output clock frequency in Hz
3420  *
3421  * Configures and enables PLL to generate output clock based on input clock.
3422  */
3423 int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
3424         unsigned int freq_in, unsigned int freq_out)
3425 {
3426         if (dai->driver && dai->driver->ops->set_pll)
3427                 return dai->driver->ops->set_pll(dai, pll_id, source,
3428                                          freq_in, freq_out);
3429         else if (dai->codec && dai->codec->driver->set_pll)
3430                 return dai->codec->driver->set_pll(dai->codec, pll_id, source,
3431                                                    freq_in, freq_out);
3432         else
3433                 return -EINVAL;
3434 }
3435 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
3436 
3437 /*
3438  * snd_soc_codec_set_pll - configure codec PLL.
3439  * @codec: CODEC
3440  * @pll_id: DAI specific PLL ID
3441  * @source: DAI specific source for the PLL
3442  * @freq_in: PLL input clock frequency in Hz
3443  * @freq_out: requested PLL output clock frequency in Hz
3444  *
3445  * Configures and enables PLL to generate output clock based on input clock.
3446  */
3447 int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
3448                           unsigned int freq_in, unsigned int freq_out)
3449 {
3450         if (codec->driver->set_pll)
3451                 return codec->driver->set_pll(codec, pll_id, source,
3452                                               freq_in, freq_out);
3453         else
3454                 return -EINVAL;
3455 }
3456 EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
3457 
3458 /**
3459  * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
3460  * @dai: DAI
3461  * @ratio Ratio of BCLK to Sample rate.
3462  *
3463  * Configures the DAI for a preset BCLK to sample rate ratio.
3464  */
3465 int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
3466 {
3467         if (dai->driver && dai->driver->ops->set_bclk_ratio)
3468                 return dai->driver->ops->set_bclk_ratio(dai, ratio);
3469         else
3470                 return -EINVAL;
3471 }
3472 EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
3473 
3474 /**
3475  * snd_soc_dai_set_fmt - configure DAI hardware audio format.
3476  * @dai: DAI
3477  * @fmt: SND_SOC_DAIFMT_ format value.
3478  *
3479  * Configures the DAI hardware format and clocking.
3480  */
3481 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
3482 {
3483         if (dai->driver == NULL)
3484                 return -EINVAL;
3485         if (dai->driver->ops->set_fmt == NULL)
3486                 return -ENOTSUPP;
3487         return dai->driver->ops->set_fmt(dai, fmt);
3488 }
3489 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
3490 
3491 /**
3492  * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
3493  * @slots: Number of slots in use.
3494  * @tx_mask: bitmask representing active TX slots.
3495  * @rx_mask: bitmask representing active RX slots.
3496  *
3497  * Generates the TDM tx and rx slot default masks for DAI.
3498  */
3499 static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
3500                                           unsigned int *tx_mask,
3501                                           unsigned int *rx_mask)
3502 {
3503         if (*tx_mask || *rx_mask)
3504                 return 0;
3505 
3506         if (!slots)
3507                 return -EINVAL;
3508 
3509         *tx_mask = (1 << slots) - 1;
3510         *rx_mask = (1 << slots) - 1;
3511 
3512         return 0;
3513 }
3514 
3515 /**
3516  * snd_soc_dai_set_tdm_slot - configure DAI TDM.
3517  * @dai: DAI
3518  * @tx_mask: bitmask representing active TX slots.
3519  * @rx_mask: bitmask representing active RX slots.
3520  * @slots: Number of slots in use.
3521  * @slot_width: Width in bits for each slot.
3522  *
3523  * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
3524  * specific.
3525  */
3526 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
3527         unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
3528 {
3529         if (dai->driver && dai->driver->ops->xlate_tdm_slot_mask)
3530                 dai->driver->ops->xlate_tdm_slot_mask(slots,
3531                                                 &tx_mask, &rx_mask);
3532         else
3533                 snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
3534 
3535         dai->tx_mask = tx_mask;
3536         dai->rx_mask = rx_mask;
3537 
3538         if (dai->driver && dai->driver->ops->set_tdm_slot)
3539                 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
3540                                 slots, slot_width);
3541         else
3542                 return -ENOTSUPP;
3543 }
3544 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
3545 
3546 /**
3547  * snd_soc_dai_set_channel_map - configure DAI audio channel map
3548  * @dai: DAI
3549  * @tx_num: how many TX channels
3550  * @tx_slot: pointer to an array which imply the TX slot number channel
3551  *           0~num-1 uses
3552  * @rx_num: how many RX channels
3553  * @rx_slot: pointer to an array which imply the RX slot number channel
3554  *           0~num-1 uses
3555  *
3556  * configure the relationship between channel number and TDM slot number.
3557  */
3558 int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
3559         unsigned int tx_num, unsigned int *tx_slot,
3560         unsigned int rx_num, unsigned int *rx_slot)
3561 {
3562         if (dai->driver && dai->driver->ops->set_channel_map)
3563                 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
3564                         rx_num, rx_slot);
3565         else
3566                 return -EINVAL;
3567 }
3568 EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
3569 
3570 /**
3571  * snd_soc_dai_set_tristate - configure DAI system or master clock.
3572  * @dai: DAI
3573  * @tristate: tristate enable
3574  *
3575  * Tristates the DAI so that others can use it.
3576  */
3577 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
3578 {
3579         if (dai->driver && dai->driver->ops->set_tristate)
3580                 return dai->driver->ops->set_tristate(dai, tristate);
3581         else
3582                 return -EINVAL;
3583 }
3584 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
3585 
3586 /**
3587  * snd_soc_dai_digital_mute - configure DAI system or master clock.
3588  * @dai: DAI
3589  * @mute: mute enable
3590  * @direction: stream to mute
3591  *
3592  * Mutes the DAI DAC.
3593  */
3594 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
3595                              int direction)
3596 {
3597         if (!dai->driver)
3598                 return -ENOTSUPP;
3599 
3600         if (dai->driver->ops->mute_stream)
3601                 return dai->driver->ops->mute_stream(dai, mute, direction);
3602         else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
3603                  dai->driver->ops->digital_mute)
3604                 return dai->driver->ops->digital_mute(dai, mute);
3605         else
3606                 return -ENOTSUPP;
3607 }
3608 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
3609 
3610 static int snd_soc_init_multicodec(struct snd_soc_card *card,
3611                                    struct snd_soc_dai_link *dai_link)
3612 {
3613         /* Legacy codec/codec_dai link is a single entry in multicodec */
3614         if (dai_link->codec_name || dai_link->codec_of_node ||
3615             dai_link->codec_dai_name) {
3616                 dai_link->num_codecs = 1;
3617 
3618                 dai_link->codecs = devm_kzalloc(card->dev,
3619                                 sizeof(struct snd_soc_dai_link_component),
3620                                 GFP_KERNEL);
3621                 if (!dai_link->codecs)
3622                         return -ENOMEM;
3623 
3624                 dai_link->codecs[0].name = dai_link->codec_name;
3625                 dai_link->codecs[0].of_node = dai_link->codec_of_node;
3626                 dai_link->codecs[0].dai_name = dai_link->codec_dai_name;
3627         }
3628 
3629         if (!dai_link->codecs) {
3630                 dev_err(card->dev, "ASoC: DAI link has no CODECs\n");
3631                 return -EINVAL;
3632         }
3633 
3634         return 0;
3635 }
3636 
3637 /**
3638  * snd_soc_register_card - Register a card with the ASoC core
3639  *
3640  * @card: Card to register
3641  *
3642  */
3643 int snd_soc_register_card(struct snd_soc_card *card)
3644 {
3645         int i, j, ret;
3646 
3647         if (!card->name || !card->dev)
3648                 return -EINVAL;
3649 
3650         for (i = 0; i < card->num_links; i++) {
3651                 struct snd_soc_dai_link *link = &card->dai_link[i];
3652 
3653                 ret = snd_soc_init_multicodec(card, link);
3654                 if (ret) {
3655                         dev_err(card->dev, "ASoC: failed to init multicodec\n");
3656                         return ret;
3657                 }
3658 
3659                 for (j = 0; j < link->num_codecs; j++) {
3660                         /*
3661                          * Codec must be specified by 1 of name or OF node,
3662                          * not both or neither.
3663                          */
3664                         if (!!link->codecs[j].name ==
3665                             !!link->codecs[j].of_node) {
3666                                 dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",
3667                                         link->name);
3668                                 return -EINVAL;
3669                         }
3670                         /* Codec DAI name must be specified */
3671                         if (!link->codecs[j].dai_name) {
3672                                 dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",
3673                                         link->name);
3674                                 return -EINVAL;
3675                         }
3676                 }
3677 
3678                 /*
3679                  * Platform may be specified by either name or OF node, but
3680                  * can be left unspecified, and a dummy platform will be used.
3681                  */
3682                 if (link->platform_name && link->platform_of_node) {
3683                         dev_err(card->dev,
3684                                 "ASoC: Both platform name/of_node are set for %s\n",
3685                                 link->name);
3686                         return -EINVAL;
3687                 }
3688 
3689                 /*
3690                  * CPU device may be specified by either name or OF node, but
3691                  * can be left unspecified, and will be matched based on DAI
3692                  * name alone..
3693                  */
3694                 if (link->cpu_name && link->cpu_of_node) {
3695                         dev_err(card->dev,
3696                                 "ASoC: Neither/both cpu name/of_node are set for %s\n",
3697                                 link->name);
3698                         return -EINVAL;
3699                 }
3700                 /*
3701                  * At least one of CPU DAI name or CPU device name/node must be
3702                  * specified
3703                  */
3704                 if (!link->cpu_dai_name &&
3705                     !(link->cpu_name || link->cpu_of_node)) {
3706                         dev_err(card->dev,
3707                                 "ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
3708                                 link->name);
3709                         return -EINVAL;
3710                 }
3711         }
3712 
3713         dev_set_drvdata(card->dev, card);
3714 
3715         snd_soc_initialize_card_lists(card);
3716 
3717         soc_init_card_debugfs(card);
3718 
3719         card->rtd = devm_kzalloc(card->dev,
3720                                  sizeof(struct snd_soc_pcm_runtime) *
3721                                  (card->num_links + card->num_aux_devs),
3722                                  GFP_KERNEL);
3723         if (card->rtd == NULL)
3724                 return -ENOMEM;
3725         card->num_rtd = 0;
3726         card->rtd_aux = &card->rtd[card->num_links];
3727 
3728         for (i = 0; i < card->num_links; i++) {
3729                 card->rtd[i].card = card;
3730                 card->rtd[i].dai_link = &card->dai_link[i];
3731                 card->rtd[i].codec_dais = devm_kzalloc(card->dev,
3732                                         sizeof(struct snd_soc_dai *) *
3733                                         (card->rtd[i].dai_link->num_codecs),
3734                                         GFP_KERNEL);
3735                 if (card->rtd[i].codec_dais == NULL)
3736                         return -ENOMEM;
3737         }
3738 
3739         for (i = 0; i < card->num_aux_devs; i++)
3740                 card->rtd_aux[i].card = card;
3741 
3742         INIT_LIST_HEAD(&card->dapm_dirty);
3743         card->instantiated = 0;
3744         mutex_init(&card->mutex);
3745         mutex_init(&card->dapm_mutex);
3746 
3747         ret = snd_soc_instantiate_card(card);
3748         if (ret != 0)
3749                 soc_cleanup_card_debugfs(card);
3750 
3751         /* deactivate pins to sleep state */
3752         for (i = 0; i < card->num_rtd; i++) {
3753                 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
3754                 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
3755                 int j;
3756 
3757                 for (j = 0; j < rtd->num_codecs; j++) {
3758                         struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
3759                         if (!codec_dai->active)
3760                                 pinctrl_pm_select_sleep_state(codec_dai->dev);
3761                 }
3762 
3763                 if (!cpu_dai->active)
3764                         pinctrl_pm_select_sleep_state(cpu_dai->dev);
3765         }
3766 
3767         return ret;
3768 }
3769 EXPORT_SYMBOL_GPL(snd_soc_register_card);
3770 
3771 /**
3772  * snd_soc_unregister_card - Unregister a card with the ASoC core
3773  *
3774  * @card: Card to unregister
3775  *
3776  */
3777 int snd_soc_unregister_card(struct snd_soc_card *card)
3778 {
3779         if (card->instantiated) {
3780                 card->instantiated = false;
3781                 snd_soc_dapm_shutdown(card);
3782                 soc_cleanup_card_resources(card);
3783         }
3784         dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
3785 
3786         return 0;
3787 }
3788 EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
3789 
3790 /*
3791  * Simplify DAI link configuration by removing ".-1" from device names
3792  * and sanitizing names.
3793  */
3794 static char *fmt_single_name(struct device *dev, int *id)
3795 {
3796         char *found, name[NAME_SIZE];
3797         int id1, id2;
3798 
3799         if (dev_name(dev) == NULL)
3800                 return NULL;
3801 
3802         strlcpy(name, dev_name(dev), NAME_SIZE);
3803 
3804         /* are we a "%s.%d" name (platform and SPI components) */
3805         found = strstr(name, dev->driver->name);
3806         if (found) {
3807                 /* get ID */
3808                 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
3809 
3810                         /* discard ID from name if ID == -1 */
3811                         if (*id == -1)
3812                                 found[strlen(dev->driver->name)] = '\0';
3813                 }
3814 
3815         } else {
3816                 /* I2C component devices are named "bus-addr"  */
3817                 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
3818                         char tmp[NAME_SIZE];
3819 
3820                         /* create unique ID number from I2C addr and bus */
3821                         *id = ((id1 & 0xffff) << 16) + id2;
3822 
3823                         /* sanitize component name for DAI link creation */
3824                         snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
3825                         strlcpy(name, tmp, NAME_SIZE);
3826                 } else
3827                         *id = 0;
3828         }
3829 
3830         return kstrdup(name, GFP_KERNEL);
3831 }
3832 
3833 /*
3834  * Simplify DAI link naming for single devices with multiple DAIs by removing
3835  * any ".-1" and using the DAI name (instead of device name).
3836  */
3837 static inline char *fmt_multiple_name(struct device *dev,
3838                 struct snd_soc_dai_driver *dai_drv)
3839 {
3840         if (dai_drv->name == NULL) {
3841                 dev_err(dev,
3842                         "ASoC: error - multiple DAI %s registered with no name\n",
3843                         dev_name(dev));
3844                 return NULL;
3845         }
3846 
3847         return kstrdup(dai_drv->name, GFP_KERNEL);
3848 }
3849 
3850 /**
3851  * snd_soc_unregister_dai - Unregister DAIs from the ASoC core
3852  *
3853  * @component: The component for which the DAIs should be unregistered
3854  */
3855 static void snd_soc_unregister_dais(struct snd_soc_component *component)
3856 {
3857         struct snd_soc_dai *dai, *_dai;
3858 
3859         list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
3860                 dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
3861                         dai->name);
3862                 list_del(&dai->list);
3863                 kfree(dai->name);
3864                 kfree(dai);
3865         }
3866 }
3867 
3868 /**
3869  * snd_soc_register_dais - Register a DAI with the ASoC core
3870  *
3871  * @component: The component the DAIs are registered for
3872  * @dai_drv: DAI driver to use for the DAIs
3873  * @count: Number of DAIs
3874  * @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the
3875  *                     parent's name.
3876  */
3877 static int snd_soc_register_dais(struct snd_soc_component *component,
3878         struct snd_soc_dai_driver *dai_drv, size_t count,
3879         bool legacy_dai_naming)
3880 {
3881         struct device *dev = component->dev;
3882         struct snd_soc_dai *dai;
3883         unsigned int i;
3884         int ret;
3885 
3886         dev_dbg(dev, "ASoC: dai register %s #%Zu\n", dev_name(dev), count);
3887 
3888         component->dai_drv = dai_drv;
3889         component->num_dai = count;
3890 
3891         for (i = 0; i < count; i++) {
3892 
3893                 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3894                 if (dai == NULL) {
3895                         ret = -ENOMEM;
3896                         goto err;
3897                 }
3898 
3899                 /*
3900                  * Back in the old days when we still had component-less DAIs,
3901                  * instead of having a static name, component-less DAIs would
3902                  * inherit the name of the parent device so it is possible to
3903                  * register multiple instances of the DAI. We still need to keep
3904                  * the same naming style even though those DAIs are not
3905                  * component-less anymore.
3906                  */
3907                 if (count == 1 && legacy_dai_naming) {
3908                         dai->name = fmt_single_name(dev, &dai->id);
3909                 } else {
3910                         dai->name = fmt_multiple_name(dev, &dai_drv[i]);
3911                         if (dai_drv[i].id)
3912                                 dai->id = dai_drv[i].id;
3913                         else
3914                                 dai->id = i;
3915                 }
3916                 if (dai->name == NULL) {
3917                         kfree(dai);
3918                         ret = -ENOMEM;
3919                         goto err;
3920                 }
3921 
3922                 dai->component = component;
3923                 dai->dev = dev;
3924                 dai->driver = &dai_drv[i];
3925                 if (!dai->driver->ops)
3926                         dai->driver->ops = &null_dai_ops;
3927 
3928                 list_add(&dai->list, &component->dai_list);
3929 
3930                 dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
3931         }
3932 
3933         return 0;
3934 
3935 err:
3936         snd_soc_unregister_dais(component);
3937 
3938         return ret;
3939 }
3940 
3941 static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,
3942         enum snd_soc_dapm_type type, int subseq)
3943 {
3944         struct snd_soc_component *component = dapm->component;
3945 
3946         component->driver->seq_notifier(component, type, subseq);
3947 }
3948 
3949 static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
3950         int event)
3951 {
3952         struct snd_soc_component *component = dapm->component;
3953 
3954         return component->driver->stream_event(component, event);
3955 }
3956 
3957 static int snd_soc_component_initialize(struct snd_soc_component *component,
3958         const struct snd_soc_component_driver *driver, struct device *dev)
3959 {
3960         struct snd_soc_dapm_context *dapm;
3961 
3962         component->name = fmt_single_name(dev, &component->id);
3963         if (!component->name) {
3964                 dev_err(dev, "ASoC: Failed to allocate name\n");
3965                 return -ENOMEM;
3966         }
3967 
3968         component->dev = dev;
3969         component->driver = driver;
3970         component->probe = component->driver->probe;
3971         component->remove = component->driver->remove;
3972 
3973         if (!component->dapm_ptr)
3974                 component->dapm_ptr = &component->dapm;
3975 
3976         dapm = component->dapm_ptr;
3977         dapm->dev = dev;
3978         dapm->component = component;
3979         dapm->bias_level = SND_SOC_BIAS_OFF;
3980         dapm->idle_bias_off = true;
3981         if (driver->seq_notifier)
3982                 dapm->seq_notifier = snd_soc_component_seq_notifier;
3983         if (driver->stream_event)
3984                 dapm->stream_event = snd_soc_component_stream_event;
3985 
3986         component->controls = driver->controls;
3987         component->num_controls = driver->num_controls;
3988         component->dapm_widgets = driver->dapm_widgets;
3989         component->num_dapm_widgets = driver->num_dapm_widgets;
3990         component->dapm_routes = driver->dapm_routes;
3991         component->num_dapm_routes = driver->num_dapm_routes;
3992 
3993         INIT_LIST_HEAD(&component->dai_list);
3994         mutex_init(&component->io_mutex);
3995 
3996         return 0;
3997 }
3998 
3999 static void snd_soc_component_init_regmap(struct snd_soc_component *component)
4000 {
4001         if (!component->regmap)
4002                 component->regmap = dev_get_regmap(component->dev, NULL);
4003         if (component->regmap) {
4004                 int val_bytes = regmap_get_val_bytes(component->regmap);
4005                 /* Errors are legitimate for non-integer byte multiples */
4006                 if (val_bytes > 0)
4007                         component->val_bytes = val_bytes;
4008         }
4009 }
4010 
4011 static void snd_soc_component_add_unlocked(struct snd_soc_component *component)
4012 {
4013         if (!component->write && !component->read)
4014                 snd_soc_component_init_regmap(component);
4015 
4016         list_add(&component->list, &component_list);
4017 }
4018 
4019 static void snd_soc_component_add(struct snd_soc_component *component)
4020 {
4021         mutex_lock(&client_mutex);
4022         snd_soc_component_add_unlocked(component);
4023         mutex_unlock(&client_mutex);
4024 }
4025 
4026 static void snd_soc_component_cleanup(struct snd_soc_component *component)
4027 {
4028         snd_soc_unregister_dais(component);
4029         kfree(component->name);
4030 }
4031 
4032 static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
4033 {
4034         list_del(&component->list);
4035 }
4036 
4037 static void snd_soc_component_del(struct snd_soc_component *component)
4038 {
4039         mutex_lock(&client_mutex);
4040         snd_soc_component_del_unlocked(component);
4041         mutex_unlock(&client_mutex);
4042 }
4043 
4044 int snd_soc_register_component(struct device *dev,
4045                                const struct snd_soc_component_driver *cmpnt_drv,
4046                                struct snd_soc_dai_driver *dai_drv,
4047                                int num_dai)
4048 {
4049         struct snd_soc_component *cmpnt;
4050         int ret;
4051 
4052         cmpnt = kzalloc(sizeof(*cmpnt), GFP_KERNEL);
4053         if (!cmpnt) {
4054                 dev_err(dev, "ASoC: Failed to allocate memory\n");
4055                 return -ENOMEM;
4056         }
4057 
4058         ret = snd_soc_component_initialize(cmpnt, cmpnt_drv, dev);
4059         if (ret)
4060                 goto err_free;
4061 
4062         cmpnt->ignore_pmdown_time = true;
4063         cmpnt->registered_as_component = true;
4064 
4065         ret = snd_soc_register_dais(cmpnt, dai_drv, num_dai, true);
4066         if (ret < 0) {
4067                 dev_err(dev, "ASoC: Failed to regster DAIs: %d\n", ret);
4068                 goto err_cleanup;
4069         }
4070 
4071         snd_soc_component_add(cmpnt);
4072 
4073         return 0;
4074 
4075 err_cleanup:
4076         snd_soc_component_cleanup(cmpnt);
4077 err_free:
4078         kfree(cmpnt);
4079         return ret;
4080 }
4081 EXPORT_SYMBOL_GPL(snd_soc_register_component);
4082 
4083 /**
4084  * snd_soc_unregister_component - Unregister a component from the ASoC core
4085  *
4086  */
4087 void snd_soc_unregister_component(struct device *dev)
4088 {
4089         struct snd_soc_component *cmpnt;
4090 
4091         list_for_each_entry(cmpnt, &component_list, list) {
4092                 if (dev == cmpnt->dev && cmpnt->registered_as_component)
4093                         goto found;
4094         }
4095         return;
4096 
4097 found:
4098         snd_soc_component_del(cmpnt);
4099         snd_soc_component_cleanup(cmpnt);
4100         kfree(cmpnt);
4101 }
4102 EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
4103 
4104 static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
4105 {
4106         struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
4107 
4108         return platform->driver->probe(platform);
4109 }
4110 
4111 static void snd_soc_platform_drv_remove(struct snd_soc_component *component)
4112 {
4113         struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
4114 
4115         platform->driver->remove(platform);
4116 }
4117 
4118 /**
4119  * snd_soc_add_platform - Add a platform to the ASoC core
4120  * @dev: The parent device for the platform
4121  * @platform: The platform to add
4122  * @platform_driver: The driver for the platform
4123  */
4124 int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
4125                 const struct snd_soc_platform_driver *platform_drv)
4126 {
4127         int ret;
4128 
4129         ret = snd_soc_component_initialize(&platform->component,
4130                         &platform_drv->component_driver, dev);
4131         if (ret)
4132                 return ret;
4133 
4134         platform->dev = dev;
4135         platform->driver = platform_drv;
4136 
4137         if (platform_drv->probe)
4138                 platform->component.probe = snd_soc_platform_drv_probe;
4139         if (platform_drv->remove)
4140                 platform->component.remove = snd_soc_platform_drv_remove;
4141 
4142 #ifdef CONFIG_DEBUG_FS
4143         platform->component.debugfs_prefix = "platform";
4144 #endif
4145 
4146         mutex_lock(&client_mutex);
4147         snd_soc_component_add_unlocked(&platform->component);
4148         list_add(&platform->list, &platform_list);
4149         mutex_unlock(&client_mutex);
4150 
4151         dev_dbg(dev, "ASoC: Registered platform '%s'\n",
4152                 platform->component.name);
4153 
4154         return 0;
4155 }
4156 EXPORT_SYMBOL_GPL(snd_soc_add_platform);
4157 
4158 /**
4159  * snd_soc_register_platform - Register a platform with the ASoC core
4160  *
4161  * @platform: platform to register
4162  */
4163 int snd_soc_register_platform(struct device *dev,
4164                 const struct snd_soc_platform_driver *platform_drv)
4165 {
4166         struct snd_soc_platform *platform;
4167         int ret;
4168 
4169         dev_dbg(dev, "ASoC: platform register %s\n", dev_name(dev));
4170 
4171         platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
4172         if (platform == NULL)
4173                 return -ENOMEM;
4174 
4175         ret = snd_soc_add_platform(dev, platform, platform_drv);
4176         if (ret)
4177                 kfree(platform);
4178 
4179         return ret;
4180 }
4181 EXPORT_SYMBOL_GPL(snd_soc_register_platform);
4182 
4183 /**
4184  * snd_soc_remove_platform - Remove a platform from the ASoC core
4185  * @platform: the platform to remove
4186  */
4187 void snd_soc_remove_platform(struct snd_soc_platform *platform)
4188 {
4189 
4190         mutex_lock(&client_mutex);
4191         list_del(&platform->list);
4192         snd_soc_component_del_unlocked(&platform->component);
4193         mutex_unlock(&client_mutex);
4194 
4195         dev_dbg(platform->dev, "ASoC: Unregistered platform '%s'\n",
4196                 platform->component.name);
4197 
4198         snd_soc_component_cleanup(&platform->component);
4199 }
4200 EXPORT_SYMBOL_GPL(snd_soc_remove_platform);
4201 
4202 struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev)
4203 {
4204         struct snd_soc_platform *platform;
4205 
4206         list_for_each_entry(platform, &platform_list, list) {
4207                 if (dev == platform->dev)
4208                         return platform;
4209         }
4210 
4211         return NULL;
4212 }
4213 EXPORT_SYMBOL_GPL(snd_soc_lookup_platform);
4214 
4215 /**
4216  * snd_soc_unregister_platform - Unregister a platform from the ASoC core
4217  *
4218  * @platform: platform to unregister
4219  */
4220 void snd_soc_unregister_platform(struct device *dev)
4221 {
4222         struct snd_soc_platform *platform;
4223 
4224         platform = snd_soc_lookup_platform(dev);
4225         if (!platform)
4226                 return;
4227 
4228         snd_soc_remove_platform(platform);
4229         kfree(platform);
4230 }
4231 EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
4232 
4233 static u64 codec_format_map[] = {
4234         SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
4235         SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
4236         SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
4237         SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
4238         SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
4239         SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
4240         SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
4241         SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
4242         SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
4243         SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
4244         SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
4245         SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
4246         SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
4247         SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
4248         SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
4249         | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
4250 };
4251 
4252 /* Fix up the DAI formats for endianness: codecs don't actually see
4253  * the endianness of the data but we're using the CPU format
4254  * definitions which do need to include endianness so we ensure that
4255  * codec DAIs always have both big and little endian variants set.
4256  */
4257 static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
4258 {
4259         int i;
4260 
4261         for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
4262                 if (stream->formats & codec_format_map[i])
4263                         stream->formats |= codec_format_map[i];
4264 }
4265 
4266 static int snd_soc_codec_drv_probe(struct snd_soc_component *component)
4267 {
4268         struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
4269 
4270         return codec->driver->probe(codec);
4271 }
4272 
4273 static void snd_soc_codec_drv_remove(struct snd_soc_component *component)
4274 {
4275         struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
4276 
4277         codec->driver->remove(codec);
4278 }
4279 
4280 static int snd_soc_codec_drv_write(struct snd_soc_component *component,
4281         unsigned int reg, unsigned int val)
4282 {
4283         struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
4284 
4285         return codec->driver->write(codec, reg, val);
4286 }
4287 
4288 static int snd_soc_codec_drv_read(struct snd_soc_component *component,
4289         unsigned int reg, unsigned int *val)
4290 {
4291         struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
4292 
4293         *val = codec->driver->read(codec, reg);
4294 
4295         return 0;
4296 }
4297 
4298 static int snd_soc_codec_set_bias_level(struct snd_soc_dapm_context *dapm,
4299         enum snd_soc_bias_level level)
4300 {
4301         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
4302 
4303         return codec->driver->set_bias_level(codec, level);
4304 }
4305 
4306 /**
4307  * snd_soc_register_codec - Register a codec with the ASoC core
4308  *
4309  * @codec: codec to register
4310  */
4311 int snd_soc_register_codec(struct device *dev,
4312                            const struct snd_soc_codec_driver *codec_drv,
4313                            struct snd_soc_dai_driver *dai_drv,
4314                            int num_dai)
4315 {
4316         struct snd_soc_codec *codec;
4317         struct snd_soc_dai *dai;
4318         int ret, i;
4319 
4320         dev_dbg(dev, "codec register %s\n", dev_name(dev));
4321 
4322         codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
4323         if (codec == NULL)
4324                 return -ENOMEM;
4325 
4326         codec->component.dapm_ptr = &codec->dapm;
4327         codec->component.codec = codec;
4328 
4329         ret = snd_soc_component_initialize(&codec->component,
4330                         &codec_drv->component_driver, dev);
4331         if (ret)
4332                 goto err_free;
4333 
4334         if (codec_drv->controls) {
4335                 codec->component.controls = codec_drv->controls;
4336                 codec->component.num_controls = codec_drv->num_controls;
4337         }
4338         if (codec_drv->dapm_widgets) {
4339                 codec->component.dapm_widgets = codec_drv->dapm_widgets;
4340                 codec->component.num_dapm_widgets = codec_drv->num_dapm_widgets;
4341         }
4342         if (codec_drv->dapm_routes) {
4343                 codec->component.dapm_routes = codec_drv->dapm_routes;
4344                 codec->component.num_dapm_routes = codec_drv->num_dapm_routes;
4345         }
4346 
4347         if (codec_drv->probe)
4348                 codec->component.probe = snd_soc_codec_drv_probe;
4349         if (codec_drv->remove)
4350                 codec->component.remove = snd_soc_codec_drv_remove;
4351         if (codec_drv->write)
4352                 codec->component.write = snd_soc_codec_drv_write;
4353         if (codec_drv->read)
4354                 codec->component.read = snd_soc_codec_drv_read;
4355         codec->component.ignore_pmdown_time = codec_drv->ignore_pmdown_time;
4356         codec->dapm.idle_bias_off = codec_drv->idle_bias_off;
4357         codec->dapm.suspend_bias_off = codec_drv->suspend_bias_off;
4358         if (codec_drv->seq_notifier)
4359                 codec->dapm.seq_notifier = codec_drv->seq_notifier;
4360         if (codec_drv->set_bias_level)
4361                 codec->dapm.set_bias_level = snd_soc_codec_set_bias_level;
4362         codec->dev = dev;
4363         codec->driver = codec_drv;
4364         codec->component.val_bytes = codec_drv->reg_word_size;
4365         mutex_init(&codec->mutex);
4366 
4367 #ifdef CONFIG_DEBUG_FS
4368         codec->component.init_debugfs = soc_init_codec_debugfs;
4369         codec->component.debugfs_prefix = "codec";
4370 #endif
4371 
4372         if (codec_drv->get_regmap)
4373                 codec->component.regmap = codec_drv->get_regmap(dev);
4374 
4375         for (i = 0; i < num_dai; i++) {
4376                 fixup_codec_formats(&dai_drv[i].playback);
4377                 fixup_codec_formats(&dai_drv[i].capture);
4378         }
4379 
4380         ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);
4381         if (ret < 0) {
4382                 dev_err(dev, "ASoC: Failed to regster DAIs: %d\n", ret);
4383                 goto err_cleanup;
4384         }
4385 
4386         list_for_each_entry(dai, &codec->component.dai_list, list)
4387                 dai->codec = codec;
4388 
4389         mutex_lock(&client_mutex);
4390         snd_soc_component_add_unlocked(&codec->component);
4391         list_add(&codec->list, &codec_list);
4392         mutex_unlock(&client_mutex);
4393 
4394         dev_dbg(codec->dev, "ASoC: Registered codec '%s'\n",
4395                 codec->component.name);
4396         return 0;
4397 
4398 err_cleanup:
4399         snd_soc_component_cleanup(&codec->component);
4400 err_free:
4401         kfree(codec);
4402         return ret;
4403 }
4404 EXPORT_SYMBOL_GPL(snd_soc_register_codec);
4405 
4406 /**
4407  * snd_soc_unregister_codec - Unregister a codec from the ASoC core
4408  *
4409  * @codec: codec to unregister
4410  */
4411 void snd_soc_unregister_codec(struct device *dev)
4412 {
4413         struct snd_soc_codec *codec;
4414 
4415         list_for_each_entry(codec, &codec_list, list) {
4416                 if (dev == codec->dev)
4417                         goto found;
4418         }
4419         return;
4420 
4421 found:
4422 
4423         mutex_lock(&client_mutex);
4424         list_del(&codec->list);
4425         snd_soc_component_del_unlocked(&codec->component);
4426         mutex_unlock(&client_mutex);
4427 
4428         dev_dbg(codec->dev, "ASoC: Unregistered codec '%s'\n",
4429                         codec->component.name);
4430 
4431         snd_soc_component_cleanup(&codec->component);
4432         snd_soc_cache_exit(codec);
4433         kfree(codec);
4434 }
4435 EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
4436 
4437 /* Retrieve a card's name from device tree */
4438 int snd_soc_of_parse_card_name(struct snd_soc_card *card,
4439                                const char *propname)
4440 {
4441         struct device_node *np;
4442         int ret;
4443 
4444         if (!card->dev) {
4445                 pr_err("card->dev is not set before calling %s\n", __func__);
4446                 return -EINVAL;
4447         }
4448 
4449         np = card->dev->of_node;
4450 
4451         ret = of_property_read_string_index(np, propname, 0, &card->name);
4452         /*
4453          * EINVAL means the property does not exist. This is fine providing
4454          * card->name was previously set, which is checked later in
4455          * snd_soc_register_card.
4456          */
4457         if (ret < 0 && ret != -EINVAL) {
4458                 dev_err(card->dev,
4459                         "ASoC: Property '%s' could not be read: %d\n",
4460                         propname, ret);
4461                 return ret;
4462         }
4463 
4464         return 0;
4465 }
4466 EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
4467 
4468 static const struct snd_soc_dapm_widget simple_widgets[] = {
4469         SND_SOC_DAPM_MIC("Microphone", NULL),
4470         SND_SOC_DAPM_LINE("Line", NULL),
4471         SND_SOC_DAPM_HP("Headphone", NULL),
4472         SND_SOC_DAPM_SPK("Speaker", NULL),
4473 };
4474 
4475 int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
4476                                           const char *propname)
4477 {
4478         struct device_node *np = card->dev->of_node;
4479         struct snd_soc_dapm_widget *widgets;
4480         const char *template, *wname;
4481         int i, j, num_widgets, ret;
4482 
4483         num_widgets = of_property_count_strings(np, propname);
4484         if (num_widgets < 0) {
4485                 dev_err(card->dev,
4486                         "ASoC: Property '%s' does not exist\n", propname);
4487                 return -EINVAL;
4488         }
4489         if (num_widgets & 1) {
4490                 dev_err(card->dev,
4491                         "ASoC: Property '%s' length is not even\n", propname);
4492                 return -EINVAL;
4493         }
4494 
4495         num_widgets /= 2;
4496         if (!num_widgets) {
4497                 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
4498                         propname);
4499                 return -EINVAL;
4500         }
4501 
4502         widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets),
4503                                GFP_KERNEL);
4504         if (!widgets) {
4505                 dev_err(card->dev,
4506                         "ASoC: Could not allocate memory for widgets\n");
4507                 return -ENOMEM;
4508         }
4509 
4510         for (i = 0; i < num_widgets; i++) {
4511                 ret = of_property_read_string_index(np, propname,
4512                         2 * i, &template);
4513                 if (ret) {
4514                         dev_err(card->dev,
4515                                 "ASoC: Property '%s' index %d read error:%d\n",
4516                                 propname, 2 * i, ret);
4517                         return -EINVAL;
4518                 }
4519 
4520                 for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) {
4521                         if (!strncmp(template, simple_widgets[j].name,
4522                                      strlen(simple_widgets[j].name))) {
4523                                 widgets[i] = simple_widgets[j];
4524                                 break;
4525                         }
4526                 }
4527 
4528                 if (j >= ARRAY_SIZE(simple_widgets)) {
4529                         dev_err(card->dev,
4530                                 "ASoC: DAPM widget '%s' is not supported\n",
4531                                 template);
4532                         return -EINVAL;
4533                 }
4534 
4535                 ret = of_property_read_string_index(np, propname,
4536                                                     (2 * i) + 1,
4537                                                     &wname);
4538                 if (ret) {
4539                         dev_err(card->dev,
4540                                 "ASoC: Property '%s' index %d read error:%d\n",
4541                                 propname, (2 * i) + 1, ret);
4542                         return -EINVAL;
4543                 }
4544 
4545                 widgets[i].name = wname;
4546         }
4547 
4548         card->dapm_widgets = widgets;
4549         card->num_dapm_widgets = num_widgets;
4550 
4551         return 0;
4552 }
4553 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);
4554 
4555 int snd_soc_of_parse_tdm_slot(struct device_node *np,
4556                               unsigned int *slots,
4557                               unsigned int *slot_width)
4558 {
4559         u32 val;
4560         int ret;
4561 
4562         if (of_property_read_bool(np, "dai-tdm-slot-num")) {
4563                 ret = of_property_read_u32(np, "dai-tdm-slot-num", &val);
4564                 if (ret)
4565                         return ret;
4566 
4567                 if (slots)
4568                         *slots = val;
4569         }
4570 
4571         if (of_property_read_bool(np, "dai-tdm-slot-width")) {
4572                 ret = of_property_read_u32(np, "dai-tdm-slot-width", &val);
4573                 if (ret)
4574                         return ret;
4575 
4576                 if (slot_width)
4577                         *slot_width = val;
4578         }
4579 
4580         return 0;
4581 }
4582 EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot);
4583 
4584 int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
4585                                    const char *propname)
4586 {
4587         struct device_node *np = card->dev->of_node;
4588         int num_routes;
4589         struct snd_soc_dapm_route *routes;
4590         int i, ret;
4591 
4592         num_routes = of_property_count_strings(np, propname);
4593         if (num_routes < 0 || num_routes & 1) {
4594                 dev_err(card->dev,
4595                         "ASoC: Property '%s' does not exist or its length is not even\n",
4596                         propname);
4597                 return -EINVAL;
4598         }
4599         num_routes /= 2;
4600         if (!num_routes) {
4601                 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
4602                         propname);
4603                 return -EINVAL;
4604         }
4605 
4606         routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
4607                               GFP_KERNEL);
4608         if (!routes) {
4609                 dev_err(card->dev,
4610                         "ASoC: Could not allocate DAPM route table\n");
4611                 return -EINVAL;
4612         }
4613 
4614         for (i = 0; i < num_routes; i++) {
4615                 ret = of_property_read_string_index(np, propname,
4616                         2 * i, &routes[i].sink);
4617                 if (ret) {
4618                         dev_err(card->dev,
4619                                 "ASoC: Property '%s' index %d could not be read: %d\n",
4620                                 propname, 2 * i, ret);
4621                         return -EINVAL;
4622                 }
4623                 ret = of_property_read_string_index(np, propname,
4624                         (2 * i) + 1, &routes[i].source);
4625                 if (ret) {
4626                         dev_err(card->dev,
4627                                 "ASoC: Property '%s' index %d could not be read: %d\n",
4628                                 propname, (2 * i) + 1, ret);
4629                         return -EINVAL;
4630                 }
4631         }
4632 
4633         card->num_dapm_routes = num_routes;
4634         card->dapm_routes = routes;
4635 
4636         return 0;
4637 }
4638 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
4639 
4640 unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
4641                                      const char *prefix,
4642                                      struct device_node **bitclkmaster,
4643                                      struct device_node **framemaster)
4644 {
4645         int ret, i;
4646         char prop[128];
4647         unsigned int format = 0;
4648         int bit, frame;
4649         const char *str;
4650         struct {
4651                 char *name;
4652                 unsigned int val;
4653         } of_fmt_table[] = {
4654                 { "i2s",        SND_SOC_DAIFMT_I2S },
4655                 { "right_j",    SND_SOC_DAIFMT_RIGHT_J },
4656                 { "left_j",     SND_SOC_DAIFMT_LEFT_J },
4657                 { "dsp_a",      SND_SOC_DAIFMT_DSP_A },
4658                 { "dsp_b",      SND_SOC_DAIFMT_DSP_B },
4659                 { "ac97",       SND_SOC_DAIFMT_AC97 },
4660                 { "pdm",        SND_SOC_DAIFMT_PDM},
4661                 { "msb",        SND_SOC_DAIFMT_MSB },
4662                 { "lsb",        SND_SOC_DAIFMT_LSB },
4663         };
4664 
4665         if (!prefix)
4666                 prefix = "";
4667 
4668         /*
4669          * check "[prefix]format = xxx"
4670          * SND_SOC_DAIFMT_FORMAT_MASK area
4671          */
4672         snprintf(prop, sizeof(prop), "%sformat", prefix);
4673         ret = of_property_read_string(np, prop, &str);
4674         if (ret == 0) {
4675                 for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) {
4676                         if (strcmp(str, of_fmt_table[i].name) == 0) {
4677                                 format |= of_fmt_table[i].val;
4678                                 break;
4679                         }
4680                 }
4681         }
4682 
4683         /*
4684          * check "[prefix]continuous-clock"
4685          * SND_SOC_DAIFMT_CLOCK_MASK area
4686          */
4687         snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);
4688         if (of_get_property(np, prop, NULL))
4689                 format |= SND_SOC_DAIFMT_CONT;
4690         else
4691                 format |= SND_SOC_DAIFMT_GATED;
4692 
4693         /*
4694          * check "[prefix]bitclock-inversion"
4695          * check "[prefix]frame-inversion"
4696          * SND_SOC_DAIFMT_INV_MASK area
4697          */
4698         snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix);
4699         bit = !!of_get_property(np, prop, NULL);
4700 
4701         snprintf(prop, sizeof(prop), "%sframe-inversion", prefix);
4702         frame = !!of_get_property(np, prop, NULL);
4703 
4704         switch ((bit << 4) + frame) {
4705         case 0x11:
4706                 format |= SND_SOC_DAIFMT_IB_IF;
4707                 break;
4708         case 0x10:
4709                 format |= SND_SOC_DAIFMT_IB_NF;
4710                 break;
4711         case 0x01:
4712                 format |= SND_SOC_DAIFMT_NB_IF;
4713                 break;
4714         default:
4715                 /* SND_SOC_DAIFMT_NB_NF is default */
4716                 break;
4717         }
4718 
4719         /*
4720          * check "[prefix]bitclock-master"
4721          * check "[prefix]frame-master"
4722          * SND_SOC_DAIFMT_MASTER_MASK area
4723          */
4724         snprintf(prop, sizeof(prop), "%sbitclock-master", prefix);
4725         bit = !!of_get_property(np, prop, NULL);
4726         if (bit && bitclkmaster)
4727                 *bitclkmaster = of_parse_phandle(np, prop, 0);
4728 
4729         snprintf(prop, sizeof(prop), "%sframe-master", prefix);
4730         frame = !!of_get_property(np, prop, NULL);
4731         if (frame && framemaster)
4732                 *framemaster = of_parse_phandle(np, prop, 0);
4733 
4734         switch ((bit << 4) + frame) {
4735         case 0x11:
4736                 format |= SND_SOC_DAIFMT_CBM_CFM;
4737                 break;
4738         case 0x10:
4739                 format |= SND_SOC_DAIFMT_CBM_CFS;
4740                 break;
4741         case 0x01:
4742                 format |= SND_SOC_DAIFMT_CBS_CFM;
4743                 break;
4744         default:
4745                 format |= SND_SOC_DAIFMT_CBS_CFS;
4746                 break;
4747         }
4748 
4749         return format;
4750 }
4751 EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt);
4752 
4753 int snd_soc_of_get_dai_name(struct device_node *of_node,
4754                             const char **dai_name)
4755 {
4756         struct snd_soc_component *pos;
4757         struct of_phandle_args args;
4758         int ret;
4759 
4760         ret = of_parse_phandle_with_args(of_node, "sound-dai",
4761                                          "#sound-dai-cells", 0, &args);
4762         if (ret)
4763                 return ret;
4764 
4765         ret = -EPROBE_DEFER;
4766 
4767         mutex_lock(&client_mutex);
4768         list_for_each_entry(pos, &component_list, list) {
4769                 if (pos->dev->of_node != args.np)
4770                         continue;
4771 
4772                 if (pos->driver->of_xlate_dai_name) {
4773                         ret = pos->driver->of_xlate_dai_name(pos, &args, dai_name);
4774                 } else {
4775                         int id = -1;
4776 
4777                         switch (args.args_count) {
4778                         case 0:
4779                                 id = 0; /* same as dai_drv[0] */
4780                                 break;
4781                         case 1:
4782                                 id = args.args[0];
4783                                 break;
4784                         default:
4785                                 /* not supported */
4786                                 break;
4787                         }
4788 
4789                         if (id < 0 || id >= pos->num_dai) {
4790                                 ret = -EINVAL;
4791                                 continue;
4792                         }
4793 
4794                         ret = 0;
4795 
4796                         *dai_name = pos->dai_drv[id].name;
4797                         if (!*dai_name)
4798                                 *dai_name = pos->name;
4799                 }
4800 
4801                 break;
4802         }
4803         mutex_unlock(&client_mutex);
4804 
4805         of_node_put(args.np);
4806 
4807         return ret;
4808 }
4809 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);
4810 
4811 static int __init snd_soc_init(void)
4812 {
4813 #ifdef CONFIG_DEBUG_FS
4814         snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
4815         if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
4816                 pr_warn("ASoC: Failed to create debugfs directory\n");
4817                 snd_soc_debugfs_root = NULL;
4818         }
4819 
4820         if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
4821                                  &codec_list_fops))
4822                 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
4823 
4824         if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
4825                                  &dai_list_fops))
4826                 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
4827 
4828         if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
4829                                  &platform_list_fops))
4830                 pr_warn("ASoC: Failed to create platform list debugfs file\n");
4831 #endif
4832 
4833         snd_soc_util_init();
4834 
4835         return platform_driver_register(&soc_driver);
4836 }
4837 module_init(snd_soc_init);
4838 
4839 static void __exit snd_soc_exit(void)
4840 {
4841         snd_soc_util_exit();
4842 
4843 #ifdef CONFIG_DEBUG_FS
4844         debugfs_remove_recursive(snd_soc_debugfs_root);
4845 #endif
4846         platform_driver_unregister(&soc_driver);
4847 }
4848 module_exit(snd_soc_exit);
4849 
4850 /* Module information */
4851 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
4852 MODULE_DESCRIPTION("ALSA SoC Core");
4853 MODULE_LICENSE("GPL");
4854 MODULE_ALIAS("platform:soc-audio");
4855 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us