1 // SPDX-License-Identifier: GPL-2.0+
3 // soc-core.c -- ALSA SoC Audio Layer
5 // Copyright 2005 Wolfson Microelectronics PLC.
6 // Copyright 2005 Openedhand Ltd.
7 // Copyright (C) 2010 Slimlogic Ltd.
8 // Copyright (C) 2010 Texas Instruments Inc.
10 // Author: Liam Girdwood <lrg@slimlogic.co.uk>
11 // with code, comments and ideas from :-
12 // Richard Purdie <richard@openedhand.com>
15 // o Add hw rules to enforce rates, etc.
16 // o More testing with other codecs/machines.
17 // o Add more codecs and platforms to ensure good API coverage.
18 // o Support TDM on PCM and I2S
20 #include <linux/module.h>
21 #include <linux/moduleparam.h>
22 #include <linux/init.h>
23 #include <linux/delay.h>
25 #include <linux/bitops.h>
26 #include <linux/debugfs.h>
27 #include <linux/platform_device.h>
28 #include <linux/pinctrl/consumer.h>
29 #include <linux/ctype.h>
30 #include <linux/slab.h>
32 #include <linux/of_graph.h>
33 #include <linux/dmi.h>
34 #include <sound/core.h>
35 #include <sound/jack.h>
36 #include <sound/pcm.h>
37 #include <sound/pcm_params.h>
38 #include <sound/soc.h>
39 #include <sound/soc-dpcm.h>
40 #include <sound/soc-topology.h>
41 #include <sound/initval.h>
43 #define CREATE_TRACE_POINTS
44 #include <trace/events/asoc.h>
48 #ifdef CONFIG_DEBUG_FS
49 struct dentry
*snd_soc_debugfs_root
;
50 EXPORT_SYMBOL_GPL(snd_soc_debugfs_root
);
53 static DEFINE_MUTEX(client_mutex
);
54 static LIST_HEAD(component_list
);
55 static LIST_HEAD(unbind_card_list
);
57 #define for_each_component(component) \
58 list_for_each_entry(component, &component_list, list)
61 * This is a timeout to do a DAPM powerdown after a stream is closed().
62 * It can be used to eliminate pops between different playback streams, e.g.
63 * between two audio tracks.
65 static int pmdown_time
= 5000;
66 module_param(pmdown_time
, int, 0);
67 MODULE_PARM_DESC(pmdown_time
, "DAPM stream powerdown time (msecs)");
70 * If a DMI filed contain strings in this blacklist (e.g.
71 * "Type2 - Board Manufacturer" or "Type1 - TBD by OEM"), it will be taken
72 * as invalid and dropped when setting the card long name from DMI info.
74 static const char * const dmi_blacklist
[] = {
75 "To be filled by OEM",
81 NULL
, /* terminator */
84 static ssize_t
pmdown_time_show(struct device
*dev
,
85 struct device_attribute
*attr
, char *buf
)
87 struct snd_soc_pcm_runtime
*rtd
= dev_get_drvdata(dev
);
89 return sprintf(buf
, "%ld\n", rtd
->pmdown_time
);
92 static ssize_t
pmdown_time_set(struct device
*dev
,
93 struct device_attribute
*attr
,
94 const char *buf
, size_t count
)
96 struct snd_soc_pcm_runtime
*rtd
= dev_get_drvdata(dev
);
99 ret
= kstrtol(buf
, 10, &rtd
->pmdown_time
);
106 static DEVICE_ATTR(pmdown_time
, 0644, pmdown_time_show
, pmdown_time_set
);
108 static struct attribute
*soc_dev_attrs
[] = {
109 &dev_attr_pmdown_time
.attr
,
113 static umode_t
soc_dev_attr_is_visible(struct kobject
*kobj
,
114 struct attribute
*attr
, int idx
)
116 struct device
*dev
= kobj_to_dev(kobj
);
117 struct snd_soc_pcm_runtime
*rtd
= dev_get_drvdata(dev
);
119 if (attr
== &dev_attr_pmdown_time
.attr
)
120 return attr
->mode
; /* always visible */
121 return rtd
->num_codecs
? attr
->mode
: 0; /* enabled only with codec */
124 static const struct attribute_group soc_dapm_dev_group
= {
125 .attrs
= soc_dapm_dev_attrs
,
126 .is_visible
= soc_dev_attr_is_visible
,
129 static const struct attribute_group soc_dev_group
= {
130 .attrs
= soc_dev_attrs
,
131 .is_visible
= soc_dev_attr_is_visible
,
134 static const struct attribute_group
*soc_dev_attr_groups
[] = {
140 #ifdef CONFIG_DEBUG_FS
141 static void soc_init_component_debugfs(struct snd_soc_component
*component
)
143 if (!component
->card
->debugfs_card_root
)
146 if (component
->debugfs_prefix
) {
149 name
= kasprintf(GFP_KERNEL
, "%s:%s",
150 component
->debugfs_prefix
, component
->name
);
152 component
->debugfs_root
= debugfs_create_dir(name
,
153 component
->card
->debugfs_card_root
);
157 component
->debugfs_root
= debugfs_create_dir(component
->name
,
158 component
->card
->debugfs_card_root
);
161 if (!component
->debugfs_root
) {
162 dev_warn(component
->dev
,
163 "ASoC: Failed to create component debugfs directory\n");
167 snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component
),
168 component
->debugfs_root
);
171 static void soc_cleanup_component_debugfs(struct snd_soc_component
*component
)
173 debugfs_remove_recursive(component
->debugfs_root
);
176 static int dai_list_show(struct seq_file
*m
, void *v
)
178 struct snd_soc_component
*component
;
179 struct snd_soc_dai
*dai
;
181 mutex_lock(&client_mutex
);
183 for_each_component(component
)
184 for_each_component_dais(component
, dai
)
185 seq_printf(m
, "%s\n", dai
->name
);
187 mutex_unlock(&client_mutex
);
191 DEFINE_SHOW_ATTRIBUTE(dai_list
);
193 static int component_list_show(struct seq_file
*m
, void *v
)
195 struct snd_soc_component
*component
;
197 mutex_lock(&client_mutex
);
199 for_each_component(component
)
200 seq_printf(m
, "%s\n", component
->name
);
202 mutex_unlock(&client_mutex
);
206 DEFINE_SHOW_ATTRIBUTE(component_list
);
208 static void soc_init_card_debugfs(struct snd_soc_card
*card
)
210 if (!snd_soc_debugfs_root
)
213 card
->debugfs_card_root
= debugfs_create_dir(card
->name
,
214 snd_soc_debugfs_root
);
215 if (!card
->debugfs_card_root
) {
217 "ASoC: Failed to create card debugfs directory\n");
221 card
->debugfs_pop_time
= debugfs_create_u32("dapm_pop_time", 0644,
222 card
->debugfs_card_root
,
224 if (!card
->debugfs_pop_time
)
226 "ASoC: Failed to create pop time debugfs file\n");
229 static void soc_cleanup_card_debugfs(struct snd_soc_card
*card
)
231 debugfs_remove_recursive(card
->debugfs_card_root
);
234 static void snd_soc_debugfs_init(void)
236 snd_soc_debugfs_root
= debugfs_create_dir("asoc", NULL
);
237 if (IS_ERR_OR_NULL(snd_soc_debugfs_root
)) {
238 pr_warn("ASoC: Failed to create debugfs directory\n");
239 snd_soc_debugfs_root
= NULL
;
243 if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root
, NULL
,
245 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
247 if (!debugfs_create_file("components", 0444, snd_soc_debugfs_root
, NULL
,
248 &component_list_fops
))
249 pr_warn("ASoC: Failed to create component list debugfs file\n");
252 static void snd_soc_debugfs_exit(void)
254 debugfs_remove_recursive(snd_soc_debugfs_root
);
259 static inline void soc_init_component_debugfs(
260 struct snd_soc_component
*component
)
264 static inline void soc_cleanup_component_debugfs(
265 struct snd_soc_component
*component
)
269 static inline void soc_init_card_debugfs(struct snd_soc_card
*card
)
273 static inline void soc_cleanup_card_debugfs(struct snd_soc_card
*card
)
277 static inline void snd_soc_debugfs_init(void)
281 static inline void snd_soc_debugfs_exit(void)
287 static int snd_soc_rtdcom_add(struct snd_soc_pcm_runtime
*rtd
,
288 struct snd_soc_component
*component
)
290 struct snd_soc_rtdcom_list
*rtdcom
;
291 struct snd_soc_rtdcom_list
*new_rtdcom
;
293 for_each_rtdcom(rtd
, rtdcom
) {
294 /* already connected */
295 if (rtdcom
->component
== component
)
299 new_rtdcom
= kmalloc(sizeof(*new_rtdcom
), GFP_KERNEL
);
303 new_rtdcom
->component
= component
;
304 INIT_LIST_HEAD(&new_rtdcom
->list
);
306 list_add_tail(&new_rtdcom
->list
, &rtd
->component_list
);
311 static void snd_soc_rtdcom_del_all(struct snd_soc_pcm_runtime
*rtd
)
313 struct snd_soc_rtdcom_list
*rtdcom1
, *rtdcom2
;
315 for_each_rtdcom_safe(rtd
, rtdcom1
, rtdcom2
)
318 INIT_LIST_HEAD(&rtd
->component_list
);
321 struct snd_soc_component
*snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime
*rtd
,
322 const char *driver_name
)
324 struct snd_soc_rtdcom_list
*rtdcom
;
329 for_each_rtdcom(rtd
, rtdcom
) {
330 const char *component_name
= rtdcom
->component
->driver
->name
;
335 if ((component_name
== driver_name
) ||
336 strcmp(component_name
, driver_name
) == 0)
337 return rtdcom
->component
;
342 EXPORT_SYMBOL_GPL(snd_soc_rtdcom_lookup
);
344 struct snd_pcm_substream
*snd_soc_get_dai_substream(struct snd_soc_card
*card
,
345 const char *dai_link
, int stream
)
347 struct snd_soc_pcm_runtime
*rtd
;
349 for_each_card_rtds(card
, rtd
) {
350 if (rtd
->dai_link
->no_pcm
&&
351 !strcmp(rtd
->dai_link
->name
, dai_link
))
352 return rtd
->pcm
->streams
[stream
].substream
;
354 dev_dbg(card
->dev
, "ASoC: failed to find dai link %s\n", dai_link
);
357 EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream
);
359 static const struct snd_soc_ops null_snd_soc_ops
;
361 static struct snd_soc_pcm_runtime
*soc_new_pcm_runtime(
362 struct snd_soc_card
*card
, struct snd_soc_dai_link
*dai_link
)
364 struct snd_soc_pcm_runtime
*rtd
;
366 rtd
= kzalloc(sizeof(struct snd_soc_pcm_runtime
), GFP_KERNEL
);
370 INIT_LIST_HEAD(&rtd
->component_list
);
372 rtd
->dai_link
= dai_link
;
373 if (!rtd
->dai_link
->ops
)
374 rtd
->dai_link
->ops
= &null_snd_soc_ops
;
376 rtd
->codec_dais
= kcalloc(dai_link
->num_codecs
,
377 sizeof(struct snd_soc_dai
*),
379 if (!rtd
->codec_dais
) {
387 static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime
*rtd
)
389 kfree(rtd
->codec_dais
);
390 snd_soc_rtdcom_del_all(rtd
);
394 static void soc_add_pcm_runtime(struct snd_soc_card
*card
,
395 struct snd_soc_pcm_runtime
*rtd
)
397 list_add_tail(&rtd
->list
, &card
->rtd_list
);
398 rtd
->num
= card
->num_rtd
;
402 static void soc_remove_pcm_runtimes(struct snd_soc_card
*card
)
404 struct snd_soc_pcm_runtime
*rtd
, *_rtd
;
406 for_each_card_rtds_safe(card
, rtd
, _rtd
) {
407 list_del(&rtd
->list
);
408 soc_free_pcm_runtime(rtd
);
414 struct snd_soc_pcm_runtime
*snd_soc_get_pcm_runtime(struct snd_soc_card
*card
,
415 const char *dai_link
)
417 struct snd_soc_pcm_runtime
*rtd
;
419 for_each_card_rtds(card
, rtd
) {
420 if (!strcmp(rtd
->dai_link
->name
, dai_link
))
423 dev_dbg(card
->dev
, "ASoC: failed to find rtd %s\n", dai_link
);
426 EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime
);
428 static void snd_soc_flush_all_delayed_work(struct snd_soc_card
*card
)
430 struct snd_soc_pcm_runtime
*rtd
;
432 for_each_card_rtds(card
, rtd
)
433 flush_delayed_work(&rtd
->delayed_work
);
436 static void codec2codec_close_delayed_work(struct work_struct
*work
)
439 * Currently nothing to do for c2c links
440 * Since c2c links are internal nodes in the DAPM graph and
441 * don't interface with the outside world or application layer
442 * we don't have to do any special handling on close.
446 #ifdef CONFIG_PM_SLEEP
447 /* powers down audio subsystem for suspend */
448 int snd_soc_suspend(struct device
*dev
)
450 struct snd_soc_card
*card
= dev_get_drvdata(dev
);
451 struct snd_soc_component
*component
;
452 struct snd_soc_pcm_runtime
*rtd
;
455 /* If the card is not initialized yet there is nothing to do */
456 if (!card
->instantiated
)
460 * Due to the resume being scheduled into a workqueue we could
461 * suspend before that's finished - wait for it to complete.
463 snd_power_wait(card
->snd_card
, SNDRV_CTL_POWER_D0
);
465 /* we're going to block userspace touching us until resume completes */
466 snd_power_change_state(card
->snd_card
, SNDRV_CTL_POWER_D3hot
);
468 /* mute any active DACs */
469 for_each_card_rtds(card
, rtd
) {
470 struct snd_soc_dai
*dai
;
472 if (rtd
->dai_link
->ignore_suspend
)
475 for_each_rtd_codec_dai(rtd
, i
, dai
) {
476 struct snd_soc_dai_driver
*drv
= dai
->driver
;
478 if (drv
->ops
->digital_mute
&& dai
->playback_active
)
479 drv
->ops
->digital_mute(dai
, 1);
483 /* suspend all pcms */
484 for_each_card_rtds(card
, rtd
) {
485 if (rtd
->dai_link
->ignore_suspend
)
488 snd_pcm_suspend_all(rtd
->pcm
);
491 if (card
->suspend_pre
)
492 card
->suspend_pre(card
);
494 for_each_card_rtds(card
, rtd
) {
495 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
497 if (rtd
->dai_link
->ignore_suspend
)
500 if (cpu_dai
->driver
->suspend
&& !cpu_dai
->driver
->bus_control
)
501 cpu_dai
->driver
->suspend(cpu_dai
);
504 /* close any waiting streams */
505 snd_soc_flush_all_delayed_work(card
);
507 for_each_card_rtds(card
, rtd
) {
509 if (rtd
->dai_link
->ignore_suspend
)
512 snd_soc_dapm_stream_event(rtd
,
513 SNDRV_PCM_STREAM_PLAYBACK
,
514 SND_SOC_DAPM_STREAM_SUSPEND
);
516 snd_soc_dapm_stream_event(rtd
,
517 SNDRV_PCM_STREAM_CAPTURE
,
518 SND_SOC_DAPM_STREAM_SUSPEND
);
521 /* Recheck all endpoints too, their state is affected by suspend */
522 dapm_mark_endpoints_dirty(card
);
523 snd_soc_dapm_sync(&card
->dapm
);
525 /* suspend all COMPONENTs */
526 for_each_card_components(card
, component
) {
527 struct snd_soc_dapm_context
*dapm
=
528 snd_soc_component_get_dapm(component
);
531 * If there are paths active then the COMPONENT will be held
532 * with bias _ON and should not be suspended.
534 if (!component
->suspended
) {
535 switch (snd_soc_dapm_get_bias_level(dapm
)) {
536 case SND_SOC_BIAS_STANDBY
:
538 * If the COMPONENT is capable of idle
539 * bias off then being in STANDBY
540 * means it's doing something,
541 * otherwise fall through.
543 if (dapm
->idle_bias_off
) {
544 dev_dbg(component
->dev
,
545 "ASoC: idle_bias_off CODEC on over suspend\n");
550 case SND_SOC_BIAS_OFF
:
551 if (component
->driver
->suspend
)
552 component
->driver
->suspend(component
);
553 component
->suspended
= 1;
554 if (component
->regmap
)
555 regcache_mark_dirty(component
->regmap
);
556 /* deactivate pins to sleep state */
557 pinctrl_pm_select_sleep_state(component
->dev
);
560 dev_dbg(component
->dev
,
561 "ASoC: COMPONENT is on over suspend\n");
567 for_each_card_rtds(card
, rtd
) {
568 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
570 if (rtd
->dai_link
->ignore_suspend
)
573 if (cpu_dai
->driver
->suspend
&& cpu_dai
->driver
->bus_control
)
574 cpu_dai
->driver
->suspend(cpu_dai
);
576 /* deactivate pins to sleep state */
577 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
580 if (card
->suspend_post
)
581 card
->suspend_post(card
);
585 EXPORT_SYMBOL_GPL(snd_soc_suspend
);
588 * deferred resume work, so resume can complete before we finished
589 * setting our codec back up, which can be very slow on I2C
591 static void soc_resume_deferred(struct work_struct
*work
)
593 struct snd_soc_card
*card
=
594 container_of(work
, struct snd_soc_card
,
595 deferred_resume_work
);
596 struct snd_soc_pcm_runtime
*rtd
;
597 struct snd_soc_component
*component
;
601 * our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
602 * so userspace apps are blocked from touching us
605 dev_dbg(card
->dev
, "ASoC: starting resume work\n");
607 /* Bring us up into D2 so that DAPM starts enabling things */
608 snd_power_change_state(card
->snd_card
, SNDRV_CTL_POWER_D2
);
610 if (card
->resume_pre
)
611 card
->resume_pre(card
);
613 /* resume control bus DAIs */
614 for_each_card_rtds(card
, rtd
) {
615 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
617 if (rtd
->dai_link
->ignore_suspend
)
620 if (cpu_dai
->driver
->resume
&& cpu_dai
->driver
->bus_control
)
621 cpu_dai
->driver
->resume(cpu_dai
);
624 for_each_card_components(card
, component
) {
625 if (component
->suspended
) {
626 if (component
->driver
->resume
)
627 component
->driver
->resume(component
);
628 component
->suspended
= 0;
632 for_each_card_rtds(card
, rtd
) {
634 if (rtd
->dai_link
->ignore_suspend
)
637 snd_soc_dapm_stream_event(rtd
,
638 SNDRV_PCM_STREAM_PLAYBACK
,
639 SND_SOC_DAPM_STREAM_RESUME
);
641 snd_soc_dapm_stream_event(rtd
,
642 SNDRV_PCM_STREAM_CAPTURE
,
643 SND_SOC_DAPM_STREAM_RESUME
);
646 /* unmute any active DACs */
647 for_each_card_rtds(card
, rtd
) {
648 struct snd_soc_dai
*dai
;
650 if (rtd
->dai_link
->ignore_suspend
)
653 for_each_rtd_codec_dai(rtd
, i
, dai
) {
654 struct snd_soc_dai_driver
*drv
= dai
->driver
;
656 if (drv
->ops
->digital_mute
&& dai
->playback_active
)
657 drv
->ops
->digital_mute(dai
, 0);
661 for_each_card_rtds(card
, rtd
) {
662 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
664 if (rtd
->dai_link
->ignore_suspend
)
667 if (cpu_dai
->driver
->resume
&& !cpu_dai
->driver
->bus_control
)
668 cpu_dai
->driver
->resume(cpu_dai
);
671 if (card
->resume_post
)
672 card
->resume_post(card
);
674 dev_dbg(card
->dev
, "ASoC: resume work completed\n");
676 /* Recheck all endpoints too, their state is affected by suspend */
677 dapm_mark_endpoints_dirty(card
);
678 snd_soc_dapm_sync(&card
->dapm
);
680 /* userspace can access us now we are back as we were before */
681 snd_power_change_state(card
->snd_card
, SNDRV_CTL_POWER_D0
);
684 /* powers up audio subsystem after a suspend */
685 int snd_soc_resume(struct device
*dev
)
687 struct snd_soc_card
*card
= dev_get_drvdata(dev
);
688 bool bus_control
= false;
689 struct snd_soc_pcm_runtime
*rtd
;
691 /* If the card is not initialized yet there is nothing to do */
692 if (!card
->instantiated
)
695 /* activate pins from sleep state */
696 for_each_card_rtds(card
, rtd
) {
697 struct snd_soc_dai
*codec_dai
;
698 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
702 pinctrl_pm_select_default_state(cpu_dai
->dev
);
704 for_each_rtd_codec_dai(rtd
, j
, codec_dai
) {
705 if (codec_dai
->active
)
706 pinctrl_pm_select_default_state(codec_dai
->dev
);
711 * DAIs that also act as the control bus master might have other drivers
712 * hanging off them so need to resume immediately. Other drivers don't
713 * have that problem and may take a substantial amount of time to resume
714 * due to I/O costs and anti-pop so handle them out of line.
716 for_each_card_rtds(card
, rtd
) {
717 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
719 bus_control
|= cpu_dai
->driver
->bus_control
;
722 dev_dbg(dev
, "ASoC: Resuming control bus master immediately\n");
723 soc_resume_deferred(&card
->deferred_resume_work
);
725 dev_dbg(dev
, "ASoC: Scheduling resume work\n");
726 if (!schedule_work(&card
->deferred_resume_work
))
727 dev_err(dev
, "ASoC: resume work item may be lost\n");
732 EXPORT_SYMBOL_GPL(snd_soc_resume
);
734 #define snd_soc_suspend NULL
735 #define snd_soc_resume NULL
738 static const struct snd_soc_dai_ops null_dai_ops
= {
741 static struct snd_soc_component
*soc_find_component(
742 const struct device_node
*of_node
, const char *name
)
744 struct snd_soc_component
*component
;
745 struct device_node
*component_of_node
;
747 lockdep_assert_held(&client_mutex
);
749 for_each_component(component
) {
751 component_of_node
= component
->dev
->of_node
;
752 if (!component_of_node
&& component
->dev
->parent
)
753 component_of_node
= component
->dev
->parent
->of_node
;
755 if (component_of_node
== of_node
)
757 } else if (name
&& strcmp(component
->name
, name
) == 0) {
765 static int snd_soc_is_matching_component(
766 const struct snd_soc_dai_link_component
*dlc
,
767 struct snd_soc_component
*component
)
769 struct device_node
*component_of_node
;
771 component_of_node
= component
->dev
->of_node
;
772 if (!component_of_node
&& component
->dev
->parent
)
773 component_of_node
= component
->dev
->parent
->of_node
;
775 if (dlc
->of_node
&& component_of_node
!= dlc
->of_node
)
777 if (dlc
->name
&& strcmp(component
->name
, dlc
->name
))
784 * snd_soc_find_dai - Find a registered DAI
786 * @dlc: name of the DAI or the DAI driver and optional component info to match
788 * This function will search all registered components and their DAIs to
789 * find the DAI of the same name. The component's of_node and name
790 * should also match if being specified.
792 * Return: pointer of DAI, or NULL if not found.
794 struct snd_soc_dai
*snd_soc_find_dai(
795 const struct snd_soc_dai_link_component
*dlc
)
797 struct snd_soc_component
*component
;
798 struct snd_soc_dai
*dai
;
800 lockdep_assert_held(&client_mutex
);
802 /* Find CPU DAI from registered DAIs */
803 for_each_component(component
) {
804 if (!snd_soc_is_matching_component(dlc
, component
))
806 for_each_component_dais(component
, dai
) {
807 if (dlc
->dai_name
&& strcmp(dai
->name
, dlc
->dai_name
)
808 && (!dai
->driver
->name
809 || strcmp(dai
->driver
->name
, dlc
->dai_name
)))
818 EXPORT_SYMBOL_GPL(snd_soc_find_dai
);
821 * snd_soc_find_dai_link - Find a DAI link
824 * @id: DAI link ID to match
825 * @name: DAI link name to match, optional
826 * @stream_name: DAI link stream name to match, optional
828 * This function will search all existing DAI links of the soc card to
829 * find the link of the same ID. Since DAI links may not have their
830 * unique ID, so name and stream name should also match if being
833 * Return: pointer of DAI link, or NULL if not found.
835 struct snd_soc_dai_link
*snd_soc_find_dai_link(struct snd_soc_card
*card
,
836 int id
, const char *name
,
837 const char *stream_name
)
839 struct snd_soc_dai_link
*link
, *_link
;
841 lockdep_assert_held(&client_mutex
);
843 for_each_card_links_safe(card
, link
, _link
) {
847 if (name
&& (!link
->name
|| strcmp(name
, link
->name
)))
850 if (stream_name
&& (!link
->stream_name
851 || strcmp(stream_name
, link
->stream_name
)))
859 EXPORT_SYMBOL_GPL(snd_soc_find_dai_link
);
861 static bool soc_is_dai_link_bound(struct snd_soc_card
*card
,
862 struct snd_soc_dai_link
*dai_link
)
864 struct snd_soc_pcm_runtime
*rtd
;
866 for_each_card_rtds(card
, rtd
) {
867 if (rtd
->dai_link
== dai_link
)
874 static int soc_bind_dai_link(struct snd_soc_card
*card
,
875 struct snd_soc_dai_link
*dai_link
)
877 struct snd_soc_pcm_runtime
*rtd
;
878 struct snd_soc_dai_link_component
*codecs
;
879 struct snd_soc_dai_link_component cpu_dai_component
;
880 struct snd_soc_component
*component
;
881 struct snd_soc_dai
**codec_dais
;
884 if (dai_link
->ignore
)
887 dev_dbg(card
->dev
, "ASoC: binding %s\n", dai_link
->name
);
889 if (soc_is_dai_link_bound(card
, dai_link
)) {
890 dev_dbg(card
->dev
, "ASoC: dai link %s already bound\n",
895 rtd
= soc_new_pcm_runtime(card
, dai_link
);
899 cpu_dai_component
.name
= dai_link
->cpu_name
;
900 cpu_dai_component
.of_node
= dai_link
->cpu_of_node
;
901 cpu_dai_component
.dai_name
= dai_link
->cpu_dai_name
;
902 rtd
->cpu_dai
= snd_soc_find_dai(&cpu_dai_component
);
904 dev_info(card
->dev
, "ASoC: CPU DAI %s not registered\n",
905 dai_link
->cpu_dai_name
);
908 snd_soc_rtdcom_add(rtd
, rtd
->cpu_dai
->component
);
910 rtd
->num_codecs
= dai_link
->num_codecs
;
912 /* Find CODEC from registered CODECs */
913 codec_dais
= rtd
->codec_dais
;
914 for_each_link_codecs(dai_link
, i
, codecs
) {
915 codec_dais
[i
] = snd_soc_find_dai(codecs
);
916 if (!codec_dais
[i
]) {
917 dev_info(card
->dev
, "ASoC: CODEC DAI %s not registered\n",
921 snd_soc_rtdcom_add(rtd
, codec_dais
[i
]->component
);
924 /* Single codec links expect codec and codec_dai in runtime data */
925 rtd
->codec_dai
= codec_dais
[0];
927 /* find one from the set of registered platforms */
928 for_each_component(component
) {
929 if (!snd_soc_is_matching_component(dai_link
->platforms
,
933 snd_soc_rtdcom_add(rtd
, component
);
936 soc_add_pcm_runtime(card
, rtd
);
940 soc_free_pcm_runtime(rtd
);
941 return -EPROBE_DEFER
;
944 static void soc_cleanup_component(struct snd_soc_component
*component
)
946 list_del(&component
->card_list
);
947 snd_soc_dapm_free(snd_soc_component_get_dapm(component
));
948 soc_cleanup_component_debugfs(component
);
949 component
->card
= NULL
;
950 if (!component
->driver
->module_get_upon_open
)
951 module_put(component
->dev
->driver
->owner
);
954 static void soc_remove_component(struct snd_soc_component
*component
)
956 if (!component
->card
)
959 if (component
->driver
->remove
)
960 component
->driver
->remove(component
);
962 soc_cleanup_component(component
);
965 static void soc_remove_dai(struct snd_soc_dai
*dai
, int order
)
969 if (!dai
|| !dai
->probed
|| !dai
->driver
||
970 dai
->driver
->remove_order
!= order
)
973 if (dai
->driver
->remove
) {
974 err
= dai
->driver
->remove(dai
);
977 "ASoC: failed to remove %s: %d\n",
983 static void soc_remove_link_dais(struct snd_soc_card
*card
,
984 struct snd_soc_pcm_runtime
*rtd
, int order
)
987 struct snd_soc_dai
*codec_dai
;
989 /* unregister the rtd device */
990 if (rtd
->dev_registered
) {
991 device_unregister(rtd
->dev
);
992 rtd
->dev_registered
= 0;
995 /* remove the CODEC DAI */
996 for_each_rtd_codec_dai(rtd
, i
, codec_dai
)
997 soc_remove_dai(codec_dai
, order
);
999 soc_remove_dai(rtd
->cpu_dai
, order
);
1002 static void soc_remove_link_components(struct snd_soc_card
*card
,
1003 struct snd_soc_pcm_runtime
*rtd
, int order
)
1005 struct snd_soc_component
*component
;
1006 struct snd_soc_rtdcom_list
*rtdcom
;
1008 for_each_rtdcom(rtd
, rtdcom
) {
1009 component
= rtdcom
->component
;
1011 if (component
->driver
->remove_order
== order
)
1012 soc_remove_component(component
);
1016 static void soc_remove_dai_links(struct snd_soc_card
*card
)
1019 struct snd_soc_pcm_runtime
*rtd
;
1020 struct snd_soc_dai_link
*link
, *_link
;
1022 for_each_comp_order(order
) {
1023 for_each_card_rtds(card
, rtd
)
1024 soc_remove_link_dais(card
, rtd
, order
);
1027 for_each_comp_order(order
) {
1028 for_each_card_rtds(card
, rtd
)
1029 soc_remove_link_components(card
, rtd
, order
);
1032 for_each_card_links_safe(card
, link
, _link
) {
1033 if (link
->dobj
.type
== SND_SOC_DOBJ_DAI_LINK
)
1034 dev_warn(card
->dev
, "Topology forgot to remove link %s?\n",
1037 list_del(&link
->list
);
1041 static int snd_soc_init_platform(struct snd_soc_card
*card
,
1042 struct snd_soc_dai_link
*dai_link
)
1044 struct snd_soc_dai_link_component
*platform
= dai_link
->platforms
;
1049 * This is glue code for Legacy vs Modern dai_link.
1050 * This function will be removed if all derivers are switched to
1051 * modern style dai_link.
1052 * Driver shouldn't use both legacy and modern style in the same time.
1054 * soc.h :: struct snd_soc_dai_link
1056 /* convert Legacy platform link */
1058 platform
= devm_kzalloc(card
->dev
,
1059 sizeof(struct snd_soc_dai_link_component
),
1064 dai_link
->platforms
= platform
;
1065 dai_link
->num_platforms
= 1;
1066 dai_link
->legacy_platform
= 1;
1067 platform
->name
= dai_link
->platform_name
;
1068 platform
->of_node
= dai_link
->platform_of_node
;
1069 platform
->dai_name
= NULL
;
1072 /* if there's no platform we match on the empty platform */
1073 if (!platform
->name
&&
1075 platform
->name
= "snd-soc-dummy";
1080 static void soc_cleanup_platform(struct snd_soc_card
*card
)
1082 struct snd_soc_dai_link
*link
;
1087 * this function should be removed with snd_soc_init_platform
1090 for_each_card_prelinks(card
, i
, link
) {
1091 if (link
->legacy_platform
) {
1092 link
->legacy_platform
= 0;
1093 link
->platforms
= NULL
;
1098 static int snd_soc_init_multicodec(struct snd_soc_card
*card
,
1099 struct snd_soc_dai_link
*dai_link
)
1104 * This is glue code for Legacy vs Modern dai_link.
1105 * This function will be removed if all derivers are switched to
1106 * modern style dai_link.
1107 * Driver shouldn't use both legacy and modern style in the same time.
1109 * soc.h :: struct snd_soc_dai_link
1112 /* Legacy codec/codec_dai link is a single entry in multicodec */
1113 if (dai_link
->codec_name
|| dai_link
->codec_of_node
||
1114 dai_link
->codec_dai_name
) {
1115 dai_link
->num_codecs
= 1;
1117 dai_link
->codecs
= devm_kzalloc(card
->dev
,
1118 sizeof(struct snd_soc_dai_link_component
),
1120 if (!dai_link
->codecs
)
1123 dai_link
->codecs
[0].name
= dai_link
->codec_name
;
1124 dai_link
->codecs
[0].of_node
= dai_link
->codec_of_node
;
1125 dai_link
->codecs
[0].dai_name
= dai_link
->codec_dai_name
;
1128 if (!dai_link
->codecs
) {
1129 dev_err(card
->dev
, "ASoC: DAI link has no CODECs\n");
1136 static int soc_init_dai_link(struct snd_soc_card
*card
,
1137 struct snd_soc_dai_link
*link
)
1140 struct snd_soc_dai_link_component
*codec
;
1142 ret
= snd_soc_init_platform(card
, link
);
1144 dev_err(card
->dev
, "ASoC: failed to init multiplatform\n");
1148 ret
= snd_soc_init_multicodec(card
, link
);
1150 dev_err(card
->dev
, "ASoC: failed to init multicodec\n");
1154 for_each_link_codecs(link
, i
, codec
) {
1156 * Codec must be specified by 1 of name or OF node,
1157 * not both or neither.
1159 if (!!codec
->name
==
1161 dev_err(card
->dev
, "ASoC: Neither/both codec name/of_node are set for %s\n",
1165 /* Codec DAI name must be specified */
1166 if (!codec
->dai_name
) {
1167 dev_err(card
->dev
, "ASoC: codec_dai_name not set for %s\n",
1174 if (link
->num_platforms
> 1) {
1176 "ASoC: multi platform is not yet supported %s\n",
1182 * Platform may be specified by either name or OF node, but
1183 * can be left unspecified, and a dummy platform will be used.
1185 if (link
->platforms
->name
&& link
->platforms
->of_node
) {
1187 "ASoC: Both platform name/of_node are set for %s\n",
1193 * Defer card registartion if platform dai component is not added to
1196 if ((link
->platforms
->of_node
|| link
->platforms
->name
) &&
1197 !soc_find_component(link
->platforms
->of_node
, link
->platforms
->name
))
1198 return -EPROBE_DEFER
;
1201 * CPU device may be specified by either name or OF node, but
1202 * can be left unspecified, and will be matched based on DAI
1205 if (link
->cpu_name
&& link
->cpu_of_node
) {
1207 "ASoC: Neither/both cpu name/of_node are set for %s\n",
1213 * Defer card registartion if cpu dai component is not added to
1216 if ((link
->cpu_of_node
|| link
->cpu_name
) &&
1217 !soc_find_component(link
->cpu_of_node
, link
->cpu_name
))
1218 return -EPROBE_DEFER
;
1221 * At least one of CPU DAI name or CPU device name/node must be
1224 if (!link
->cpu_dai_name
&&
1225 !(link
->cpu_name
|| link
->cpu_of_node
)) {
1227 "ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
1235 void snd_soc_disconnect_sync(struct device
*dev
)
1237 struct snd_soc_component
*component
=
1238 snd_soc_lookup_component(dev
, NULL
);
1240 if (!component
|| !component
->card
)
1243 snd_card_disconnect_sync(component
->card
->snd_card
);
1245 EXPORT_SYMBOL_GPL(snd_soc_disconnect_sync
);
1248 * snd_soc_add_dai_link - Add a DAI link dynamically
1249 * @card: The ASoC card to which the DAI link is added
1250 * @dai_link: The new DAI link to add
1252 * This function adds a DAI link to the ASoC card's link list.
1254 * Note: Topology can use this API to add DAI links when probing the
1255 * topology component. And machine drivers can still define static
1256 * DAI links in dai_link array.
1258 int snd_soc_add_dai_link(struct snd_soc_card
*card
,
1259 struct snd_soc_dai_link
*dai_link
)
1261 if (dai_link
->dobj
.type
1262 && dai_link
->dobj
.type
!= SND_SOC_DOBJ_DAI_LINK
) {
1263 dev_err(card
->dev
, "Invalid dai link type %d\n",
1264 dai_link
->dobj
.type
);
1268 lockdep_assert_held(&client_mutex
);
1270 * Notify the machine driver for extra initialization
1271 * on the link created by topology.
1273 if (dai_link
->dobj
.type
&& card
->add_dai_link
)
1274 card
->add_dai_link(card
, dai_link
);
1276 list_add_tail(&dai_link
->list
, &card
->dai_link_list
);
1280 EXPORT_SYMBOL_GPL(snd_soc_add_dai_link
);
1283 * snd_soc_remove_dai_link - Remove a DAI link from the list
1284 * @card: The ASoC card that owns the link
1285 * @dai_link: The DAI link to remove
1287 * This function removes a DAI link from the ASoC card's link list.
1289 * For DAI links previously added by topology, topology should
1290 * remove them by using the dobj embedded in the link.
1292 void snd_soc_remove_dai_link(struct snd_soc_card
*card
,
1293 struct snd_soc_dai_link
*dai_link
)
1295 struct snd_soc_dai_link
*link
, *_link
;
1297 if (dai_link
->dobj
.type
1298 && dai_link
->dobj
.type
!= SND_SOC_DOBJ_DAI_LINK
) {
1299 dev_err(card
->dev
, "Invalid dai link type %d\n",
1300 dai_link
->dobj
.type
);
1304 lockdep_assert_held(&client_mutex
);
1306 * Notify the machine driver for extra destruction
1307 * on the link created by topology.
1309 if (dai_link
->dobj
.type
&& card
->remove_dai_link
)
1310 card
->remove_dai_link(card
, dai_link
);
1312 for_each_card_links_safe(card
, link
, _link
) {
1313 if (link
== dai_link
) {
1314 list_del(&link
->list
);
1319 EXPORT_SYMBOL_GPL(snd_soc_remove_dai_link
);
1321 static void soc_set_of_name_prefix(struct snd_soc_component
*component
)
1323 struct device_node
*component_of_node
= component
->dev
->of_node
;
1327 if (!component_of_node
&& component
->dev
->parent
)
1328 component_of_node
= component
->dev
->parent
->of_node
;
1330 ret
= of_property_read_string(component_of_node
, "sound-name-prefix",
1333 component
->name_prefix
= str
;
1336 static void soc_set_name_prefix(struct snd_soc_card
*card
,
1337 struct snd_soc_component
*component
)
1341 for (i
= 0; i
< card
->num_configs
&& card
->codec_conf
; i
++) {
1342 struct snd_soc_codec_conf
*map
= &card
->codec_conf
[i
];
1343 struct device_node
*component_of_node
= component
->dev
->of_node
;
1345 if (!component_of_node
&& component
->dev
->parent
)
1346 component_of_node
= component
->dev
->parent
->of_node
;
1348 if (map
->of_node
&& component_of_node
!= map
->of_node
)
1350 if (map
->dev_name
&& strcmp(component
->name
, map
->dev_name
))
1352 component
->name_prefix
= map
->name_prefix
;
1357 * If there is no configuration table or no match in the table,
1358 * check if a prefix is provided in the node
1360 soc_set_of_name_prefix(component
);
1363 static int soc_probe_component(struct snd_soc_card
*card
,
1364 struct snd_soc_component
*component
)
1366 struct snd_soc_dapm_context
*dapm
=
1367 snd_soc_component_get_dapm(component
);
1368 struct snd_soc_dai
*dai
;
1371 if (!strcmp(component
->name
, "snd-soc-dummy"))
1374 if (component
->card
) {
1375 if (component
->card
!= card
) {
1376 dev_err(component
->dev
,
1377 "Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",
1378 card
->name
, component
->card
->name
);
1384 if (!component
->driver
->module_get_upon_open
&&
1385 !try_module_get(component
->dev
->driver
->owner
))
1388 component
->card
= card
;
1390 INIT_LIST_HEAD(&component
->card_list
);
1391 INIT_LIST_HEAD(&dapm
->list
);
1392 soc_set_name_prefix(card
, component
);
1394 soc_init_component_debugfs(component
);
1396 if (component
->driver
->dapm_widgets
) {
1397 ret
= snd_soc_dapm_new_controls(dapm
,
1398 component
->driver
->dapm_widgets
,
1399 component
->driver
->num_dapm_widgets
);
1402 dev_err(component
->dev
,
1403 "Failed to create new controls %d\n", ret
);
1408 for_each_component_dais(component
, dai
) {
1409 ret
= snd_soc_dapm_new_dai_widgets(dapm
, dai
);
1411 dev_err(component
->dev
,
1412 "Failed to create DAI widgets %d\n", ret
);
1417 if (component
->driver
->probe
) {
1418 ret
= component
->driver
->probe(component
);
1420 dev_err(component
->dev
,
1421 "ASoC: failed to probe component %d\n", ret
);
1425 WARN(dapm
->idle_bias_off
&&
1426 dapm
->bias_level
!= SND_SOC_BIAS_OFF
,
1427 "codec %s can not start from non-off bias with idle_bias_off==1\n",
1431 /* machine specific init */
1432 if (component
->init
) {
1433 ret
= component
->init(component
);
1435 dev_err(component
->dev
,
1436 "Failed to do machine specific init %d\n", ret
);
1441 if (component
->driver
->controls
)
1442 snd_soc_add_component_controls(component
,
1443 component
->driver
->controls
,
1444 component
->driver
->num_controls
);
1445 if (component
->driver
->dapm_routes
)
1446 snd_soc_dapm_add_routes(dapm
,
1447 component
->driver
->dapm_routes
,
1448 component
->driver
->num_dapm_routes
);
1450 list_add(&dapm
->list
, &card
->dapm_list
);
1451 /* see for_each_card_components */
1452 list_add(&component
->card_list
, &card
->component_dev_list
);
1456 soc_cleanup_component(component
);
1461 static void rtd_release(struct device
*dev
)
1466 static int soc_post_component_init(struct snd_soc_pcm_runtime
*rtd
,
1471 /* register the rtd device */
1472 rtd
->dev
= kzalloc(sizeof(struct device
), GFP_KERNEL
);
1475 device_initialize(rtd
->dev
);
1476 rtd
->dev
->parent
= rtd
->card
->dev
;
1477 rtd
->dev
->release
= rtd_release
;
1478 rtd
->dev
->groups
= soc_dev_attr_groups
;
1479 dev_set_name(rtd
->dev
, "%s", name
);
1480 dev_set_drvdata(rtd
->dev
, rtd
);
1481 mutex_init(&rtd
->pcm_mutex
);
1482 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_PLAYBACK
].be_clients
);
1483 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_CAPTURE
].be_clients
);
1484 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_PLAYBACK
].fe_clients
);
1485 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_CAPTURE
].fe_clients
);
1486 ret
= device_add(rtd
->dev
);
1488 /* calling put_device() here to free the rtd->dev */
1489 put_device(rtd
->dev
);
1490 dev_err(rtd
->card
->dev
,
1491 "ASoC: failed to register runtime device: %d\n", ret
);
1494 rtd
->dev_registered
= 1;
1498 static int soc_probe_link_components(struct snd_soc_card
*card
,
1499 struct snd_soc_pcm_runtime
*rtd
, int order
)
1501 struct snd_soc_component
*component
;
1502 struct snd_soc_rtdcom_list
*rtdcom
;
1505 for_each_rtdcom(rtd
, rtdcom
) {
1506 component
= rtdcom
->component
;
1508 if (component
->driver
->probe_order
== order
) {
1509 ret
= soc_probe_component(card
, component
);
1518 static int soc_probe_dai(struct snd_soc_dai
*dai
, int order
)
1521 dai
->driver
->probe_order
!= order
)
1524 if (dai
->driver
->probe
) {
1525 int ret
= dai
->driver
->probe(dai
);
1528 dev_err(dai
->dev
, "ASoC: failed to probe DAI %s: %d\n",
1539 static int soc_link_dai_pcm_new(struct snd_soc_dai
**dais
, int num_dais
,
1540 struct snd_soc_pcm_runtime
*rtd
)
1544 for (i
= 0; i
< num_dais
; ++i
) {
1545 struct snd_soc_dai_driver
*drv
= dais
[i
]->driver
;
1548 ret
= drv
->pcm_new(rtd
, dais
[i
]);
1550 dev_err(dais
[i
]->dev
,
1551 "ASoC: Failed to bind %s with pcm device\n",
1560 static int soc_probe_link_dais(struct snd_soc_card
*card
,
1561 struct snd_soc_pcm_runtime
*rtd
, int order
)
1563 struct snd_soc_dai_link
*dai_link
= rtd
->dai_link
;
1564 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1565 struct snd_soc_rtdcom_list
*rtdcom
;
1566 struct snd_soc_component
*component
;
1567 struct snd_soc_dai
*codec_dai
;
1570 dev_dbg(card
->dev
, "ASoC: probe %s dai link %d late %d\n",
1571 card
->name
, rtd
->num
, order
);
1573 /* set default power off timeout */
1574 rtd
->pmdown_time
= pmdown_time
;
1576 ret
= soc_probe_dai(cpu_dai
, order
);
1580 /* probe the CODEC DAI */
1581 for_each_rtd_codec_dai(rtd
, i
, codec_dai
) {
1582 ret
= soc_probe_dai(codec_dai
, order
);
1587 /* complete DAI probe during last probe */
1588 if (order
!= SND_SOC_COMP_ORDER_LAST
)
1591 /* do machine specific initialization */
1592 if (dai_link
->init
) {
1593 ret
= dai_link
->init(rtd
);
1595 dev_err(card
->dev
, "ASoC: failed to init %s: %d\n",
1596 dai_link
->name
, ret
);
1601 if (dai_link
->dai_fmt
)
1602 snd_soc_runtime_set_dai_fmt(rtd
, dai_link
->dai_fmt
);
1604 ret
= soc_post_component_init(rtd
, dai_link
->name
);
1608 #ifdef CONFIG_DEBUG_FS
1609 /* add DPCM sysfs entries */
1610 if (dai_link
->dynamic
)
1611 soc_dpcm_debugfs_add(rtd
);
1617 * most drivers will register their PCMs using DAI link ordering but
1618 * topology based drivers can use the DAI link id field to set PCM
1619 * device number and then use rtd + a base offset of the BEs.
1621 for_each_rtdcom(rtd
, rtdcom
) {
1622 component
= rtdcom
->component
;
1624 if (!component
->driver
->use_dai_pcm_id
)
1627 if (rtd
->dai_link
->no_pcm
)
1628 num
+= component
->driver
->be_pcm_base
;
1630 num
= rtd
->dai_link
->id
;
1633 if (cpu_dai
->driver
->compress_new
) {
1634 /* create compress_device" */
1635 ret
= cpu_dai
->driver
->compress_new(rtd
, num
);
1637 dev_err(card
->dev
, "ASoC: can't create compress %s\n",
1638 dai_link
->stream_name
);
1641 } else if (!dai_link
->params
) {
1642 /* create the pcm */
1643 ret
= soc_new_pcm(rtd
, num
);
1645 dev_err(card
->dev
, "ASoC: can't create pcm %s :%d\n",
1646 dai_link
->stream_name
, ret
);
1649 ret
= soc_link_dai_pcm_new(&cpu_dai
, 1, rtd
);
1652 ret
= soc_link_dai_pcm_new(rtd
->codec_dais
,
1653 rtd
->num_codecs
, rtd
);
1657 INIT_DELAYED_WORK(&rtd
->delayed_work
,
1658 codec2codec_close_delayed_work
);
1664 static int soc_bind_aux_dev(struct snd_soc_card
*card
, int num
)
1666 struct snd_soc_aux_dev
*aux_dev
= &card
->aux_dev
[num
];
1667 struct snd_soc_component
*component
;
1669 struct device_node
*codec_of_node
;
1671 if (aux_dev
->codec_of_node
|| aux_dev
->codec_name
) {
1672 /* codecs, usually analog devices */
1673 name
= aux_dev
->codec_name
;
1674 codec_of_node
= aux_dev
->codec_of_node
;
1675 component
= soc_find_component(codec_of_node
, name
);
1678 name
= of_node_full_name(codec_of_node
);
1681 } else if (aux_dev
->name
) {
1682 /* generic components */
1683 name
= aux_dev
->name
;
1684 component
= soc_find_component(NULL
, name
);
1688 dev_err(card
->dev
, "ASoC: Invalid auxiliary device\n");
1692 component
->init
= aux_dev
->init
;
1693 list_add(&component
->card_aux_list
, &card
->aux_comp_list
);
1698 dev_err(card
->dev
, "ASoC: %s not registered\n", name
);
1699 return -EPROBE_DEFER
;
1702 static int soc_probe_aux_devices(struct snd_soc_card
*card
)
1704 struct snd_soc_component
*comp
;
1708 for_each_comp_order(order
) {
1709 list_for_each_entry(comp
, &card
->aux_comp_list
, card_aux_list
) {
1710 if (comp
->driver
->probe_order
== order
) {
1711 ret
= soc_probe_component(card
, comp
);
1714 "ASoC: failed to probe aux component %s %d\n",
1725 static void soc_remove_aux_devices(struct snd_soc_card
*card
)
1727 struct snd_soc_component
*comp
, *_comp
;
1730 for_each_comp_order(order
) {
1731 list_for_each_entry_safe(comp
, _comp
,
1732 &card
->aux_comp_list
, card_aux_list
) {
1734 if (comp
->driver
->remove_order
== order
) {
1735 soc_remove_component(comp
);
1736 /* remove it from the card's aux_comp_list */
1737 list_del(&comp
->card_aux_list
);
1744 * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
1745 * @rtd: The runtime for which the DAI link format should be changed
1746 * @dai_fmt: The new DAI link format
1748 * This function updates the DAI link format for all DAIs connected to the DAI
1749 * link for the specified runtime.
1751 * Note: For setups with a static format set the dai_fmt field in the
1752 * corresponding snd_dai_link struct instead of using this function.
1754 * Returns 0 on success, otherwise a negative error code.
1756 int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime
*rtd
,
1757 unsigned int dai_fmt
)
1759 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1760 struct snd_soc_dai
*codec_dai
;
1764 for_each_rtd_codec_dai(rtd
, i
, codec_dai
) {
1765 ret
= snd_soc_dai_set_fmt(codec_dai
, dai_fmt
);
1766 if (ret
!= 0 && ret
!= -ENOTSUPP
) {
1767 dev_warn(codec_dai
->dev
,
1768 "ASoC: Failed to set DAI format: %d\n", ret
);
1774 * Flip the polarity for the "CPU" end of a CODEC<->CODEC link
1775 * the component which has non_legacy_dai_naming is Codec
1777 if (cpu_dai
->component
->driver
->non_legacy_dai_naming
) {
1778 unsigned int inv_dai_fmt
;
1780 inv_dai_fmt
= dai_fmt
& ~SND_SOC_DAIFMT_MASTER_MASK
;
1781 switch (dai_fmt
& SND_SOC_DAIFMT_MASTER_MASK
) {
1782 case SND_SOC_DAIFMT_CBM_CFM
:
1783 inv_dai_fmt
|= SND_SOC_DAIFMT_CBS_CFS
;
1785 case SND_SOC_DAIFMT_CBM_CFS
:
1786 inv_dai_fmt
|= SND_SOC_DAIFMT_CBS_CFM
;
1788 case SND_SOC_DAIFMT_CBS_CFM
:
1789 inv_dai_fmt
|= SND_SOC_DAIFMT_CBM_CFS
;
1791 case SND_SOC_DAIFMT_CBS_CFS
:
1792 inv_dai_fmt
|= SND_SOC_DAIFMT_CBM_CFM
;
1796 dai_fmt
= inv_dai_fmt
;
1799 ret
= snd_soc_dai_set_fmt(cpu_dai
, dai_fmt
);
1800 if (ret
!= 0 && ret
!= -ENOTSUPP
) {
1801 dev_warn(cpu_dai
->dev
,
1802 "ASoC: Failed to set DAI format: %d\n", ret
);
1808 EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt
);
1812 * Trim special characters, and replace '-' with '_' since '-' is used to
1813 * separate different DMI fields in the card long name. Only number and
1814 * alphabet characters and a few separator characters are kept.
1816 static void cleanup_dmi_name(char *name
)
1820 for (i
= 0; name
[i
]; i
++) {
1821 if (isalnum(name
[i
]) || (name
[i
] == '.')
1822 || (name
[i
] == '_'))
1823 name
[j
++] = name
[i
];
1824 else if (name
[i
] == '-')
1832 * Check if a DMI field is valid, i.e. not containing any string
1833 * in the black list.
1835 static int is_dmi_valid(const char *field
)
1839 while (dmi_blacklist
[i
]) {
1840 if (strstr(field
, dmi_blacklist
[i
]))
1849 * snd_soc_set_dmi_name() - Register DMI names to card
1850 * @card: The card to register DMI names
1851 * @flavour: The flavour "differentiator" for the card amongst its peers.
1853 * An Intel machine driver may be used by many different devices but are
1854 * difficult for userspace to differentiate, since machine drivers ususally
1855 * use their own name as the card short name and leave the card long name
1856 * blank. To differentiate such devices and fix bugs due to lack of
1857 * device-specific configurations, this function allows DMI info to be used
1858 * as the sound card long name, in the format of
1859 * "vendor-product-version-board"
1860 * (Character '-' is used to separate different DMI fields here).
1861 * This will help the user space to load the device-specific Use Case Manager
1862 * (UCM) configurations for the card.
1864 * Possible card long names may be:
1865 * DellInc.-XPS139343-01-0310JH
1866 * ASUSTeKCOMPUTERINC.-T100TA-1.0-T100TA
1867 * Circuitco-MinnowboardMaxD0PLATFORM-D0-MinnowBoardMAX
1869 * This function also supports flavoring the card longname to provide
1870 * the extra differentiation, like "vendor-product-version-board-flavor".
1872 * We only keep number and alphabet characters and a few separator characters
1873 * in the card long name since UCM in the user space uses the card long names
1874 * as card configuration directory names and AudoConf cannot support special
1875 * charactors like SPACE.
1877 * Returns 0 on success, otherwise a negative error code.
1879 int snd_soc_set_dmi_name(struct snd_soc_card
*card
, const char *flavour
)
1881 const char *vendor
, *product
, *product_version
, *board
;
1882 size_t longname_buf_size
= sizeof(card
->snd_card
->longname
);
1885 if (card
->long_name
)
1886 return 0; /* long name already set by driver or from DMI */
1888 /* make up dmi long name as: vendor.product.version.board */
1889 vendor
= dmi_get_system_info(DMI_BOARD_VENDOR
);
1890 if (!vendor
|| !is_dmi_valid(vendor
)) {
1891 dev_warn(card
->dev
, "ASoC: no DMI vendor name!\n");
1895 snprintf(card
->dmi_longname
, sizeof(card
->snd_card
->longname
),
1897 cleanup_dmi_name(card
->dmi_longname
);
1899 product
= dmi_get_system_info(DMI_PRODUCT_NAME
);
1900 if (product
&& is_dmi_valid(product
)) {
1901 len
= strlen(card
->dmi_longname
);
1902 snprintf(card
->dmi_longname
+ len
,
1903 longname_buf_size
- len
,
1906 len
++; /* skip the separator "-" */
1907 if (len
< longname_buf_size
)
1908 cleanup_dmi_name(card
->dmi_longname
+ len
);
1911 * some vendors like Lenovo may only put a self-explanatory
1912 * name in the product version field
1914 product_version
= dmi_get_system_info(DMI_PRODUCT_VERSION
);
1915 if (product_version
&& is_dmi_valid(product_version
)) {
1916 len
= strlen(card
->dmi_longname
);
1917 snprintf(card
->dmi_longname
+ len
,
1918 longname_buf_size
- len
,
1919 "-%s", product_version
);
1922 if (len
< longname_buf_size
)
1923 cleanup_dmi_name(card
->dmi_longname
+ len
);
1927 board
= dmi_get_system_info(DMI_BOARD_NAME
);
1928 if (board
&& is_dmi_valid(board
)) {
1929 len
= strlen(card
->dmi_longname
);
1930 snprintf(card
->dmi_longname
+ len
,
1931 longname_buf_size
- len
,
1935 if (len
< longname_buf_size
)
1936 cleanup_dmi_name(card
->dmi_longname
+ len
);
1937 } else if (!product
) {
1938 /* fall back to using legacy name */
1939 dev_warn(card
->dev
, "ASoC: no DMI board/product name!\n");
1943 /* Add flavour to dmi long name */
1945 len
= strlen(card
->dmi_longname
);
1946 snprintf(card
->dmi_longname
+ len
,
1947 longname_buf_size
- len
,
1951 if (len
< longname_buf_size
)
1952 cleanup_dmi_name(card
->dmi_longname
+ len
);
1955 /* set the card long name */
1956 card
->long_name
= card
->dmi_longname
;
1960 EXPORT_SYMBOL_GPL(snd_soc_set_dmi_name
);
1961 #endif /* CONFIG_DMI */
1963 static void soc_check_tplg_fes(struct snd_soc_card
*card
)
1965 struct snd_soc_component
*component
;
1966 const struct snd_soc_component_driver
*comp_drv
;
1967 struct snd_soc_dai_link
*dai_link
;
1970 for_each_component(component
) {
1972 /* does this component override FEs ? */
1973 if (!component
->driver
->ignore_machine
)
1976 /* for this machine ? */
1977 if (!strcmp(component
->driver
->ignore_machine
,
1978 card
->dev
->driver
->name
))
1980 if (strcmp(component
->driver
->ignore_machine
,
1981 dev_name(card
->dev
)))
1984 /* machine matches, so override the rtd data */
1985 for_each_card_prelinks(card
, i
, dai_link
) {
1987 /* ignore this FE */
1988 if (dai_link
->dynamic
) {
1989 dai_link
->ignore
= true;
1993 dev_info(card
->dev
, "info: override FE DAI link %s\n",
1994 card
->dai_link
[i
].name
);
1996 /* override platform component */
1997 if (snd_soc_init_platform(card
, dai_link
) < 0) {
1998 dev_err(card
->dev
, "init platform error");
2001 dai_link
->platforms
->name
= component
->name
;
2003 /* convert non BE into BE */
2004 dai_link
->no_pcm
= 1;
2006 /* override any BE fixups */
2007 dai_link
->be_hw_params_fixup
=
2008 component
->driver
->be_hw_params_fixup
;
2011 * most BE links don't set stream name, so set it to
2012 * dai link name if it's NULL to help bind widgets.
2014 if (!dai_link
->stream_name
)
2015 dai_link
->stream_name
= dai_link
->name
;
2018 /* Inform userspace we are using alternate topology */
2019 if (component
->driver
->topology_name_prefix
) {
2021 /* topology shortname created? */
2022 if (!card
->topology_shortname_created
) {
2023 comp_drv
= component
->driver
;
2025 snprintf(card
->topology_shortname
, 32, "%s-%s",
2026 comp_drv
->topology_name_prefix
,
2028 card
->topology_shortname_created
= true;
2031 /* use topology shortname */
2032 card
->name
= card
->topology_shortname
;
2037 static int soc_cleanup_card_resources(struct snd_soc_card
*card
)
2039 /* free the ALSA card at first; this syncs with pending operations */
2041 snd_card_free(card
->snd_card
);
2043 /* remove and free each DAI */
2044 soc_remove_dai_links(card
);
2045 soc_remove_pcm_runtimes(card
);
2046 soc_cleanup_platform(card
);
2048 /* remove auxiliary devices */
2049 soc_remove_aux_devices(card
);
2051 snd_soc_dapm_free(&card
->dapm
);
2052 soc_cleanup_card_debugfs(card
);
2054 /* remove the card */
2061 static int snd_soc_instantiate_card(struct snd_soc_card
*card
)
2063 struct snd_soc_pcm_runtime
*rtd
;
2064 struct snd_soc_dai_link
*dai_link
;
2067 mutex_lock(&client_mutex
);
2068 mutex_lock_nested(&card
->mutex
, SND_SOC_CARD_CLASS_INIT
);
2070 card
->dapm
.bias_level
= SND_SOC_BIAS_OFF
;
2071 card
->dapm
.dev
= card
->dev
;
2072 card
->dapm
.card
= card
;
2073 list_add(&card
->dapm
.list
, &card
->dapm_list
);
2075 /* check whether any platform is ignore machine FE and using topology */
2076 soc_check_tplg_fes(card
);
2079 for_each_card_prelinks(card
, i
, dai_link
) {
2080 ret
= soc_bind_dai_link(card
, dai_link
);
2085 /* bind aux_devs too */
2086 for (i
= 0; i
< card
->num_aux_devs
; i
++) {
2087 ret
= soc_bind_aux_dev(card
, i
);
2092 /* add predefined DAI links to the list */
2093 for_each_card_prelinks(card
, i
, dai_link
)
2094 snd_soc_add_dai_link(card
, dai_link
);
2096 /* card bind complete so register a sound card */
2097 ret
= snd_card_new(card
->dev
, SNDRV_DEFAULT_IDX1
, SNDRV_DEFAULT_STR1
,
2098 card
->owner
, 0, &card
->snd_card
);
2101 "ASoC: can't create sound card for card %s: %d\n",
2106 soc_init_card_debugfs(card
);
2108 #ifdef CONFIG_DEBUG_FS
2109 snd_soc_dapm_debugfs_init(&card
->dapm
, card
->debugfs_card_root
);
2112 #ifdef CONFIG_PM_SLEEP
2113 /* deferred resume work */
2114 INIT_WORK(&card
->deferred_resume_work
, soc_resume_deferred
);
2117 if (card
->dapm_widgets
)
2118 snd_soc_dapm_new_controls(&card
->dapm
, card
->dapm_widgets
,
2119 card
->num_dapm_widgets
);
2121 if (card
->of_dapm_widgets
)
2122 snd_soc_dapm_new_controls(&card
->dapm
, card
->of_dapm_widgets
,
2123 card
->num_of_dapm_widgets
);
2125 /* initialise the sound card only once */
2127 ret
= card
->probe(card
);
2132 /* probe all components used by DAI links on this card */
2133 for_each_comp_order(order
) {
2134 for_each_card_rtds(card
, rtd
) {
2135 ret
= soc_probe_link_components(card
, rtd
, order
);
2138 "ASoC: failed to instantiate card %d\n",
2145 /* probe auxiliary components */
2146 ret
= soc_probe_aux_devices(card
);
2151 * Find new DAI links added during probing components and bind them.
2152 * Components with topology may bring new DAIs and DAI links.
2154 for_each_card_links(card
, dai_link
) {
2155 if (soc_is_dai_link_bound(card
, dai_link
))
2158 ret
= soc_init_dai_link(card
, dai_link
);
2161 ret
= soc_bind_dai_link(card
, dai_link
);
2166 /* probe all DAI links on this card */
2167 for_each_comp_order(order
) {
2168 for_each_card_rtds(card
, rtd
) {
2169 ret
= soc_probe_link_dais(card
, rtd
, order
);
2172 "ASoC: failed to instantiate card %d\n",
2179 snd_soc_dapm_link_dai_widgets(card
);
2180 snd_soc_dapm_connect_dai_link_widgets(card
);
2183 snd_soc_add_card_controls(card
, card
->controls
,
2184 card
->num_controls
);
2186 if (card
->dapm_routes
)
2187 snd_soc_dapm_add_routes(&card
->dapm
, card
->dapm_routes
,
2188 card
->num_dapm_routes
);
2190 if (card
->of_dapm_routes
)
2191 snd_soc_dapm_add_routes(&card
->dapm
, card
->of_dapm_routes
,
2192 card
->num_of_dapm_routes
);
2194 /* try to set some sane longname if DMI is available */
2195 snd_soc_set_dmi_name(card
, NULL
);
2197 snprintf(card
->snd_card
->shortname
, sizeof(card
->snd_card
->shortname
),
2199 snprintf(card
->snd_card
->longname
, sizeof(card
->snd_card
->longname
),
2200 "%s", card
->long_name
? card
->long_name
: card
->name
);
2201 snprintf(card
->snd_card
->driver
, sizeof(card
->snd_card
->driver
),
2202 "%s", card
->driver_name
? card
->driver_name
: card
->name
);
2203 for (i
= 0; i
< ARRAY_SIZE(card
->snd_card
->driver
); i
++) {
2204 switch (card
->snd_card
->driver
[i
]) {
2210 if (!isalnum(card
->snd_card
->driver
[i
]))
2211 card
->snd_card
->driver
[i
] = '_';
2216 if (card
->late_probe
) {
2217 ret
= card
->late_probe(card
);
2219 dev_err(card
->dev
, "ASoC: %s late_probe() failed: %d\n",
2225 snd_soc_dapm_new_widgets(card
);
2227 ret
= snd_card_register(card
->snd_card
);
2229 dev_err(card
->dev
, "ASoC: failed to register soundcard %d\n",
2234 card
->instantiated
= 1;
2235 dapm_mark_endpoints_dirty(card
);
2236 snd_soc_dapm_sync(&card
->dapm
);
2240 soc_cleanup_card_resources(card
);
2242 mutex_unlock(&card
->mutex
);
2243 mutex_unlock(&client_mutex
);
2248 /* probes a new socdev */
2249 static int soc_probe(struct platform_device
*pdev
)
2251 struct snd_soc_card
*card
= platform_get_drvdata(pdev
);
2254 * no card, so machine driver should be registering card
2255 * we should not be here in that case so ret error
2260 dev_warn(&pdev
->dev
,
2261 "ASoC: machine %s should use snd_soc_register_card()\n",
2264 /* Bodge while we unpick instantiation */
2265 card
->dev
= &pdev
->dev
;
2267 return snd_soc_register_card(card
);
2270 /* removes a socdev */
2271 static int soc_remove(struct platform_device
*pdev
)
2273 struct snd_soc_card
*card
= platform_get_drvdata(pdev
);
2275 snd_soc_unregister_card(card
);
2279 int snd_soc_poweroff(struct device
*dev
)
2281 struct snd_soc_card
*card
= dev_get_drvdata(dev
);
2282 struct snd_soc_pcm_runtime
*rtd
;
2284 if (!card
->instantiated
)
2288 * Flush out pmdown_time work - we actually do want to run it
2289 * now, we're shutting down so no imminent restart.
2291 snd_soc_flush_all_delayed_work(card
);
2293 snd_soc_dapm_shutdown(card
);
2295 /* deactivate pins to sleep state */
2296 for_each_card_rtds(card
, rtd
) {
2297 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
2298 struct snd_soc_dai
*codec_dai
;
2301 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
2302 for_each_rtd_codec_dai(rtd
, i
, codec_dai
) {
2303 pinctrl_pm_select_sleep_state(codec_dai
->dev
);
2309 EXPORT_SYMBOL_GPL(snd_soc_poweroff
);
2311 const struct dev_pm_ops snd_soc_pm_ops
= {
2312 .suspend
= snd_soc_suspend
,
2313 .resume
= snd_soc_resume
,
2314 .freeze
= snd_soc_suspend
,
2315 .thaw
= snd_soc_resume
,
2316 .poweroff
= snd_soc_poweroff
,
2317 .restore
= snd_soc_resume
,
2319 EXPORT_SYMBOL_GPL(snd_soc_pm_ops
);
2321 /* ASoC platform driver */
2322 static struct platform_driver soc_driver
= {
2324 .name
= "soc-audio",
2325 .pm
= &snd_soc_pm_ops
,
2328 .remove
= soc_remove
,
2332 * snd_soc_cnew - create new control
2333 * @_template: control template
2334 * @data: control private data
2335 * @long_name: control long name
2336 * @prefix: control name prefix
2338 * Create a new mixer control from a template control.
2340 * Returns 0 for success, else error.
2342 struct snd_kcontrol
*snd_soc_cnew(const struct snd_kcontrol_new
*_template
,
2343 void *data
, const char *long_name
,
2346 struct snd_kcontrol_new
template;
2347 struct snd_kcontrol
*kcontrol
;
2350 memcpy(&template, _template
, sizeof(template));
2354 long_name
= template.name
;
2357 name
= kasprintf(GFP_KERNEL
, "%s %s", prefix
, long_name
);
2361 template.name
= name
;
2363 template.name
= long_name
;
2366 kcontrol
= snd_ctl_new1(&template, data
);
2372 EXPORT_SYMBOL_GPL(snd_soc_cnew
);
2374 static int snd_soc_add_controls(struct snd_card
*card
, struct device
*dev
,
2375 const struct snd_kcontrol_new
*controls
, int num_controls
,
2376 const char *prefix
, void *data
)
2380 for (i
= 0; i
< num_controls
; i
++) {
2381 const struct snd_kcontrol_new
*control
= &controls
[i
];
2383 err
= snd_ctl_add(card
, snd_soc_cnew(control
, data
,
2384 control
->name
, prefix
));
2386 dev_err(dev
, "ASoC: Failed to add %s: %d\n",
2387 control
->name
, err
);
2395 struct snd_kcontrol
*snd_soc_card_get_kcontrol(struct snd_soc_card
*soc_card
,
2398 struct snd_card
*card
= soc_card
->snd_card
;
2399 struct snd_kcontrol
*kctl
;
2401 if (unlikely(!name
))
2404 list_for_each_entry(kctl
, &card
->controls
, list
)
2405 if (!strncmp(kctl
->id
.name
, name
, sizeof(kctl
->id
.name
)))
2409 EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol
);
2412 * snd_soc_add_component_controls - Add an array of controls to a component.
2414 * @component: Component to add controls to
2415 * @controls: Array of controls to add
2416 * @num_controls: Number of elements in the array
2418 * Return: 0 for success, else error.
2420 int snd_soc_add_component_controls(struct snd_soc_component
*component
,
2421 const struct snd_kcontrol_new
*controls
, unsigned int num_controls
)
2423 struct snd_card
*card
= component
->card
->snd_card
;
2425 return snd_soc_add_controls(card
, component
->dev
, controls
,
2426 num_controls
, component
->name_prefix
, component
);
2428 EXPORT_SYMBOL_GPL(snd_soc_add_component_controls
);
2431 * snd_soc_add_card_controls - add an array of controls to a SoC card.
2432 * Convenience function to add a list of controls.
2434 * @soc_card: SoC card to add controls to
2435 * @controls: array of controls to add
2436 * @num_controls: number of elements in the array
2438 * Return 0 for success, else error.
2440 int snd_soc_add_card_controls(struct snd_soc_card
*soc_card
,
2441 const struct snd_kcontrol_new
*controls
, int num_controls
)
2443 struct snd_card
*card
= soc_card
->snd_card
;
2445 return snd_soc_add_controls(card
, soc_card
->dev
, controls
, num_controls
,
2448 EXPORT_SYMBOL_GPL(snd_soc_add_card_controls
);
2451 * snd_soc_add_dai_controls - add an array of controls to a DAI.
2452 * Convienience function to add a list of controls.
2454 * @dai: DAI to add controls to
2455 * @controls: array of controls to add
2456 * @num_controls: number of elements in the array
2458 * Return 0 for success, else error.
2460 int snd_soc_add_dai_controls(struct snd_soc_dai
*dai
,
2461 const struct snd_kcontrol_new
*controls
, int num_controls
)
2463 struct snd_card
*card
= dai
->component
->card
->snd_card
;
2465 return snd_soc_add_controls(card
, dai
->dev
, controls
, num_controls
,
2468 EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls
);
2471 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2473 * @clk_id: DAI specific clock ID
2474 * @freq: new clock frequency in Hz
2475 * @dir: new clock direction - input/output.
2477 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2479 int snd_soc_dai_set_sysclk(struct snd_soc_dai
*dai
, int clk_id
,
2480 unsigned int freq
, int dir
)
2482 if (dai
->driver
->ops
->set_sysclk
)
2483 return dai
->driver
->ops
->set_sysclk(dai
, clk_id
, freq
, dir
);
2485 return snd_soc_component_set_sysclk(dai
->component
, clk_id
, 0,
2488 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk
);
2491 * snd_soc_component_set_sysclk - configure COMPONENT system or master clock.
2492 * @component: COMPONENT
2493 * @clk_id: DAI specific clock ID
2494 * @source: Source for the clock
2495 * @freq: new clock frequency in Hz
2496 * @dir: new clock direction - input/output.
2498 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
2500 int snd_soc_component_set_sysclk(struct snd_soc_component
*component
,
2501 int clk_id
, int source
, unsigned int freq
,
2504 if (component
->driver
->set_sysclk
)
2505 return component
->driver
->set_sysclk(component
, clk_id
, source
,
2510 EXPORT_SYMBOL_GPL(snd_soc_component_set_sysclk
);
2513 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2515 * @div_id: DAI specific clock divider ID
2516 * @div: new clock divisor.
2518 * Configures the clock dividers. This is used to derive the best DAI bit and
2519 * frame clocks from the system or master clock. It's best to set the DAI bit
2520 * and frame clocks as low as possible to save system power.
2522 int snd_soc_dai_set_clkdiv(struct snd_soc_dai
*dai
,
2523 int div_id
, int div
)
2525 if (dai
->driver
->ops
->set_clkdiv
)
2526 return dai
->driver
->ops
->set_clkdiv(dai
, div_id
, div
);
2530 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv
);
2533 * snd_soc_dai_set_pll - configure DAI PLL.
2535 * @pll_id: DAI specific PLL ID
2536 * @source: DAI specific source for the PLL
2537 * @freq_in: PLL input clock frequency in Hz
2538 * @freq_out: requested PLL output clock frequency in Hz
2540 * Configures and enables PLL to generate output clock based on input clock.
2542 int snd_soc_dai_set_pll(struct snd_soc_dai
*dai
, int pll_id
, int source
,
2543 unsigned int freq_in
, unsigned int freq_out
)
2545 if (dai
->driver
->ops
->set_pll
)
2546 return dai
->driver
->ops
->set_pll(dai
, pll_id
, source
,
2549 return snd_soc_component_set_pll(dai
->component
, pll_id
, source
,
2552 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll
);
2555 * snd_soc_component_set_pll - configure component PLL.
2556 * @component: COMPONENT
2557 * @pll_id: DAI specific PLL ID
2558 * @source: DAI specific source for the PLL
2559 * @freq_in: PLL input clock frequency in Hz
2560 * @freq_out: requested PLL output clock frequency in Hz
2562 * Configures and enables PLL to generate output clock based on input clock.
2564 int snd_soc_component_set_pll(struct snd_soc_component
*component
, int pll_id
,
2565 int source
, unsigned int freq_in
,
2566 unsigned int freq_out
)
2568 if (component
->driver
->set_pll
)
2569 return component
->driver
->set_pll(component
, pll_id
, source
,
2574 EXPORT_SYMBOL_GPL(snd_soc_component_set_pll
);
2577 * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
2579 * @ratio: Ratio of BCLK to Sample rate.
2581 * Configures the DAI for a preset BCLK to sample rate ratio.
2583 int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai
*dai
, unsigned int ratio
)
2585 if (dai
->driver
->ops
->set_bclk_ratio
)
2586 return dai
->driver
->ops
->set_bclk_ratio(dai
, ratio
);
2590 EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio
);
2593 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
2595 * @fmt: SND_SOC_DAIFMT_* format value.
2597 * Configures the DAI hardware format and clocking.
2599 int snd_soc_dai_set_fmt(struct snd_soc_dai
*dai
, unsigned int fmt
)
2601 if (dai
->driver
->ops
->set_fmt
== NULL
)
2603 return dai
->driver
->ops
->set_fmt(dai
, fmt
);
2605 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt
);
2608 * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
2609 * @slots: Number of slots in use.
2610 * @tx_mask: bitmask representing active TX slots.
2611 * @rx_mask: bitmask representing active RX slots.
2613 * Generates the TDM tx and rx slot default masks for DAI.
2615 static int snd_soc_xlate_tdm_slot_mask(unsigned int slots
,
2616 unsigned int *tx_mask
,
2617 unsigned int *rx_mask
)
2619 if (*tx_mask
|| *rx_mask
)
2625 *tx_mask
= (1 << slots
) - 1;
2626 *rx_mask
= (1 << slots
) - 1;
2632 * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
2633 * @dai: The DAI to configure
2634 * @tx_mask: bitmask representing active TX slots.
2635 * @rx_mask: bitmask representing active RX slots.
2636 * @slots: Number of slots in use.
2637 * @slot_width: Width in bits for each slot.
2639 * This function configures the specified DAI for TDM operation. @slot contains
2640 * the total number of slots of the TDM stream and @slot_with the width of each
2641 * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
2642 * active slots of the TDM stream for the specified DAI, i.e. which slots the
2643 * DAI should write to or read from. If a bit is set the corresponding slot is
2644 * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
2645 * the first slot, bit 1 to the second slot and so on. The first active slot
2646 * maps to the first channel of the DAI, the second active slot to the second
2647 * channel and so on.
2649 * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
2650 * @rx_mask and @slot_width will be ignored.
2652 * Returns 0 on success, a negative error code otherwise.
2654 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai
*dai
,
2655 unsigned int tx_mask
, unsigned int rx_mask
, int slots
, int slot_width
)
2657 if (dai
->driver
->ops
->xlate_tdm_slot_mask
)
2658 dai
->driver
->ops
->xlate_tdm_slot_mask(slots
,
2659 &tx_mask
, &rx_mask
);
2661 snd_soc_xlate_tdm_slot_mask(slots
, &tx_mask
, &rx_mask
);
2663 dai
->tx_mask
= tx_mask
;
2664 dai
->rx_mask
= rx_mask
;
2666 if (dai
->driver
->ops
->set_tdm_slot
)
2667 return dai
->driver
->ops
->set_tdm_slot(dai
, tx_mask
, rx_mask
,
2672 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot
);
2675 * snd_soc_dai_set_channel_map - configure DAI audio channel map
2677 * @tx_num: how many TX channels
2678 * @tx_slot: pointer to an array which imply the TX slot number channel
2680 * @rx_num: how many RX channels
2681 * @rx_slot: pointer to an array which imply the RX slot number channel
2684 * configure the relationship between channel number and TDM slot number.
2686 int snd_soc_dai_set_channel_map(struct snd_soc_dai
*dai
,
2687 unsigned int tx_num
, unsigned int *tx_slot
,
2688 unsigned int rx_num
, unsigned int *rx_slot
)
2690 if (dai
->driver
->ops
->set_channel_map
)
2691 return dai
->driver
->ops
->set_channel_map(dai
, tx_num
, tx_slot
,
2696 EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map
);
2699 * snd_soc_dai_get_channel_map - Get DAI audio channel map
2701 * @tx_num: how many TX channels
2702 * @tx_slot: pointer to an array which imply the TX slot number channel
2704 * @rx_num: how many RX channels
2705 * @rx_slot: pointer to an array which imply the RX slot number channel
2708 int snd_soc_dai_get_channel_map(struct snd_soc_dai
*dai
,
2709 unsigned int *tx_num
, unsigned int *tx_slot
,
2710 unsigned int *rx_num
, unsigned int *rx_slot
)
2712 if (dai
->driver
->ops
->get_channel_map
)
2713 return dai
->driver
->ops
->get_channel_map(dai
, tx_num
, tx_slot
,
2718 EXPORT_SYMBOL_GPL(snd_soc_dai_get_channel_map
);
2721 * snd_soc_dai_set_tristate - configure DAI system or master clock.
2723 * @tristate: tristate enable
2725 * Tristates the DAI so that others can use it.
2727 int snd_soc_dai_set_tristate(struct snd_soc_dai
*dai
, int tristate
)
2729 if (dai
->driver
->ops
->set_tristate
)
2730 return dai
->driver
->ops
->set_tristate(dai
, tristate
);
2734 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate
);
2737 * snd_soc_dai_digital_mute - configure DAI system or master clock.
2739 * @mute: mute enable
2740 * @direction: stream to mute
2742 * Mutes the DAI DAC.
2744 int snd_soc_dai_digital_mute(struct snd_soc_dai
*dai
, int mute
,
2747 if (dai
->driver
->ops
->mute_stream
)
2748 return dai
->driver
->ops
->mute_stream(dai
, mute
, direction
);
2749 else if (direction
== SNDRV_PCM_STREAM_PLAYBACK
&&
2750 dai
->driver
->ops
->digital_mute
)
2751 return dai
->driver
->ops
->digital_mute(dai
, mute
);
2755 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute
);
2757 static int snd_soc_bind_card(struct snd_soc_card
*card
)
2759 struct snd_soc_pcm_runtime
*rtd
;
2762 ret
= snd_soc_instantiate_card(card
);
2766 /* deactivate pins to sleep state */
2767 for_each_card_rtds(card
, rtd
) {
2768 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
2769 struct snd_soc_dai
*codec_dai
;
2772 for_each_rtd_codec_dai(rtd
, j
, codec_dai
) {
2773 if (!codec_dai
->active
)
2774 pinctrl_pm_select_sleep_state(codec_dai
->dev
);
2777 if (!cpu_dai
->active
)
2778 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
2785 * snd_soc_register_card - Register a card with the ASoC core
2787 * @card: Card to register
2790 int snd_soc_register_card(struct snd_soc_card
*card
)
2793 struct snd_soc_dai_link
*link
;
2795 if (!card
->name
|| !card
->dev
)
2798 mutex_lock(&client_mutex
);
2799 for_each_card_prelinks(card
, i
, link
) {
2801 ret
= soc_init_dai_link(card
, link
);
2803 soc_cleanup_platform(card
);
2804 dev_err(card
->dev
, "ASoC: failed to init link %s\n",
2806 mutex_unlock(&client_mutex
);
2810 mutex_unlock(&client_mutex
);
2812 dev_set_drvdata(card
->dev
, card
);
2814 snd_soc_initialize_card_lists(card
);
2816 INIT_LIST_HEAD(&card
->dai_link_list
);
2818 INIT_LIST_HEAD(&card
->rtd_list
);
2821 INIT_LIST_HEAD(&card
->dapm_dirty
);
2822 INIT_LIST_HEAD(&card
->dobj_list
);
2823 card
->instantiated
= 0;
2824 mutex_init(&card
->mutex
);
2825 mutex_init(&card
->dapm_mutex
);
2826 spin_lock_init(&card
->dpcm_lock
);
2828 return snd_soc_bind_card(card
);
2830 EXPORT_SYMBOL_GPL(snd_soc_register_card
);
2832 static void snd_soc_unbind_card(struct snd_soc_card
*card
, bool unregister
)
2834 struct snd_soc_pcm_runtime
*rtd
;
2837 if (card
->instantiated
) {
2838 card
->instantiated
= false;
2839 snd_soc_dapm_shutdown(card
);
2840 snd_soc_flush_all_delayed_work(card
);
2842 /* remove all components used by DAI links on this card */
2843 for_each_comp_order(order
) {
2844 for_each_card_rtds(card
, rtd
) {
2845 soc_remove_link_components(card
, rtd
, order
);
2849 soc_cleanup_card_resources(card
);
2851 list_add(&card
->list
, &unbind_card_list
);
2854 list_del(&card
->list
);
2859 * snd_soc_unregister_card - Unregister a card with the ASoC core
2861 * @card: Card to unregister
2864 int snd_soc_unregister_card(struct snd_soc_card
*card
)
2866 snd_soc_unbind_card(card
, true);
2867 dev_dbg(card
->dev
, "ASoC: Unregistered card '%s'\n", card
->name
);
2871 EXPORT_SYMBOL_GPL(snd_soc_unregister_card
);
2874 * Simplify DAI link configuration by removing ".-1" from device names
2875 * and sanitizing names.
2877 static char *fmt_single_name(struct device
*dev
, int *id
)
2879 char *found
, name
[NAME_SIZE
];
2882 if (dev_name(dev
) == NULL
)
2885 strlcpy(name
, dev_name(dev
), NAME_SIZE
);
2887 /* are we a "%s.%d" name (platform and SPI components) */
2888 found
= strstr(name
, dev
->driver
->name
);
2891 if (sscanf(&found
[strlen(dev
->driver
->name
)], ".%d", id
) == 1) {
2893 /* discard ID from name if ID == -1 */
2895 found
[strlen(dev
->driver
->name
)] = '\0';
2899 /* I2C component devices are named "bus-addr" */
2900 if (sscanf(name
, "%x-%x", &id1
, &id2
) == 2) {
2901 char tmp
[NAME_SIZE
];
2903 /* create unique ID number from I2C addr and bus */
2904 *id
= ((id1
& 0xffff) << 16) + id2
;
2906 /* sanitize component name for DAI link creation */
2907 snprintf(tmp
, NAME_SIZE
, "%s.%s", dev
->driver
->name
,
2909 strlcpy(name
, tmp
, NAME_SIZE
);
2914 return kstrdup(name
, GFP_KERNEL
);
2918 * Simplify DAI link naming for single devices with multiple DAIs by removing
2919 * any ".-1" and using the DAI name (instead of device name).
2921 static inline char *fmt_multiple_name(struct device
*dev
,
2922 struct snd_soc_dai_driver
*dai_drv
)
2924 if (dai_drv
->name
== NULL
) {
2926 "ASoC: error - multiple DAI %s registered with no name\n",
2931 return kstrdup(dai_drv
->name
, GFP_KERNEL
);
2935 * snd_soc_unregister_dai - Unregister DAIs from the ASoC core
2937 * @component: The component for which the DAIs should be unregistered
2939 static void snd_soc_unregister_dais(struct snd_soc_component
*component
)
2941 struct snd_soc_dai
*dai
, *_dai
;
2943 for_each_component_dais_safe(component
, dai
, _dai
) {
2944 dev_dbg(component
->dev
, "ASoC: Unregistered DAI '%s'\n",
2946 list_del(&dai
->list
);
2952 /* Create a DAI and add it to the component's DAI list */
2953 static struct snd_soc_dai
*soc_add_dai(struct snd_soc_component
*component
,
2954 struct snd_soc_dai_driver
*dai_drv
,
2955 bool legacy_dai_naming
)
2957 struct device
*dev
= component
->dev
;
2958 struct snd_soc_dai
*dai
;
2960 dev_dbg(dev
, "ASoC: dynamically register DAI %s\n", dev_name(dev
));
2962 dai
= kzalloc(sizeof(struct snd_soc_dai
), GFP_KERNEL
);
2967 * Back in the old days when we still had component-less DAIs,
2968 * instead of having a static name, component-less DAIs would
2969 * inherit the name of the parent device so it is possible to
2970 * register multiple instances of the DAI. We still need to keep
2971 * the same naming style even though those DAIs are not
2972 * component-less anymore.
2974 if (legacy_dai_naming
&&
2975 (dai_drv
->id
== 0 || dai_drv
->name
== NULL
)) {
2976 dai
->name
= fmt_single_name(dev
, &dai
->id
);
2978 dai
->name
= fmt_multiple_name(dev
, dai_drv
);
2980 dai
->id
= dai_drv
->id
;
2982 dai
->id
= component
->num_dai
;
2984 if (dai
->name
== NULL
) {
2989 dai
->component
= component
;
2991 dai
->driver
= dai_drv
;
2992 if (!dai
->driver
->ops
)
2993 dai
->driver
->ops
= &null_dai_ops
;
2995 /* see for_each_component_dais */
2996 list_add_tail(&dai
->list
, &component
->dai_list
);
2997 component
->num_dai
++;
2999 dev_dbg(dev
, "ASoC: Registered DAI '%s'\n", dai
->name
);
3004 * snd_soc_register_dais - Register a DAI with the ASoC core
3006 * @component: The component the DAIs are registered for
3007 * @dai_drv: DAI driver to use for the DAIs
3008 * @count: Number of DAIs
3010 static int snd_soc_register_dais(struct snd_soc_component
*component
,
3011 struct snd_soc_dai_driver
*dai_drv
,
3014 struct device
*dev
= component
->dev
;
3015 struct snd_soc_dai
*dai
;
3019 dev_dbg(dev
, "ASoC: dai register %s #%zu\n", dev_name(dev
), count
);
3021 for (i
= 0; i
< count
; i
++) {
3023 dai
= soc_add_dai(component
, dai_drv
+ i
, count
== 1 &&
3024 !component
->driver
->non_legacy_dai_naming
);
3034 snd_soc_unregister_dais(component
);
3040 * snd_soc_register_dai - Register a DAI dynamically & create its widgets
3042 * @component: The component the DAIs are registered for
3043 * @dai_drv: DAI driver to use for the DAI
3045 * Topology can use this API to register DAIs when probing a component.
3046 * These DAIs's widgets will be freed in the card cleanup and the DAIs
3047 * will be freed in the component cleanup.
3049 int snd_soc_register_dai(struct snd_soc_component
*component
,
3050 struct snd_soc_dai_driver
*dai_drv
)
3052 struct snd_soc_dapm_context
*dapm
=
3053 snd_soc_component_get_dapm(component
);
3054 struct snd_soc_dai
*dai
;
3057 if (dai_drv
->dobj
.type
!= SND_SOC_DOBJ_PCM
) {
3058 dev_err(component
->dev
, "Invalid dai type %d\n",
3059 dai_drv
->dobj
.type
);
3063 lockdep_assert_held(&client_mutex
);
3064 dai
= soc_add_dai(component
, dai_drv
, false);
3069 * Create the DAI widgets here. After adding DAIs, topology may
3070 * also add routes that need these widgets as source or sink.
3072 ret
= snd_soc_dapm_new_dai_widgets(dapm
, dai
);
3074 dev_err(component
->dev
,
3075 "Failed to create DAI widgets %d\n", ret
);
3080 EXPORT_SYMBOL_GPL(snd_soc_register_dai
);
3082 static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context
*dapm
,
3083 enum snd_soc_dapm_type type
, int subseq
)
3085 struct snd_soc_component
*component
= dapm
->component
;
3087 component
->driver
->seq_notifier(component
, type
, subseq
);
3090 static int snd_soc_component_stream_event(struct snd_soc_dapm_context
*dapm
,
3093 struct snd_soc_component
*component
= dapm
->component
;
3095 return component
->driver
->stream_event(component
, event
);
3098 static int snd_soc_component_set_bias_level(struct snd_soc_dapm_context
*dapm
,
3099 enum snd_soc_bias_level level
)
3101 struct snd_soc_component
*component
= dapm
->component
;
3103 return component
->driver
->set_bias_level(component
, level
);
3106 static int snd_soc_component_initialize(struct snd_soc_component
*component
,
3107 const struct snd_soc_component_driver
*driver
, struct device
*dev
)
3109 struct snd_soc_dapm_context
*dapm
;
3111 component
->name
= fmt_single_name(dev
, &component
->id
);
3112 if (!component
->name
) {
3113 dev_err(dev
, "ASoC: Failed to allocate name\n");
3117 component
->dev
= dev
;
3118 component
->driver
= driver
;
3120 dapm
= snd_soc_component_get_dapm(component
);
3122 dapm
->component
= component
;
3123 dapm
->bias_level
= SND_SOC_BIAS_OFF
;
3124 dapm
->idle_bias_off
= !driver
->idle_bias_on
;
3125 dapm
->suspend_bias_off
= driver
->suspend_bias_off
;
3126 if (driver
->seq_notifier
)
3127 dapm
->seq_notifier
= snd_soc_component_seq_notifier
;
3128 if (driver
->stream_event
)
3129 dapm
->stream_event
= snd_soc_component_stream_event
;
3130 if (driver
->set_bias_level
)
3131 dapm
->set_bias_level
= snd_soc_component_set_bias_level
;
3133 INIT_LIST_HEAD(&component
->dai_list
);
3134 mutex_init(&component
->io_mutex
);
3139 static void snd_soc_component_setup_regmap(struct snd_soc_component
*component
)
3141 int val_bytes
= regmap_get_val_bytes(component
->regmap
);
3143 /* Errors are legitimate for non-integer byte multiples */
3145 component
->val_bytes
= val_bytes
;
3148 #ifdef CONFIG_REGMAP
3151 * snd_soc_component_init_regmap() - Initialize regmap instance for the
3153 * @component: The component for which to initialize the regmap instance
3154 * @regmap: The regmap instance that should be used by the component
3156 * This function allows deferred assignment of the regmap instance that is
3157 * associated with the component. Only use this if the regmap instance is not
3158 * yet ready when the component is registered. The function must also be called
3159 * before the first IO attempt of the component.
3161 void snd_soc_component_init_regmap(struct snd_soc_component
*component
,
3162 struct regmap
*regmap
)
3164 component
->regmap
= regmap
;
3165 snd_soc_component_setup_regmap(component
);
3167 EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap
);
3170 * snd_soc_component_exit_regmap() - De-initialize regmap instance for the
3172 * @component: The component for which to de-initialize the regmap instance
3174 * Calls regmap_exit() on the regmap instance associated to the component and
3175 * removes the regmap instance from the component.
3177 * This function should only be used if snd_soc_component_init_regmap() was used
3178 * to initialize the regmap instance.
3180 void snd_soc_component_exit_regmap(struct snd_soc_component
*component
)
3182 regmap_exit(component
->regmap
);
3183 component
->regmap
= NULL
;
3185 EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap
);
3189 static void snd_soc_component_add(struct snd_soc_component
*component
)
3191 mutex_lock(&client_mutex
);
3193 if (!component
->driver
->write
&& !component
->driver
->read
) {
3194 if (!component
->regmap
)
3195 component
->regmap
= dev_get_regmap(component
->dev
,
3197 if (component
->regmap
)
3198 snd_soc_component_setup_regmap(component
);
3201 /* see for_each_component */
3202 list_add(&component
->list
, &component_list
);
3203 INIT_LIST_HEAD(&component
->dobj_list
);
3205 mutex_unlock(&client_mutex
);
3208 static void snd_soc_component_cleanup(struct snd_soc_component
*component
)
3210 snd_soc_unregister_dais(component
);
3211 kfree(component
->name
);
3214 static void snd_soc_component_del_unlocked(struct snd_soc_component
*component
)
3216 struct snd_soc_card
*card
= component
->card
;
3219 snd_soc_unbind_card(card
, false);
3221 list_del(&component
->list
);
3224 #define ENDIANNESS_MAP(name) \
3225 (SNDRV_PCM_FMTBIT_##name##LE | SNDRV_PCM_FMTBIT_##name##BE)
3226 static u64 endianness_format_map
[] = {
3227 ENDIANNESS_MAP(S16_
),
3228 ENDIANNESS_MAP(U16_
),
3229 ENDIANNESS_MAP(S24_
),
3230 ENDIANNESS_MAP(U24_
),
3231 ENDIANNESS_MAP(S32_
),
3232 ENDIANNESS_MAP(U32_
),
3233 ENDIANNESS_MAP(S24_3
),
3234 ENDIANNESS_MAP(U24_3
),
3235 ENDIANNESS_MAP(S20_3
),
3236 ENDIANNESS_MAP(U20_3
),
3237 ENDIANNESS_MAP(S18_3
),
3238 ENDIANNESS_MAP(U18_3
),
3239 ENDIANNESS_MAP(FLOAT_
),
3240 ENDIANNESS_MAP(FLOAT64_
),
3241 ENDIANNESS_MAP(IEC958_SUBFRAME_
),
3245 * Fix up the DAI formats for endianness: codecs don't actually see
3246 * the endianness of the data but we're using the CPU format
3247 * definitions which do need to include endianness so we ensure that
3248 * codec DAIs always have both big and little endian variants set.
3250 static void convert_endianness_formats(struct snd_soc_pcm_stream
*stream
)
3254 for (i
= 0; i
< ARRAY_SIZE(endianness_format_map
); i
++)
3255 if (stream
->formats
& endianness_format_map
[i
])
3256 stream
->formats
|= endianness_format_map
[i
];
3259 static void snd_soc_try_rebind_card(void)
3261 struct snd_soc_card
*card
, *c
;
3263 if (!list_empty(&unbind_card_list
)) {
3264 list_for_each_entry_safe(card
, c
, &unbind_card_list
, list
) {
3265 if (!snd_soc_bind_card(card
))
3266 list_del(&card
->list
);
3271 int snd_soc_add_component(struct device
*dev
,
3272 struct snd_soc_component
*component
,
3273 const struct snd_soc_component_driver
*component_driver
,
3274 struct snd_soc_dai_driver
*dai_drv
,
3280 ret
= snd_soc_component_initialize(component
, component_driver
, dev
);
3284 if (component_driver
->endianness
) {
3285 for (i
= 0; i
< num_dai
; i
++) {
3286 convert_endianness_formats(&dai_drv
[i
].playback
);
3287 convert_endianness_formats(&dai_drv
[i
].capture
);
3291 ret
= snd_soc_register_dais(component
, dai_drv
, num_dai
);
3293 dev_err(dev
, "ASoC: Failed to register DAIs: %d\n", ret
);
3297 snd_soc_component_add(component
);
3298 snd_soc_try_rebind_card();
3303 snd_soc_component_cleanup(component
);
3307 EXPORT_SYMBOL_GPL(snd_soc_add_component
);
3309 int snd_soc_register_component(struct device
*dev
,
3310 const struct snd_soc_component_driver
*component_driver
,
3311 struct snd_soc_dai_driver
*dai_drv
,
3314 struct snd_soc_component
*component
;
3316 component
= devm_kzalloc(dev
, sizeof(*component
), GFP_KERNEL
);
3320 return snd_soc_add_component(dev
, component
, component_driver
,
3323 EXPORT_SYMBOL_GPL(snd_soc_register_component
);
3326 * snd_soc_unregister_component - Unregister all related component
3327 * from the ASoC core
3329 * @dev: The device to unregister
3331 static int __snd_soc_unregister_component(struct device
*dev
)
3333 struct snd_soc_component
*component
;
3336 mutex_lock(&client_mutex
);
3337 for_each_component(component
) {
3338 if (dev
!= component
->dev
)
3341 snd_soc_tplg_component_remove(component
,
3342 SND_SOC_TPLG_INDEX_ALL
);
3343 snd_soc_component_del_unlocked(component
);
3347 mutex_unlock(&client_mutex
);
3350 snd_soc_component_cleanup(component
);
3355 void snd_soc_unregister_component(struct device
*dev
)
3357 while (__snd_soc_unregister_component(dev
))
3360 EXPORT_SYMBOL_GPL(snd_soc_unregister_component
);
3362 struct snd_soc_component
*snd_soc_lookup_component(struct device
*dev
,
3363 const char *driver_name
)
3365 struct snd_soc_component
*component
;
3366 struct snd_soc_component
*ret
;
3369 mutex_lock(&client_mutex
);
3370 for_each_component(component
) {
3371 if (dev
!= component
->dev
)
3375 (driver_name
!= component
->driver
->name
) &&
3376 (strcmp(component
->driver
->name
, driver_name
) != 0))
3382 mutex_unlock(&client_mutex
);
3386 EXPORT_SYMBOL_GPL(snd_soc_lookup_component
);
3388 /* Retrieve a card's name from device tree */
3389 int snd_soc_of_parse_card_name(struct snd_soc_card
*card
,
3390 const char *propname
)
3392 struct device_node
*np
;
3396 pr_err("card->dev is not set before calling %s\n", __func__
);
3400 np
= card
->dev
->of_node
;
3402 ret
= of_property_read_string_index(np
, propname
, 0, &card
->name
);
3404 * EINVAL means the property does not exist. This is fine providing
3405 * card->name was previously set, which is checked later in
3406 * snd_soc_register_card.
3408 if (ret
< 0 && ret
!= -EINVAL
) {
3410 "ASoC: Property '%s' could not be read: %d\n",
3417 EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name
);
3419 static const struct snd_soc_dapm_widget simple_widgets
[] = {
3420 SND_SOC_DAPM_MIC("Microphone", NULL
),
3421 SND_SOC_DAPM_LINE("Line", NULL
),
3422 SND_SOC_DAPM_HP("Headphone", NULL
),
3423 SND_SOC_DAPM_SPK("Speaker", NULL
),
3426 int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card
*card
,
3427 const char *propname
)
3429 struct device_node
*np
= card
->dev
->of_node
;
3430 struct snd_soc_dapm_widget
*widgets
;
3431 const char *template, *wname
;
3432 int i
, j
, num_widgets
, ret
;
3434 num_widgets
= of_property_count_strings(np
, propname
);
3435 if (num_widgets
< 0) {
3437 "ASoC: Property '%s' does not exist\n", propname
);
3440 if (num_widgets
& 1) {
3442 "ASoC: Property '%s' length is not even\n", propname
);
3448 dev_err(card
->dev
, "ASoC: Property '%s's length is zero\n",
3453 widgets
= devm_kcalloc(card
->dev
, num_widgets
, sizeof(*widgets
),
3457 "ASoC: Could not allocate memory for widgets\n");
3461 for (i
= 0; i
< num_widgets
; i
++) {
3462 ret
= of_property_read_string_index(np
, propname
,
3466 "ASoC: Property '%s' index %d read error:%d\n",
3467 propname
, 2 * i
, ret
);
3471 for (j
= 0; j
< ARRAY_SIZE(simple_widgets
); j
++) {
3472 if (!strncmp(template, simple_widgets
[j
].name
,
3473 strlen(simple_widgets
[j
].name
))) {
3474 widgets
[i
] = simple_widgets
[j
];
3479 if (j
>= ARRAY_SIZE(simple_widgets
)) {
3481 "ASoC: DAPM widget '%s' is not supported\n",
3486 ret
= of_property_read_string_index(np
, propname
,
3491 "ASoC: Property '%s' index %d read error:%d\n",
3492 propname
, (2 * i
) + 1, ret
);
3496 widgets
[i
].name
= wname
;
3499 card
->of_dapm_widgets
= widgets
;
3500 card
->num_of_dapm_widgets
= num_widgets
;
3504 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets
);
3506 int snd_soc_of_get_slot_mask(struct device_node
*np
,
3507 const char *prop_name
,
3511 const __be32
*of_slot_mask
= of_get_property(np
, prop_name
, &val
);
3517 for (i
= 0; i
< val
; i
++)
3518 if (be32_to_cpup(&of_slot_mask
[i
]))
3523 EXPORT_SYMBOL_GPL(snd_soc_of_get_slot_mask
);
3525 int snd_soc_of_parse_tdm_slot(struct device_node
*np
,
3526 unsigned int *tx_mask
,
3527 unsigned int *rx_mask
,
3528 unsigned int *slots
,
3529 unsigned int *slot_width
)
3535 snd_soc_of_get_slot_mask(np
, "dai-tdm-slot-tx-mask", tx_mask
);
3537 snd_soc_of_get_slot_mask(np
, "dai-tdm-slot-rx-mask", rx_mask
);
3539 if (of_property_read_bool(np
, "dai-tdm-slot-num")) {
3540 ret
= of_property_read_u32(np
, "dai-tdm-slot-num", &val
);
3548 if (of_property_read_bool(np
, "dai-tdm-slot-width")) {
3549 ret
= of_property_read_u32(np
, "dai-tdm-slot-width", &val
);
3559 EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot
);
3561 void snd_soc_of_parse_node_prefix(struct device_node
*np
,
3562 struct snd_soc_codec_conf
*codec_conf
,
3563 struct device_node
*of_node
,
3564 const char *propname
)
3569 ret
= of_property_read_string(np
, propname
, &str
);
3571 /* no prefix is not error */
3575 codec_conf
->of_node
= of_node
;
3576 codec_conf
->name_prefix
= str
;
3578 EXPORT_SYMBOL_GPL(snd_soc_of_parse_node_prefix
);
3580 int snd_soc_of_parse_audio_routing(struct snd_soc_card
*card
,
3581 const char *propname
)
3583 struct device_node
*np
= card
->dev
->of_node
;
3585 struct snd_soc_dapm_route
*routes
;
3588 num_routes
= of_property_count_strings(np
, propname
);
3589 if (num_routes
< 0 || num_routes
& 1) {
3591 "ASoC: Property '%s' does not exist or its length is not even\n",
3597 dev_err(card
->dev
, "ASoC: Property '%s's length is zero\n",
3602 routes
= devm_kcalloc(card
->dev
, num_routes
, sizeof(*routes
),
3606 "ASoC: Could not allocate DAPM route table\n");
3610 for (i
= 0; i
< num_routes
; i
++) {
3611 ret
= of_property_read_string_index(np
, propname
,
3612 2 * i
, &routes
[i
].sink
);
3615 "ASoC: Property '%s' index %d could not be read: %d\n",
3616 propname
, 2 * i
, ret
);
3619 ret
= of_property_read_string_index(np
, propname
,
3620 (2 * i
) + 1, &routes
[i
].source
);
3623 "ASoC: Property '%s' index %d could not be read: %d\n",
3624 propname
, (2 * i
) + 1, ret
);
3629 card
->num_of_dapm_routes
= num_routes
;
3630 card
->of_dapm_routes
= routes
;
3634 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing
);
3636 unsigned int snd_soc_of_parse_daifmt(struct device_node
*np
,
3638 struct device_node
**bitclkmaster
,
3639 struct device_node
**framemaster
)
3643 unsigned int format
= 0;
3649 } of_fmt_table
[] = {
3650 { "i2s", SND_SOC_DAIFMT_I2S
},
3651 { "right_j", SND_SOC_DAIFMT_RIGHT_J
},
3652 { "left_j", SND_SOC_DAIFMT_LEFT_J
},
3653 { "dsp_a", SND_SOC_DAIFMT_DSP_A
},
3654 { "dsp_b", SND_SOC_DAIFMT_DSP_B
},
3655 { "ac97", SND_SOC_DAIFMT_AC97
},
3656 { "pdm", SND_SOC_DAIFMT_PDM
},
3657 { "msb", SND_SOC_DAIFMT_MSB
},
3658 { "lsb", SND_SOC_DAIFMT_LSB
},
3665 * check "dai-format = xxx"
3666 * or "[prefix]format = xxx"
3667 * SND_SOC_DAIFMT_FORMAT_MASK area
3669 ret
= of_property_read_string(np
, "dai-format", &str
);
3671 snprintf(prop
, sizeof(prop
), "%sformat", prefix
);
3672 ret
= of_property_read_string(np
, prop
, &str
);
3675 for (i
= 0; i
< ARRAY_SIZE(of_fmt_table
); i
++) {
3676 if (strcmp(str
, of_fmt_table
[i
].name
) == 0) {
3677 format
|= of_fmt_table
[i
].val
;
3684 * check "[prefix]continuous-clock"
3685 * SND_SOC_DAIFMT_CLOCK_MASK area
3687 snprintf(prop
, sizeof(prop
), "%scontinuous-clock", prefix
);
3688 if (of_property_read_bool(np
, prop
))
3689 format
|= SND_SOC_DAIFMT_CONT
;
3691 format
|= SND_SOC_DAIFMT_GATED
;
3694 * check "[prefix]bitclock-inversion"
3695 * check "[prefix]frame-inversion"
3696 * SND_SOC_DAIFMT_INV_MASK area
3698 snprintf(prop
, sizeof(prop
), "%sbitclock-inversion", prefix
);
3699 bit
= !!of_get_property(np
, prop
, NULL
);
3701 snprintf(prop
, sizeof(prop
), "%sframe-inversion", prefix
);
3702 frame
= !!of_get_property(np
, prop
, NULL
);
3704 switch ((bit
<< 4) + frame
) {
3706 format
|= SND_SOC_DAIFMT_IB_IF
;
3709 format
|= SND_SOC_DAIFMT_IB_NF
;
3712 format
|= SND_SOC_DAIFMT_NB_IF
;
3715 /* SND_SOC_DAIFMT_NB_NF is default */
3720 * check "[prefix]bitclock-master"
3721 * check "[prefix]frame-master"
3722 * SND_SOC_DAIFMT_MASTER_MASK area
3724 snprintf(prop
, sizeof(prop
), "%sbitclock-master", prefix
);
3725 bit
= !!of_get_property(np
, prop
, NULL
);
3726 if (bit
&& bitclkmaster
)
3727 *bitclkmaster
= of_parse_phandle(np
, prop
, 0);
3729 snprintf(prop
, sizeof(prop
), "%sframe-master", prefix
);
3730 frame
= !!of_get_property(np
, prop
, NULL
);
3731 if (frame
&& framemaster
)
3732 *framemaster
= of_parse_phandle(np
, prop
, 0);
3734 switch ((bit
<< 4) + frame
) {
3736 format
|= SND_SOC_DAIFMT_CBM_CFM
;
3739 format
|= SND_SOC_DAIFMT_CBM_CFS
;
3742 format
|= SND_SOC_DAIFMT_CBS_CFM
;
3745 format
|= SND_SOC_DAIFMT_CBS_CFS
;
3751 EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt
);
3753 int snd_soc_get_dai_id(struct device_node
*ep
)
3755 struct snd_soc_component
*pos
;
3756 struct device_node
*node
;
3759 node
= of_graph_get_port_parent(ep
);
3762 * For example HDMI case, HDMI has video/sound port,
3763 * but ALSA SoC needs sound port number only.
3764 * Thus counting HDMI DT port/endpoint doesn't work.
3765 * Then, it should have .of_xlate_dai_id
3768 mutex_lock(&client_mutex
);
3769 for_each_component(pos
) {
3770 struct device_node
*component_of_node
= pos
->dev
->of_node
;
3772 if (!component_of_node
&& pos
->dev
->parent
)
3773 component_of_node
= pos
->dev
->parent
->of_node
;
3775 if (component_of_node
!= node
)
3778 if (pos
->driver
->of_xlate_dai_id
)
3779 ret
= pos
->driver
->of_xlate_dai_id(pos
, ep
);
3783 mutex_unlock(&client_mutex
);
3789 EXPORT_SYMBOL_GPL(snd_soc_get_dai_id
);
3791 int snd_soc_get_dai_name(struct of_phandle_args
*args
,
3792 const char **dai_name
)
3794 struct snd_soc_component
*pos
;
3795 struct device_node
*component_of_node
;
3796 int ret
= -EPROBE_DEFER
;
3798 mutex_lock(&client_mutex
);
3799 for_each_component(pos
) {
3800 component_of_node
= pos
->dev
->of_node
;
3801 if (!component_of_node
&& pos
->dev
->parent
)
3802 component_of_node
= pos
->dev
->parent
->of_node
;
3804 if (component_of_node
!= args
->np
)
3807 if (pos
->driver
->of_xlate_dai_name
) {
3808 ret
= pos
->driver
->of_xlate_dai_name(pos
,
3812 struct snd_soc_dai
*dai
;
3815 switch (args
->args_count
) {
3817 id
= 0; /* same as dai_drv[0] */
3827 if (id
< 0 || id
>= pos
->num_dai
) {
3834 /* find target DAI */
3835 for_each_component_dais(pos
, dai
) {
3841 *dai_name
= dai
->driver
->name
;
3843 *dai_name
= pos
->name
;
3848 mutex_unlock(&client_mutex
);
3851 EXPORT_SYMBOL_GPL(snd_soc_get_dai_name
);
3853 int snd_soc_of_get_dai_name(struct device_node
*of_node
,
3854 const char **dai_name
)
3856 struct of_phandle_args args
;
3859 ret
= of_parse_phandle_with_args(of_node
, "sound-dai",
3860 "#sound-dai-cells", 0, &args
);
3864 ret
= snd_soc_get_dai_name(&args
, dai_name
);
3866 of_node_put(args
.np
);
3870 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name
);
3873 * snd_soc_of_put_dai_link_codecs - Dereference device nodes in the codecs array
3874 * @dai_link: DAI link
3876 * Dereference device nodes acquired by snd_soc_of_get_dai_link_codecs().
3878 void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link
*dai_link
)
3880 struct snd_soc_dai_link_component
*component
;
3883 for_each_link_codecs(dai_link
, index
, component
) {
3884 if (!component
->of_node
)
3886 of_node_put(component
->of_node
);
3887 component
->of_node
= NULL
;
3890 EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_codecs
);
3893 * snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree
3895 * @of_node: Device node
3896 * @dai_link: DAI link
3898 * Builds an array of CODEC DAI components from the DAI link property
3900 * The array is set in the DAI link and the number of DAIs is set accordingly.
3901 * The device nodes in the array (of_node) must be dereferenced by calling
3902 * snd_soc_of_put_dai_link_codecs() on @dai_link.
3904 * Returns 0 for success
3906 int snd_soc_of_get_dai_link_codecs(struct device
*dev
,
3907 struct device_node
*of_node
,
3908 struct snd_soc_dai_link
*dai_link
)
3910 struct of_phandle_args args
;
3911 struct snd_soc_dai_link_component
*component
;
3913 int index
, num_codecs
, ret
;
3915 /* Count the number of CODECs */
3917 num_codecs
= of_count_phandle_with_args(of_node
, name
,
3918 "#sound-dai-cells");
3919 if (num_codecs
<= 0) {
3920 if (num_codecs
== -ENOENT
)
3921 dev_err(dev
, "No 'sound-dai' property\n");
3923 dev_err(dev
, "Bad phandle in 'sound-dai'\n");
3926 component
= devm_kcalloc(dev
,
3927 num_codecs
, sizeof(*component
),
3931 dai_link
->codecs
= component
;
3932 dai_link
->num_codecs
= num_codecs
;
3934 /* Parse the list */
3935 for_each_link_codecs(dai_link
, index
, component
) {
3936 ret
= of_parse_phandle_with_args(of_node
, name
,
3941 component
->of_node
= args
.np
;
3942 ret
= snd_soc_get_dai_name(&args
, &component
->dai_name
);
3948 snd_soc_of_put_dai_link_codecs(dai_link
);
3949 dai_link
->codecs
= NULL
;
3950 dai_link
->num_codecs
= 0;
3953 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs
);
3955 static int __init
snd_soc_init(void)
3957 snd_soc_debugfs_init();
3958 snd_soc_util_init();
3960 return platform_driver_register(&soc_driver
);
3962 module_init(snd_soc_init
);
3964 static void __exit
snd_soc_exit(void)
3966 snd_soc_util_exit();
3967 snd_soc_debugfs_exit();
3969 platform_driver_unregister(&soc_driver
);
3971 module_exit(snd_soc_exit
);
3973 /* Module information */
3974 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
3975 MODULE_DESCRIPTION("ALSA SoC Core");
3976 MODULE_LICENSE("GPL");
3977 MODULE_ALIAS("platform:soc-audio");