1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/module.h>
24#include <linux/moduleparam.h>
25#include <linux/init.h>
26#include <linux/delay.h>
27#include <linux/pm.h>
28#include <linux/bitops.h>
29#include <linux/debugfs.h>
30#include <linux/platform_device.h>
31#include <sound/ac97_codec.h>
32#include <sound/core.h>
33#include <sound/pcm.h>
34#include <sound/pcm_params.h>
35#include <sound/soc.h>
36#include <sound/soc-dapm.h>
37#include <sound/initval.h>
38
39static DEFINE_MUTEX(pcm_mutex);
40static DEFINE_MUTEX(io_mutex);
41static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
42
43#ifdef CONFIG_DEBUG_FS
44static struct dentry *debugfs_root;
45#endif
46
47static DEFINE_MUTEX(client_mutex);
48static LIST_HEAD(card_list);
49static LIST_HEAD(dai_list);
50static LIST_HEAD(platform_list);
51static LIST_HEAD(codec_list);
52
53static int snd_soc_register_card(struct snd_soc_card *card);
54static int snd_soc_unregister_card(struct snd_soc_card *card);
55
56
57
58
59
60
61static int pmdown_time = 5000;
62module_param(pmdown_time, int, 0);
63MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
64
65
66
67
68static int run_delayed_work(struct delayed_work *dwork)
69{
70 int ret;
71
72
73 ret = cancel_delayed_work(dwork);
74
75
76
77 if (ret) {
78 schedule_delayed_work(dwork, 0);
79 flush_scheduled_work();
80 }
81 return ret;
82}
83
84#ifdef CONFIG_SND_SOC_AC97_BUS
85
86static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
87{
88 if (codec->ac97->dev.bus)
89 device_unregister(&codec->ac97->dev);
90 return 0;
91}
92
93
94static void soc_ac97_device_release(struct device *dev){}
95
96
97static int soc_ac97_dev_register(struct snd_soc_codec *codec)
98{
99 int err;
100
101 codec->ac97->dev.bus = &ac97_bus_type;
102 codec->ac97->dev.parent = codec->card->dev;
103 codec->ac97->dev.release = soc_ac97_device_release;
104
105 dev_set_name(&codec->ac97->dev, "%d-%d:%s",
106 codec->card->number, 0, codec->name);
107 err = device_register(&codec->ac97->dev);
108 if (err < 0) {
109 snd_printk(KERN_ERR "Can't register ac97 bus\n");
110 codec->ac97->dev.bus = NULL;
111 return err;
112 }
113 return 0;
114}
115#endif
116
117static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream)
118{
119 struct snd_soc_pcm_runtime *rtd = substream->private_data;
120 struct snd_soc_device *socdev = rtd->socdev;
121 struct snd_soc_card *card = socdev->card;
122 struct snd_soc_dai_link *machine = rtd->dai;
123 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
124 struct snd_soc_dai *codec_dai = machine->codec_dai;
125 int ret;
126
127 if (codec_dai->symmetric_rates || cpu_dai->symmetric_rates ||
128 machine->symmetric_rates) {
129 dev_dbg(card->dev, "Symmetry forces %dHz rate\n",
130 machine->rate);
131
132 ret = snd_pcm_hw_constraint_minmax(substream->runtime,
133 SNDRV_PCM_HW_PARAM_RATE,
134 machine->rate,
135 machine->rate);
136 if (ret < 0) {
137 dev_err(card->dev,
138 "Unable to apply rate symmetry constraint: %d\n", ret);
139 return ret;
140 }
141 }
142
143 return 0;
144}
145
146
147
148
149
150
151static int soc_pcm_open(struct snd_pcm_substream *substream)
152{
153 struct snd_soc_pcm_runtime *rtd = substream->private_data;
154 struct snd_soc_device *socdev = rtd->socdev;
155 struct snd_soc_card *card = socdev->card;
156 struct snd_pcm_runtime *runtime = substream->runtime;
157 struct snd_soc_dai_link *machine = rtd->dai;
158 struct snd_soc_platform *platform = card->platform;
159 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
160 struct snd_soc_dai *codec_dai = machine->codec_dai;
161 int ret = 0;
162
163 mutex_lock(&pcm_mutex);
164
165
166 if (cpu_dai->ops->startup) {
167 ret = cpu_dai->ops->startup(substream, cpu_dai);
168 if (ret < 0) {
169 printk(KERN_ERR "asoc: can't open interface %s\n",
170 cpu_dai->name);
171 goto out;
172 }
173 }
174
175 if (platform->pcm_ops->open) {
176 ret = platform->pcm_ops->open(substream);
177 if (ret < 0) {
178 printk(KERN_ERR "asoc: can't open platform %s\n", platform->name);
179 goto platform_err;
180 }
181 }
182
183 if (codec_dai->ops->startup) {
184 ret = codec_dai->ops->startup(substream, codec_dai);
185 if (ret < 0) {
186 printk(KERN_ERR "asoc: can't open codec %s\n",
187 codec_dai->name);
188 goto codec_dai_err;
189 }
190 }
191
192 if (machine->ops && machine->ops->startup) {
193 ret = machine->ops->startup(substream);
194 if (ret < 0) {
195 printk(KERN_ERR "asoc: %s startup failed\n", machine->name);
196 goto machine_err;
197 }
198 }
199
200
201 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
202 runtime->hw.rate_min =
203 max(codec_dai->playback.rate_min,
204 cpu_dai->playback.rate_min);
205 runtime->hw.rate_max =
206 min(codec_dai->playback.rate_max,
207 cpu_dai->playback.rate_max);
208 runtime->hw.channels_min =
209 max(codec_dai->playback.channels_min,
210 cpu_dai->playback.channels_min);
211 runtime->hw.channels_max =
212 min(codec_dai->playback.channels_max,
213 cpu_dai->playback.channels_max);
214 runtime->hw.formats =
215 codec_dai->playback.formats & cpu_dai->playback.formats;
216 runtime->hw.rates =
217 codec_dai->playback.rates & cpu_dai->playback.rates;
218 } else {
219 runtime->hw.rate_min =
220 max(codec_dai->capture.rate_min,
221 cpu_dai->capture.rate_min);
222 runtime->hw.rate_max =
223 min(codec_dai->capture.rate_max,
224 cpu_dai->capture.rate_max);
225 runtime->hw.channels_min =
226 max(codec_dai->capture.channels_min,
227 cpu_dai->capture.channels_min);
228 runtime->hw.channels_max =
229 min(codec_dai->capture.channels_max,
230 cpu_dai->capture.channels_max);
231 runtime->hw.formats =
232 codec_dai->capture.formats & cpu_dai->capture.formats;
233 runtime->hw.rates =
234 codec_dai->capture.rates & cpu_dai->capture.rates;
235 }
236
237 snd_pcm_limit_hw_rates(runtime);
238 if (!runtime->hw.rates) {
239 printk(KERN_ERR "asoc: %s <-> %s No matching rates\n",
240 codec_dai->name, cpu_dai->name);
241 goto machine_err;
242 }
243 if (!runtime->hw.formats) {
244 printk(KERN_ERR "asoc: %s <-> %s No matching formats\n",
245 codec_dai->name, cpu_dai->name);
246 goto machine_err;
247 }
248 if (!runtime->hw.channels_min || !runtime->hw.channels_max) {
249 printk(KERN_ERR "asoc: %s <-> %s No matching channels\n",
250 codec_dai->name, cpu_dai->name);
251 goto machine_err;
252 }
253
254
255 if (cpu_dai->active || codec_dai->active) {
256 ret = soc_pcm_apply_symmetry(substream);
257 if (ret != 0)
258 goto machine_err;
259 }
260
261 pr_debug("asoc: %s <-> %s info:\n", codec_dai->name, cpu_dai->name);
262 pr_debug("asoc: rate mask 0x%x\n", runtime->hw.rates);
263 pr_debug("asoc: min ch %d max ch %d\n", runtime->hw.channels_min,
264 runtime->hw.channels_max);
265 pr_debug("asoc: min rate %d max rate %d\n", runtime->hw.rate_min,
266 runtime->hw.rate_max);
267
268 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
269 cpu_dai->playback.active = codec_dai->playback.active = 1;
270 else
271 cpu_dai->capture.active = codec_dai->capture.active = 1;
272 cpu_dai->active = codec_dai->active = 1;
273 cpu_dai->runtime = runtime;
274 card->codec->active++;
275 mutex_unlock(&pcm_mutex);
276 return 0;
277
278machine_err:
279 if (machine->ops && machine->ops->shutdown)
280 machine->ops->shutdown(substream);
281
282codec_dai_err:
283 if (platform->pcm_ops->close)
284 platform->pcm_ops->close(substream);
285
286platform_err:
287 if (cpu_dai->ops->shutdown)
288 cpu_dai->ops->shutdown(substream, cpu_dai);
289out:
290 mutex_unlock(&pcm_mutex);
291 return ret;
292}
293
294
295
296
297
298
299static void close_delayed_work(struct work_struct *work)
300{
301 struct snd_soc_card *card = container_of(work, struct snd_soc_card,
302 delayed_work.work);
303 struct snd_soc_codec *codec = card->codec;
304 struct snd_soc_dai *codec_dai;
305 int i;
306
307 mutex_lock(&pcm_mutex);
308 for (i = 0; i < codec->num_dai; i++) {
309 codec_dai = &codec->dai[i];
310
311 pr_debug("pop wq checking: %s status: %s waiting: %s\n",
312 codec_dai->playback.stream_name,
313 codec_dai->playback.active ? "active" : "inactive",
314 codec_dai->pop_wait ? "yes" : "no");
315
316
317 if (codec_dai->pop_wait == 1) {
318 codec_dai->pop_wait = 0;
319 snd_soc_dapm_stream_event(codec,
320 codec_dai->playback.stream_name,
321 SND_SOC_DAPM_STREAM_STOP);
322 }
323 }
324 mutex_unlock(&pcm_mutex);
325}
326
327
328
329
330
331
332static int soc_codec_close(struct snd_pcm_substream *substream)
333{
334 struct snd_soc_pcm_runtime *rtd = substream->private_data;
335 struct snd_soc_device *socdev = rtd->socdev;
336 struct snd_soc_card *card = socdev->card;
337 struct snd_soc_dai_link *machine = rtd->dai;
338 struct snd_soc_platform *platform = card->platform;
339 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
340 struct snd_soc_dai *codec_dai = machine->codec_dai;
341 struct snd_soc_codec *codec = card->codec;
342
343 mutex_lock(&pcm_mutex);
344
345 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
346 cpu_dai->playback.active = codec_dai->playback.active = 0;
347 else
348 cpu_dai->capture.active = codec_dai->capture.active = 0;
349
350 if (codec_dai->playback.active == 0 &&
351 codec_dai->capture.active == 0) {
352 cpu_dai->active = codec_dai->active = 0;
353 }
354 codec->active--;
355
356
357
358
359 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
360 snd_soc_dai_digital_mute(codec_dai, 1);
361
362 if (cpu_dai->ops->shutdown)
363 cpu_dai->ops->shutdown(substream, cpu_dai);
364
365 if (codec_dai->ops->shutdown)
366 codec_dai->ops->shutdown(substream, codec_dai);
367
368 if (machine->ops && machine->ops->shutdown)
369 machine->ops->shutdown(substream);
370
371 if (platform->pcm_ops->close)
372 platform->pcm_ops->close(substream);
373 cpu_dai->runtime = NULL;
374
375 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
376
377 codec_dai->pop_wait = 1;
378 schedule_delayed_work(&card->delayed_work,
379 msecs_to_jiffies(pmdown_time));
380 } else {
381
382 snd_soc_dapm_stream_event(codec,
383 codec_dai->capture.stream_name,
384 SND_SOC_DAPM_STREAM_STOP);
385 }
386
387 mutex_unlock(&pcm_mutex);
388 return 0;
389}
390
391
392
393
394
395
396static int soc_pcm_prepare(struct snd_pcm_substream *substream)
397{
398 struct snd_soc_pcm_runtime *rtd = substream->private_data;
399 struct snd_soc_device *socdev = rtd->socdev;
400 struct snd_soc_card *card = socdev->card;
401 struct snd_soc_dai_link *machine = rtd->dai;
402 struct snd_soc_platform *platform = card->platform;
403 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
404 struct snd_soc_dai *codec_dai = machine->codec_dai;
405 struct snd_soc_codec *codec = card->codec;
406 int ret = 0;
407
408 mutex_lock(&pcm_mutex);
409
410 if (machine->ops && machine->ops->prepare) {
411 ret = machine->ops->prepare(substream);
412 if (ret < 0) {
413 printk(KERN_ERR "asoc: machine prepare error\n");
414 goto out;
415 }
416 }
417
418 if (platform->pcm_ops->prepare) {
419 ret = platform->pcm_ops->prepare(substream);
420 if (ret < 0) {
421 printk(KERN_ERR "asoc: platform prepare error\n");
422 goto out;
423 }
424 }
425
426 if (codec_dai->ops->prepare) {
427 ret = codec_dai->ops->prepare(substream, codec_dai);
428 if (ret < 0) {
429 printk(KERN_ERR "asoc: codec DAI prepare error\n");
430 goto out;
431 }
432 }
433
434 if (cpu_dai->ops->prepare) {
435 ret = cpu_dai->ops->prepare(substream, cpu_dai);
436 if (ret < 0) {
437 printk(KERN_ERR "asoc: cpu DAI prepare error\n");
438 goto out;
439 }
440 }
441
442
443 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
444 codec_dai->pop_wait) {
445 codec_dai->pop_wait = 0;
446 cancel_delayed_work(&card->delayed_work);
447 }
448
449 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
450 snd_soc_dapm_stream_event(codec,
451 codec_dai->playback.stream_name,
452 SND_SOC_DAPM_STREAM_START);
453 else
454 snd_soc_dapm_stream_event(codec,
455 codec_dai->capture.stream_name,
456 SND_SOC_DAPM_STREAM_START);
457
458 snd_soc_dai_digital_mute(codec_dai, 0);
459
460out:
461 mutex_unlock(&pcm_mutex);
462 return ret;
463}
464
465
466
467
468
469
470static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
471 struct snd_pcm_hw_params *params)
472{
473 struct snd_soc_pcm_runtime *rtd = substream->private_data;
474 struct snd_soc_device *socdev = rtd->socdev;
475 struct snd_soc_dai_link *machine = rtd->dai;
476 struct snd_soc_card *card = socdev->card;
477 struct snd_soc_platform *platform = card->platform;
478 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
479 struct snd_soc_dai *codec_dai = machine->codec_dai;
480 int ret = 0;
481
482 mutex_lock(&pcm_mutex);
483
484 if (machine->ops && machine->ops->hw_params) {
485 ret = machine->ops->hw_params(substream, params);
486 if (ret < 0) {
487 printk(KERN_ERR "asoc: machine hw_params failed\n");
488 goto out;
489 }
490 }
491
492 if (codec_dai->ops->hw_params) {
493 ret = codec_dai->ops->hw_params(substream, params, codec_dai);
494 if (ret < 0) {
495 printk(KERN_ERR "asoc: can't set codec %s hw params\n",
496 codec_dai->name);
497 goto codec_err;
498 }
499 }
500
501 if (cpu_dai->ops->hw_params) {
502 ret = cpu_dai->ops->hw_params(substream, params, cpu_dai);
503 if (ret < 0) {
504 printk(KERN_ERR "asoc: interface %s hw params failed\n",
505 cpu_dai->name);
506 goto interface_err;
507 }
508 }
509
510 if (platform->pcm_ops->hw_params) {
511 ret = platform->pcm_ops->hw_params(substream, params);
512 if (ret < 0) {
513 printk(KERN_ERR "asoc: platform %s hw params failed\n",
514 platform->name);
515 goto platform_err;
516 }
517 }
518
519 machine->rate = params_rate(params);
520
521out:
522 mutex_unlock(&pcm_mutex);
523 return ret;
524
525platform_err:
526 if (cpu_dai->ops->hw_free)
527 cpu_dai->ops->hw_free(substream, cpu_dai);
528
529interface_err:
530 if (codec_dai->ops->hw_free)
531 codec_dai->ops->hw_free(substream, codec_dai);
532
533codec_err:
534 if (machine->ops && machine->ops->hw_free)
535 machine->ops->hw_free(substream);
536
537 mutex_unlock(&pcm_mutex);
538 return ret;
539}
540
541
542
543
544static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
545{
546 struct snd_soc_pcm_runtime *rtd = substream->private_data;
547 struct snd_soc_device *socdev = rtd->socdev;
548 struct snd_soc_dai_link *machine = rtd->dai;
549 struct snd_soc_card *card = socdev->card;
550 struct snd_soc_platform *platform = card->platform;
551 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
552 struct snd_soc_dai *codec_dai = machine->codec_dai;
553 struct snd_soc_codec *codec = card->codec;
554
555 mutex_lock(&pcm_mutex);
556
557
558 if (!codec->active)
559 snd_soc_dai_digital_mute(codec_dai, 1);
560
561
562 if (machine->ops && machine->ops->hw_free)
563 machine->ops->hw_free(substream);
564
565
566 if (platform->pcm_ops->hw_free)
567 platform->pcm_ops->hw_free(substream);
568
569
570 if (codec_dai->ops->hw_free)
571 codec_dai->ops->hw_free(substream, codec_dai);
572
573 if (cpu_dai->ops->hw_free)
574 cpu_dai->ops->hw_free(substream, cpu_dai);
575
576 mutex_unlock(&pcm_mutex);
577 return 0;
578}
579
580static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
581{
582 struct snd_soc_pcm_runtime *rtd = substream->private_data;
583 struct snd_soc_device *socdev = rtd->socdev;
584 struct snd_soc_card *card= socdev->card;
585 struct snd_soc_dai_link *machine = rtd->dai;
586 struct snd_soc_platform *platform = card->platform;
587 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
588 struct snd_soc_dai *codec_dai = machine->codec_dai;
589 int ret;
590
591 if (codec_dai->ops->trigger) {
592 ret = codec_dai->ops->trigger(substream, cmd, codec_dai);
593 if (ret < 0)
594 return ret;
595 }
596
597 if (platform->pcm_ops->trigger) {
598 ret = platform->pcm_ops->trigger(substream, cmd);
599 if (ret < 0)
600 return ret;
601 }
602
603 if (cpu_dai->ops->trigger) {
604 ret = cpu_dai->ops->trigger(substream, cmd, cpu_dai);
605 if (ret < 0)
606 return ret;
607 }
608 return 0;
609}
610
611
612static struct snd_pcm_ops soc_pcm_ops = {
613 .open = soc_pcm_open,
614 .close = soc_codec_close,
615 .hw_params = soc_pcm_hw_params,
616 .hw_free = soc_pcm_hw_free,
617 .prepare = soc_pcm_prepare,
618 .trigger = soc_pcm_trigger,
619};
620
621#ifdef CONFIG_PM
622
623static int soc_suspend(struct device *dev)
624{
625 struct platform_device *pdev = to_platform_device(dev);
626 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
627 struct snd_soc_card *card = socdev->card;
628 struct snd_soc_platform *platform = card->platform;
629 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
630 struct snd_soc_codec *codec = card->codec;
631 int i;
632
633
634
635
636 if (!codec)
637 return 0;
638
639
640
641
642 snd_power_lock(codec->card);
643 snd_power_wait(codec->card, SNDRV_CTL_POWER_D0);
644 snd_power_unlock(codec->card);
645
646
647 snd_power_change_state(codec->card, SNDRV_CTL_POWER_D3hot);
648
649
650 for (i = 0; i < card->num_links; i++) {
651 struct snd_soc_dai *dai = card->dai_link[i].codec_dai;
652 if (dai->ops->digital_mute && dai->playback.active)
653 dai->ops->digital_mute(dai, 1);
654 }
655
656
657 for (i = 0; i < card->num_links; i++)
658 snd_pcm_suspend_all(card->dai_link[i].pcm);
659
660 if (card->suspend_pre)
661 card->suspend_pre(pdev, PMSG_SUSPEND);
662
663 for (i = 0; i < card->num_links; i++) {
664 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
665 if (cpu_dai->suspend && !cpu_dai->ac97_control)
666 cpu_dai->suspend(cpu_dai);
667 if (platform->suspend)
668 platform->suspend(cpu_dai);
669 }
670
671
672 run_delayed_work(&card->delayed_work);
673 codec->suspend_bias_level = codec->bias_level;
674
675 for (i = 0; i < codec->num_dai; i++) {
676 char *stream = codec->dai[i].playback.stream_name;
677 if (stream != NULL)
678 snd_soc_dapm_stream_event(codec, stream,
679 SND_SOC_DAPM_STREAM_SUSPEND);
680 stream = codec->dai[i].capture.stream_name;
681 if (stream != NULL)
682 snd_soc_dapm_stream_event(codec, stream,
683 SND_SOC_DAPM_STREAM_SUSPEND);
684 }
685
686 if (codec_dev->suspend)
687 codec_dev->suspend(pdev, PMSG_SUSPEND);
688
689 for (i = 0; i < card->num_links; i++) {
690 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
691 if (cpu_dai->suspend && cpu_dai->ac97_control)
692 cpu_dai->suspend(cpu_dai);
693 }
694
695 if (card->suspend_post)
696 card->suspend_post(pdev, PMSG_SUSPEND);
697
698 return 0;
699}
700
701
702
703
704static void soc_resume_deferred(struct work_struct *work)
705{
706 struct snd_soc_card *card = container_of(work,
707 struct snd_soc_card,
708 deferred_resume_work);
709 struct snd_soc_device *socdev = card->socdev;
710 struct snd_soc_platform *platform = card->platform;
711 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
712 struct snd_soc_codec *codec = card->codec;
713 struct platform_device *pdev = to_platform_device(socdev->dev);
714 int i;
715
716
717
718
719
720 dev_dbg(socdev->dev, "starting resume work\n");
721
722 if (card->resume_pre)
723 card->resume_pre(pdev);
724
725 for (i = 0; i < card->num_links; i++) {
726 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
727 if (cpu_dai->resume && cpu_dai->ac97_control)
728 cpu_dai->resume(cpu_dai);
729 }
730
731 if (codec_dev->resume)
732 codec_dev->resume(pdev);
733
734 for (i = 0; i < codec->num_dai; i++) {
735 char *stream = codec->dai[i].playback.stream_name;
736 if (stream != NULL)
737 snd_soc_dapm_stream_event(codec, stream,
738 SND_SOC_DAPM_STREAM_RESUME);
739 stream = codec->dai[i].capture.stream_name;
740 if (stream != NULL)
741 snd_soc_dapm_stream_event(codec, stream,
742 SND_SOC_DAPM_STREAM_RESUME);
743 }
744
745
746 for (i = 0; i < card->num_links; i++) {
747 struct snd_soc_dai *dai = card->dai_link[i].codec_dai;
748 if (dai->ops->digital_mute && dai->playback.active)
749 dai->ops->digital_mute(dai, 0);
750 }
751
752 for (i = 0; i < card->num_links; i++) {
753 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
754 if (cpu_dai->resume && !cpu_dai->ac97_control)
755 cpu_dai->resume(cpu_dai);
756 if (platform->resume)
757 platform->resume(cpu_dai);
758 }
759
760 if (card->resume_post)
761 card->resume_post(pdev);
762
763 dev_dbg(socdev->dev, "resume work completed\n");
764
765
766 snd_power_change_state(codec->card, SNDRV_CTL_POWER_D0);
767}
768
769
770static int soc_resume(struct device *dev)
771{
772 struct platform_device *pdev = to_platform_device(dev);
773 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
774 struct snd_soc_card *card = socdev->card;
775 struct snd_soc_dai *cpu_dai = card->dai_link[0].cpu_dai;
776
777
778
779
780
781
782 if (cpu_dai->ac97_control) {
783 dev_dbg(socdev->dev, "Resuming AC97 immediately\n");
784 soc_resume_deferred(&card->deferred_resume_work);
785 } else {
786 dev_dbg(socdev->dev, "Scheduling resume work\n");
787 if (!schedule_work(&card->deferred_resume_work))
788 dev_err(socdev->dev, "resume work item may be lost\n");
789 }
790
791 return 0;
792}
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807int snd_soc_suspend_device(struct device *dev)
808{
809 return 0;
810}
811EXPORT_SYMBOL_GPL(snd_soc_suspend_device);
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827int snd_soc_resume_device(struct device *dev)
828{
829 return 0;
830}
831EXPORT_SYMBOL_GPL(snd_soc_resume_device);
832#else
833#define soc_suspend NULL
834#define soc_resume NULL
835#endif
836
837static struct snd_soc_dai_ops null_dai_ops = {
838};
839
840static void snd_soc_instantiate_card(struct snd_soc_card *card)
841{
842 struct platform_device *pdev = container_of(card->dev,
843 struct platform_device,
844 dev);
845 struct snd_soc_codec_device *codec_dev = card->socdev->codec_dev;
846 struct snd_soc_platform *platform;
847 struct snd_soc_dai *dai;
848 int i, found, ret, ac97;
849
850 if (card->instantiated)
851 return;
852
853 found = 0;
854 list_for_each_entry(platform, &platform_list, list)
855 if (card->platform == platform) {
856 found = 1;
857 break;
858 }
859 if (!found) {
860 dev_dbg(card->dev, "Platform %s not registered\n",
861 card->platform->name);
862 return;
863 }
864
865 ac97 = 0;
866 for (i = 0; i < card->num_links; i++) {
867 found = 0;
868 list_for_each_entry(dai, &dai_list, list)
869 if (card->dai_link[i].cpu_dai == dai) {
870 found = 1;
871 break;
872 }
873 if (!found) {
874 dev_dbg(card->dev, "DAI %s not registered\n",
875 card->dai_link[i].cpu_dai->name);
876 return;
877 }
878
879 if (card->dai_link[i].cpu_dai->ac97_control)
880 ac97 = 1;
881 }
882
883 for (i = 0; i < card->num_links; i++) {
884 if (!card->dai_link[i].codec_dai->ops)
885 card->dai_link[i].codec_dai->ops = &null_dai_ops;
886 }
887
888
889
890
891
892
893
894 if (!ac97)
895 for (i = 0; i < card->num_links; i++) {
896 found = 0;
897 list_for_each_entry(dai, &dai_list, list)
898 if (card->dai_link[i].codec_dai == dai) {
899 found = 1;
900 break;
901 }
902 if (!found) {
903 dev_dbg(card->dev, "DAI %s not registered\n",
904 card->dai_link[i].codec_dai->name);
905 return;
906 }
907 }
908
909
910
911 dev_dbg(card->dev, "All components present, instantiating\n");
912
913
914 if (card->probe) {
915 ret = card->probe(pdev);
916 if (ret < 0)
917 return;
918 }
919
920 for (i = 0; i < card->num_links; i++) {
921 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
922 if (cpu_dai->probe) {
923 ret = cpu_dai->probe(pdev, cpu_dai);
924 if (ret < 0)
925 goto cpu_dai_err;
926 }
927 }
928
929 if (codec_dev->probe) {
930 ret = codec_dev->probe(pdev);
931 if (ret < 0)
932 goto cpu_dai_err;
933 }
934
935 if (platform->probe) {
936 ret = platform->probe(pdev);
937 if (ret < 0)
938 goto platform_err;
939 }
940
941
942 INIT_DELAYED_WORK(&card->delayed_work, close_delayed_work);
943#ifdef CONFIG_PM
944
945 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
946#endif
947
948 card->instantiated = 1;
949
950 return;
951
952platform_err:
953 if (codec_dev->remove)
954 codec_dev->remove(pdev);
955
956cpu_dai_err:
957 for (i--; i >= 0; i--) {
958 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
959 if (cpu_dai->remove)
960 cpu_dai->remove(pdev, cpu_dai);
961 }
962
963 if (card->remove)
964 card->remove(pdev);
965}
966
967
968
969
970
971static void snd_soc_instantiate_cards(void)
972{
973 struct snd_soc_card *card;
974 list_for_each_entry(card, &card_list, list)
975 snd_soc_instantiate_card(card);
976}
977
978
979static int soc_probe(struct platform_device *pdev)
980{
981 int ret = 0;
982 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
983 struct snd_soc_card *card = socdev->card;
984
985
986 card->socdev = socdev;
987
988
989 card->dev = &pdev->dev;
990 ret = snd_soc_register_card(card);
991 if (ret != 0) {
992 dev_err(&pdev->dev, "Failed to register card\n");
993 return ret;
994 }
995
996 return 0;
997}
998
999
1000static int soc_remove(struct platform_device *pdev)
1001{
1002 int i;
1003 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1004 struct snd_soc_card *card = socdev->card;
1005 struct snd_soc_platform *platform = card->platform;
1006 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
1007
1008 if (!card->instantiated)
1009 return 0;
1010
1011 run_delayed_work(&card->delayed_work);
1012
1013 if (platform->remove)
1014 platform->remove(pdev);
1015
1016 if (codec_dev->remove)
1017 codec_dev->remove(pdev);
1018
1019 for (i = 0; i < card->num_links; i++) {
1020 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
1021 if (cpu_dai->remove)
1022 cpu_dai->remove(pdev, cpu_dai);
1023 }
1024
1025 if (card->remove)
1026 card->remove(pdev);
1027
1028 snd_soc_unregister_card(card);
1029
1030 return 0;
1031}
1032
1033static int soc_poweroff(struct device *dev)
1034{
1035 struct platform_device *pdev = to_platform_device(dev);
1036 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1037 struct snd_soc_card *card = socdev->card;
1038
1039 if (!card->instantiated)
1040 return 0;
1041
1042
1043
1044 run_delayed_work(&card->delayed_work);
1045
1046 snd_soc_dapm_shutdown(socdev);
1047
1048 return 0;
1049}
1050
1051static struct dev_pm_ops soc_pm_ops = {
1052 .suspend = soc_suspend,
1053 .resume = soc_resume,
1054 .poweroff = soc_poweroff,
1055};
1056
1057
1058static struct platform_driver soc_driver = {
1059 .driver = {
1060 .name = "soc-audio",
1061 .owner = THIS_MODULE,
1062 .pm = &soc_pm_ops,
1063 },
1064 .probe = soc_probe,
1065 .remove = soc_remove,
1066};
1067
1068
1069static int soc_new_pcm(struct snd_soc_device *socdev,
1070 struct snd_soc_dai_link *dai_link, int num)
1071{
1072 struct snd_soc_card *card = socdev->card;
1073 struct snd_soc_codec *codec = card->codec;
1074 struct snd_soc_platform *platform = card->platform;
1075 struct snd_soc_dai *codec_dai = dai_link->codec_dai;
1076 struct snd_soc_dai *cpu_dai = dai_link->cpu_dai;
1077 struct snd_soc_pcm_runtime *rtd;
1078 struct snd_pcm *pcm;
1079 char new_name[64];
1080 int ret = 0, playback = 0, capture = 0;
1081
1082 rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
1083 if (rtd == NULL)
1084 return -ENOMEM;
1085
1086 rtd->dai = dai_link;
1087 rtd->socdev = socdev;
1088 codec_dai->codec = card->codec;
1089
1090
1091 sprintf(new_name, "%s %s-%d", dai_link->stream_name, codec_dai->name,
1092 num);
1093
1094 if (codec_dai->playback.channels_min)
1095 playback = 1;
1096 if (codec_dai->capture.channels_min)
1097 capture = 1;
1098
1099 ret = snd_pcm_new(codec->card, new_name, codec->pcm_devs++, playback,
1100 capture, &pcm);
1101 if (ret < 0) {
1102 printk(KERN_ERR "asoc: can't create pcm for codec %s\n",
1103 codec->name);
1104 kfree(rtd);
1105 return ret;
1106 }
1107
1108 dai_link->pcm = pcm;
1109 pcm->private_data = rtd;
1110 soc_pcm_ops.mmap = platform->pcm_ops->mmap;
1111 soc_pcm_ops.pointer = platform->pcm_ops->pointer;
1112 soc_pcm_ops.ioctl = platform->pcm_ops->ioctl;
1113 soc_pcm_ops.copy = platform->pcm_ops->copy;
1114 soc_pcm_ops.silence = platform->pcm_ops->silence;
1115 soc_pcm_ops.ack = platform->pcm_ops->ack;
1116 soc_pcm_ops.page = platform->pcm_ops->page;
1117
1118 if (playback)
1119 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops);
1120
1121 if (capture)
1122 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops);
1123
1124 ret = platform->pcm_new(codec->card, codec_dai, pcm);
1125 if (ret < 0) {
1126 printk(KERN_ERR "asoc: platform pcm constructor failed\n");
1127 kfree(rtd);
1128 return ret;
1129 }
1130
1131 pcm->private_free = platform->pcm_free;
1132 printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name,
1133 cpu_dai->name);
1134 return ret;
1135}
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145int snd_soc_codec_volatile_register(struct snd_soc_codec *codec, int reg)
1146{
1147 if (codec->volatile_register)
1148 return codec->volatile_register(reg);
1149 else
1150 return 0;
1151}
1152EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register);
1153
1154
1155static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf)
1156{
1157 int i, step = 1, count = 0;
1158
1159 if (!codec->reg_cache_size)
1160 return 0;
1161
1162 if (codec->reg_cache_step)
1163 step = codec->reg_cache_step;
1164
1165 count += sprintf(buf, "%s registers\n", codec->name);
1166 for (i = 0; i < codec->reg_cache_size; i += step) {
1167 if (codec->readable_register && !codec->readable_register(i))
1168 continue;
1169
1170 count += sprintf(buf + count, "%2x: ", i);
1171 if (count >= PAGE_SIZE - 1)
1172 break;
1173
1174 if (codec->display_register)
1175 count += codec->display_register(codec, buf + count,
1176 PAGE_SIZE - count, i);
1177 else
1178 count += snprintf(buf + count, PAGE_SIZE - count,
1179 "%4x", codec->read(codec, i));
1180
1181 if (count >= PAGE_SIZE - 1)
1182 break;
1183
1184 count += snprintf(buf + count, PAGE_SIZE - count, "\n");
1185 if (count >= PAGE_SIZE - 1)
1186 break;
1187 }
1188
1189
1190 if (count >= PAGE_SIZE)
1191 count = PAGE_SIZE - 1;
1192
1193 return count;
1194}
1195static ssize_t codec_reg_show(struct device *dev,
1196 struct device_attribute *attr, char *buf)
1197{
1198 struct snd_soc_device *devdata = dev_get_drvdata(dev);
1199 return soc_codec_reg_show(devdata->card->codec, buf);
1200}
1201
1202static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
1203
1204#ifdef CONFIG_DEBUG_FS
1205static int codec_reg_open_file(struct inode *inode, struct file *file)
1206{
1207 file->private_data = inode->i_private;
1208 return 0;
1209}
1210
1211static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
1212 size_t count, loff_t *ppos)
1213{
1214 ssize_t ret;
1215 struct snd_soc_codec *codec = file->private_data;
1216 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1217 if (!buf)
1218 return -ENOMEM;
1219 ret = soc_codec_reg_show(codec, buf);
1220 if (ret >= 0)
1221 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1222 kfree(buf);
1223 return ret;
1224}
1225
1226static ssize_t codec_reg_write_file(struct file *file,
1227 const char __user *user_buf, size_t count, loff_t *ppos)
1228{
1229 char buf[32];
1230 int buf_size;
1231 char *start = buf;
1232 unsigned long reg, value;
1233 int step = 1;
1234 struct snd_soc_codec *codec = file->private_data;
1235
1236 buf_size = min(count, (sizeof(buf)-1));
1237 if (copy_from_user(buf, user_buf, buf_size))
1238 return -EFAULT;
1239 buf[buf_size] = 0;
1240
1241 if (codec->reg_cache_step)
1242 step = codec->reg_cache_step;
1243
1244 while (*start == ' ')
1245 start++;
1246 reg = simple_strtoul(start, &start, 16);
1247 if ((reg >= codec->reg_cache_size) || (reg % step))
1248 return -EINVAL;
1249 while (*start == ' ')
1250 start++;
1251 if (strict_strtoul(start, 16, &value))
1252 return -EINVAL;
1253 codec->write(codec, reg, value);
1254 return buf_size;
1255}
1256
1257static const struct file_operations codec_reg_fops = {
1258 .open = codec_reg_open_file,
1259 .read = codec_reg_read_file,
1260 .write = codec_reg_write_file,
1261};
1262
1263static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
1264{
1265 codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
1266 debugfs_root, codec,
1267 &codec_reg_fops);
1268 if (!codec->debugfs_reg)
1269 printk(KERN_WARNING
1270 "ASoC: Failed to create codec register debugfs file\n");
1271
1272 codec->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0744,
1273 debugfs_root,
1274 &codec->pop_time);
1275 if (!codec->debugfs_pop_time)
1276 printk(KERN_WARNING
1277 "Failed to create pop time debugfs file\n");
1278
1279 codec->debugfs_dapm = debugfs_create_dir("dapm", debugfs_root);
1280 if (!codec->debugfs_dapm)
1281 printk(KERN_WARNING
1282 "Failed to create DAPM debugfs directory\n");
1283
1284 snd_soc_dapm_debugfs_init(codec);
1285}
1286
1287static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
1288{
1289 debugfs_remove_recursive(codec->debugfs_dapm);
1290 debugfs_remove(codec->debugfs_pop_time);
1291 debugfs_remove(codec->debugfs_reg);
1292}
1293
1294#else
1295
1296static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
1297{
1298}
1299
1300static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
1301{
1302}
1303#endif
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
1314 struct snd_ac97_bus_ops *ops, int num)
1315{
1316 mutex_lock(&codec->mutex);
1317
1318 codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
1319 if (codec->ac97 == NULL) {
1320 mutex_unlock(&codec->mutex);
1321 return -ENOMEM;
1322 }
1323
1324 codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
1325 if (codec->ac97->bus == NULL) {
1326 kfree(codec->ac97);
1327 codec->ac97 = NULL;
1328 mutex_unlock(&codec->mutex);
1329 return -ENOMEM;
1330 }
1331
1332 codec->ac97->bus->ops = ops;
1333 codec->ac97->num = num;
1334 mutex_unlock(&codec->mutex);
1335 return 0;
1336}
1337EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
1338
1339
1340
1341
1342
1343
1344
1345void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
1346{
1347 mutex_lock(&codec->mutex);
1348 kfree(codec->ac97->bus);
1349 kfree(codec->ac97);
1350 codec->ac97 = NULL;
1351 mutex_unlock(&codec->mutex);
1352}
1353EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
1367 unsigned int mask, unsigned int value)
1368{
1369 int change;
1370 unsigned int old, new;
1371
1372 mutex_lock(&io_mutex);
1373 old = snd_soc_read(codec, reg);
1374 new = (old & ~mask) | value;
1375 change = old != new;
1376 if (change)
1377 snd_soc_write(codec, reg, new);
1378
1379 mutex_unlock(&io_mutex);
1380 return change;
1381}
1382EXPORT_SYMBOL_GPL(snd_soc_update_bits);
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
1397 unsigned int mask, unsigned int value)
1398{
1399 int change;
1400 unsigned int old, new;
1401
1402 mutex_lock(&io_mutex);
1403 old = snd_soc_read(codec, reg);
1404 new = (old & ~mask) | value;
1405 change = old != new;
1406 mutex_unlock(&io_mutex);
1407
1408 return change;
1409}
1410EXPORT_SYMBOL_GPL(snd_soc_test_bits);
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid)
1423{
1424 struct snd_soc_card *card = socdev->card;
1425 struct snd_soc_codec *codec = card->codec;
1426 int ret, i;
1427
1428 mutex_lock(&codec->mutex);
1429
1430
1431 ret = snd_card_create(idx, xid, codec->owner, 0, &codec->card);
1432 if (ret < 0) {
1433 printk(KERN_ERR "asoc: can't create sound card for codec %s\n",
1434 codec->name);
1435 mutex_unlock(&codec->mutex);
1436 return ret;
1437 }
1438
1439 codec->socdev = socdev;
1440 codec->card->dev = socdev->dev;
1441 codec->card->private_data = codec;
1442 strncpy(codec->card->driver, codec->name, sizeof(codec->card->driver));
1443
1444
1445 for (i = 0; i < card->num_links; i++) {
1446 ret = soc_new_pcm(socdev, &card->dai_link[i], i);
1447 if (ret < 0) {
1448 printk(KERN_ERR "asoc: can't create pcm %s\n",
1449 card->dai_link[i].stream_name);
1450 mutex_unlock(&codec->mutex);
1451 return ret;
1452 }
1453 }
1454
1455 mutex_unlock(&codec->mutex);
1456 return ret;
1457}
1458EXPORT_SYMBOL_GPL(snd_soc_new_pcms);
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469int snd_soc_init_card(struct snd_soc_device *socdev)
1470{
1471 struct snd_soc_card *card = socdev->card;
1472 struct snd_soc_codec *codec = card->codec;
1473 int ret = 0, i, ac97 = 0, err = 0;
1474
1475 for (i = 0; i < card->num_links; i++) {
1476 if (card->dai_link[i].init) {
1477 err = card->dai_link[i].init(codec);
1478 if (err < 0) {
1479 printk(KERN_ERR "asoc: failed to init %s\n",
1480 card->dai_link[i].stream_name);
1481 continue;
1482 }
1483 }
1484 if (card->dai_link[i].codec_dai->ac97_control) {
1485 ac97 = 1;
1486 snd_ac97_dev_add_pdata(codec->ac97,
1487 card->dai_link[i].cpu_dai->ac97_pdata);
1488 }
1489 }
1490 snprintf(codec->card->shortname, sizeof(codec->card->shortname),
1491 "%s", card->name);
1492 snprintf(codec->card->longname, sizeof(codec->card->longname),
1493 "%s (%s)", card->name, codec->name);
1494
1495
1496 snd_soc_dapm_new_widgets(codec);
1497
1498 ret = snd_card_register(codec->card);
1499 if (ret < 0) {
1500 printk(KERN_ERR "asoc: failed to register soundcard for %s\n",
1501 codec->name);
1502 goto out;
1503 }
1504
1505 mutex_lock(&codec->mutex);
1506#ifdef CONFIG_SND_SOC_AC97_BUS
1507
1508
1509
1510 if (ac97 && strcmp(codec->name, "AC97") != 0) {
1511 ret = soc_ac97_dev_register(codec);
1512 if (ret < 0) {
1513 printk(KERN_ERR "asoc: AC97 device register failed\n");
1514 snd_card_free(codec->card);
1515 mutex_unlock(&codec->mutex);
1516 goto out;
1517 }
1518 }
1519#endif
1520
1521 err = snd_soc_dapm_sys_add(socdev->dev);
1522 if (err < 0)
1523 printk(KERN_WARNING "asoc: failed to add dapm sysfs entries\n");
1524
1525 err = device_create_file(socdev->dev, &dev_attr_codec_reg);
1526 if (err < 0)
1527 printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");
1528
1529 soc_init_codec_debugfs(codec);
1530 mutex_unlock(&codec->mutex);
1531
1532out:
1533 return ret;
1534}
1535EXPORT_SYMBOL_GPL(snd_soc_init_card);
1536
1537
1538
1539
1540
1541
1542
1543
1544void snd_soc_free_pcms(struct snd_soc_device *socdev)
1545{
1546 struct snd_soc_codec *codec = socdev->card->codec;
1547#ifdef CONFIG_SND_SOC_AC97_BUS
1548 struct snd_soc_dai *codec_dai;
1549 int i;
1550#endif
1551
1552 mutex_lock(&codec->mutex);
1553 soc_cleanup_codec_debugfs(codec);
1554#ifdef CONFIG_SND_SOC_AC97_BUS
1555 for (i = 0; i < codec->num_dai; i++) {
1556 codec_dai = &codec->dai[i];
1557 if (codec_dai->ac97_control && codec->ac97 &&
1558 strcmp(codec->name, "AC97") != 0) {
1559 soc_ac97_dev_unregister(codec);
1560 goto free_card;
1561 }
1562 }
1563free_card:
1564#endif
1565
1566 if (codec->card)
1567 snd_card_free(codec->card);
1568 device_remove_file(socdev->dev, &dev_attr_codec_reg);
1569 mutex_unlock(&codec->mutex);
1570}
1571EXPORT_SYMBOL_GPL(snd_soc_free_pcms);
1572
1573
1574
1575
1576
1577
1578
1579
1580int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
1581 const struct snd_pcm_hardware *hw)
1582{
1583 struct snd_pcm_runtime *runtime = substream->runtime;
1584 runtime->hw.info = hw->info;
1585 runtime->hw.formats = hw->formats;
1586 runtime->hw.period_bytes_min = hw->period_bytes_min;
1587 runtime->hw.period_bytes_max = hw->period_bytes_max;
1588 runtime->hw.periods_min = hw->periods_min;
1589 runtime->hw.periods_max = hw->periods_max;
1590 runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
1591 runtime->hw.fifo_size = hw->fifo_size;
1592 return 0;
1593}
1594EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
1607 void *data, char *long_name)
1608{
1609 struct snd_kcontrol_new template;
1610
1611 memcpy(&template, _template, sizeof(template));
1612 if (long_name)
1613 template.name = long_name;
1614 template.index = 0;
1615
1616 return snd_ctl_new1(&template, data);
1617}
1618EXPORT_SYMBOL_GPL(snd_soc_cnew);
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631int snd_soc_add_controls(struct snd_soc_codec *codec,
1632 const struct snd_kcontrol_new *controls, int num_controls)
1633{
1634 struct snd_card *card = codec->card;
1635 int err, i;
1636
1637 for (i = 0; i < num_controls; i++) {
1638 const struct snd_kcontrol_new *control = &controls[i];
1639 err = snd_ctl_add(card, snd_soc_cnew(control, codec, NULL));
1640 if (err < 0) {
1641 dev_err(codec->dev, "%s: Failed to add %s\n",
1642 codec->name, control->name);
1643 return err;
1644 }
1645 }
1646
1647 return 0;
1648}
1649EXPORT_SYMBOL_GPL(snd_soc_add_controls);
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
1662 struct snd_ctl_elem_info *uinfo)
1663{
1664 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1665
1666 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1667 uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
1668 uinfo->value.enumerated.items = e->max;
1669
1670 if (uinfo->value.enumerated.item > e->max - 1)
1671 uinfo->value.enumerated.item = e->max - 1;
1672 strcpy(uinfo->value.enumerated.name,
1673 e->texts[uinfo->value.enumerated.item]);
1674 return 0;
1675}
1676EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
1688 struct snd_ctl_elem_value *ucontrol)
1689{
1690 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1691 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1692 unsigned int val, bitmask;
1693
1694 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
1695 ;
1696 val = snd_soc_read(codec, e->reg);
1697 ucontrol->value.enumerated.item[0]
1698 = (val >> e->shift_l) & (bitmask - 1);
1699 if (e->shift_l != e->shift_r)
1700 ucontrol->value.enumerated.item[1] =
1701 (val >> e->shift_r) & (bitmask - 1);
1702
1703 return 0;
1704}
1705EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
1717 struct snd_ctl_elem_value *ucontrol)
1718{
1719 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1720 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1721 unsigned int val;
1722 unsigned int mask, bitmask;
1723
1724 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
1725 ;
1726 if (ucontrol->value.enumerated.item[0] > e->max - 1)
1727 return -EINVAL;
1728 val = ucontrol->value.enumerated.item[0] << e->shift_l;
1729 mask = (bitmask - 1) << e->shift_l;
1730 if (e->shift_l != e->shift_r) {
1731 if (ucontrol->value.enumerated.item[1] > e->max - 1)
1732 return -EINVAL;
1733 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1734 mask |= (bitmask - 1) << e->shift_r;
1735 }
1736
1737 return snd_soc_update_bits(codec, e->reg, mask, val);
1738}
1739EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
1754 struct snd_ctl_elem_value *ucontrol)
1755{
1756 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1757 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1758 unsigned int reg_val, val, mux;
1759
1760 reg_val = snd_soc_read(codec, e->reg);
1761 val = (reg_val >> e->shift_l) & e->mask;
1762 for (mux = 0; mux < e->max; mux++) {
1763 if (val == e->values[mux])
1764 break;
1765 }
1766 ucontrol->value.enumerated.item[0] = mux;
1767 if (e->shift_l != e->shift_r) {
1768 val = (reg_val >> e->shift_r) & e->mask;
1769 for (mux = 0; mux < e->max; mux++) {
1770 if (val == e->values[mux])
1771 break;
1772 }
1773 ucontrol->value.enumerated.item[1] = mux;
1774 }
1775
1776 return 0;
1777}
1778EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double);
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
1793 struct snd_ctl_elem_value *ucontrol)
1794{
1795 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1796 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1797 unsigned int val;
1798 unsigned int mask;
1799
1800 if (ucontrol->value.enumerated.item[0] > e->max - 1)
1801 return -EINVAL;
1802 val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
1803 mask = e->mask << e->shift_l;
1804 if (e->shift_l != e->shift_r) {
1805 if (ucontrol->value.enumerated.item[1] > e->max - 1)
1806 return -EINVAL;
1807 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
1808 mask |= e->mask << e->shift_r;
1809 }
1810
1811 return snd_soc_update_bits(codec, e->reg, mask, val);
1812}
1813EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double);
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
1826 struct snd_ctl_elem_info *uinfo)
1827{
1828 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1829
1830 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1831 uinfo->count = 1;
1832 uinfo->value.enumerated.items = e->max;
1833
1834 if (uinfo->value.enumerated.item > e->max - 1)
1835 uinfo->value.enumerated.item = e->max - 1;
1836 strcpy(uinfo->value.enumerated.name,
1837 e->texts[uinfo->value.enumerated.item]);
1838 return 0;
1839}
1840EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
1852 struct snd_ctl_elem_info *uinfo)
1853{
1854 int max = kcontrol->private_value;
1855
1856 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
1857 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1858 else
1859 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1860
1861 uinfo->count = 1;
1862 uinfo->value.integer.min = 0;
1863 uinfo->value.integer.max = max;
1864 return 0;
1865}
1866EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
1878 struct snd_ctl_elem_info *uinfo)
1879{
1880 struct soc_mixer_control *mc =
1881 (struct soc_mixer_control *)kcontrol->private_value;
1882 int max = mc->max;
1883 unsigned int shift = mc->shift;
1884 unsigned int rshift = mc->rshift;
1885
1886 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
1887 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1888 else
1889 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1890
1891 uinfo->count = shift == rshift ? 1 : 2;
1892 uinfo->value.integer.min = 0;
1893 uinfo->value.integer.max = max;
1894 return 0;
1895}
1896EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
1908 struct snd_ctl_elem_value *ucontrol)
1909{
1910 struct soc_mixer_control *mc =
1911 (struct soc_mixer_control *)kcontrol->private_value;
1912 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1913 unsigned int reg = mc->reg;
1914 unsigned int shift = mc->shift;
1915 unsigned int rshift = mc->rshift;
1916 int max = mc->max;
1917 unsigned int mask = (1 << fls(max)) - 1;
1918 unsigned int invert = mc->invert;
1919
1920 ucontrol->value.integer.value[0] =
1921 (snd_soc_read(codec, reg) >> shift) & mask;
1922 if (shift != rshift)
1923 ucontrol->value.integer.value[1] =
1924 (snd_soc_read(codec, reg) >> rshift) & mask;
1925 if (invert) {
1926 ucontrol->value.integer.value[0] =
1927 max - ucontrol->value.integer.value[0];
1928 if (shift != rshift)
1929 ucontrol->value.integer.value[1] =
1930 max - ucontrol->value.integer.value[1];
1931 }
1932
1933 return 0;
1934}
1935EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
1947 struct snd_ctl_elem_value *ucontrol)
1948{
1949 struct soc_mixer_control *mc =
1950 (struct soc_mixer_control *)kcontrol->private_value;
1951 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1952 unsigned int reg = mc->reg;
1953 unsigned int shift = mc->shift;
1954 unsigned int rshift = mc->rshift;
1955 int max = mc->max;
1956 unsigned int mask = (1 << fls(max)) - 1;
1957 unsigned int invert = mc->invert;
1958 unsigned int val, val2, val_mask;
1959
1960 val = (ucontrol->value.integer.value[0] & mask);
1961 if (invert)
1962 val = max - val;
1963 val_mask = mask << shift;
1964 val = val << shift;
1965 if (shift != rshift) {
1966 val2 = (ucontrol->value.integer.value[1] & mask);
1967 if (invert)
1968 val2 = max - val2;
1969 val_mask |= mask << rshift;
1970 val |= val2 << rshift;
1971 }
1972 return snd_soc_update_bits(codec, reg, val_mask, val);
1973}
1974EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
1987 struct snd_ctl_elem_info *uinfo)
1988{
1989 struct soc_mixer_control *mc =
1990 (struct soc_mixer_control *)kcontrol->private_value;
1991 int max = mc->max;
1992
1993 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
1994 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1995 else
1996 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1997
1998 uinfo->count = 2;
1999 uinfo->value.integer.min = 0;
2000 uinfo->value.integer.max = max;
2001 return 0;
2002}
2003EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
2015 struct snd_ctl_elem_value *ucontrol)
2016{
2017 struct soc_mixer_control *mc =
2018 (struct soc_mixer_control *)kcontrol->private_value;
2019 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2020 unsigned int reg = mc->reg;
2021 unsigned int reg2 = mc->rreg;
2022 unsigned int shift = mc->shift;
2023 int max = mc->max;
2024 unsigned int mask = (1 << fls(max)) - 1;
2025 unsigned int invert = mc->invert;
2026
2027 ucontrol->value.integer.value[0] =
2028 (snd_soc_read(codec, reg) >> shift) & mask;
2029 ucontrol->value.integer.value[1] =
2030 (snd_soc_read(codec, reg2) >> shift) & mask;
2031 if (invert) {
2032 ucontrol->value.integer.value[0] =
2033 max - ucontrol->value.integer.value[0];
2034 ucontrol->value.integer.value[1] =
2035 max - ucontrol->value.integer.value[1];
2036 }
2037
2038 return 0;
2039}
2040EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r);
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
2052 struct snd_ctl_elem_value *ucontrol)
2053{
2054 struct soc_mixer_control *mc =
2055 (struct soc_mixer_control *)kcontrol->private_value;
2056 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2057 unsigned int reg = mc->reg;
2058 unsigned int reg2 = mc->rreg;
2059 unsigned int shift = mc->shift;
2060 int max = mc->max;
2061 unsigned int mask = (1 << fls(max)) - 1;
2062 unsigned int invert = mc->invert;
2063 int err;
2064 unsigned int val, val2, val_mask;
2065
2066 val_mask = mask << shift;
2067 val = (ucontrol->value.integer.value[0] & mask);
2068 val2 = (ucontrol->value.integer.value[1] & mask);
2069
2070 if (invert) {
2071 val = max - val;
2072 val2 = max - val2;
2073 }
2074
2075 val = val << shift;
2076 val2 = val2 << shift;
2077
2078 err = snd_soc_update_bits(codec, reg, val_mask, val);
2079 if (err < 0)
2080 return err;
2081
2082 err = snd_soc_update_bits(codec, reg2, val_mask, val2);
2083 return err;
2084}
2085EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
2097 struct snd_ctl_elem_info *uinfo)
2098{
2099 struct soc_mixer_control *mc =
2100 (struct soc_mixer_control *)kcontrol->private_value;
2101 int max = mc->max;
2102 int min = mc->min;
2103
2104 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2105 uinfo->count = 2;
2106 uinfo->value.integer.min = 0;
2107 uinfo->value.integer.max = max-min;
2108 return 0;
2109}
2110EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
2122 struct snd_ctl_elem_value *ucontrol)
2123{
2124 struct soc_mixer_control *mc =
2125 (struct soc_mixer_control *)kcontrol->private_value;
2126 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2127 unsigned int reg = mc->reg;
2128 int min = mc->min;
2129 int val = snd_soc_read(codec, reg);
2130
2131 ucontrol->value.integer.value[0] =
2132 ((signed char)(val & 0xff))-min;
2133 ucontrol->value.integer.value[1] =
2134 ((signed char)((val >> 8) & 0xff))-min;
2135 return 0;
2136}
2137EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
2149 struct snd_ctl_elem_value *ucontrol)
2150{
2151 struct soc_mixer_control *mc =
2152 (struct soc_mixer_control *)kcontrol->private_value;
2153 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2154 unsigned int reg = mc->reg;
2155 int min = mc->min;
2156 unsigned int val;
2157
2158 val = (ucontrol->value.integer.value[0]+min) & 0xff;
2159 val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
2160
2161 return snd_soc_update_bits(codec, reg, 0xffff, val);
2162}
2163EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2175 unsigned int freq, int dir)
2176{
2177 if (dai->ops && dai->ops->set_sysclk)
2178 return dai->ops->set_sysclk(dai, clk_id, freq, dir);
2179 else
2180 return -EINVAL;
2181}
2182EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2195 int div_id, int div)
2196{
2197 if (dai->ops && dai->ops->set_clkdiv)
2198 return dai->ops->set_clkdiv(dai, div_id, div);
2199 else
2200 return -EINVAL;
2201}
2202EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213int snd_soc_dai_set_pll(struct snd_soc_dai *dai,
2214 int pll_id, unsigned int freq_in, unsigned int freq_out)
2215{
2216 if (dai->ops && dai->ops->set_pll)
2217 return dai->ops->set_pll(dai, pll_id, freq_in, freq_out);
2218 else
2219 return -EINVAL;
2220}
2221EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
2222
2223
2224
2225
2226
2227
2228
2229
2230int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2231{
2232 if (dai->ops && dai->ops->set_fmt)
2233 return dai->ops->set_fmt(dai, fmt);
2234 else
2235 return -EINVAL;
2236}
2237EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
2251 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
2252{
2253 if (dai->ops && dai->ops->set_tdm_slot)
2254 return dai->ops->set_tdm_slot(dai, tx_mask, rx_mask,
2255 slots, slot_width);
2256 else
2257 return -EINVAL;
2258}
2259EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
2260
2261
2262
2263
2264
2265
2266
2267
2268int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
2269{
2270 if (dai->ops && dai->ops->set_tristate)
2271 return dai->ops->set_tristate(dai, tristate);
2272 else
2273 return -EINVAL;
2274}
2275EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
2276
2277
2278
2279
2280
2281
2282
2283
2284int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
2285{
2286 if (dai->ops && dai->ops->digital_mute)
2287 return dai->ops->digital_mute(dai, mute);
2288 else
2289 return -EINVAL;
2290}
2291EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302static int snd_soc_register_card(struct snd_soc_card *card)
2303{
2304 if (!card->name || !card->dev)
2305 return -EINVAL;
2306
2307 INIT_LIST_HEAD(&card->list);
2308 card->instantiated = 0;
2309
2310 mutex_lock(&client_mutex);
2311 list_add(&card->list, &card_list);
2312 snd_soc_instantiate_cards();
2313 mutex_unlock(&client_mutex);
2314
2315 dev_dbg(card->dev, "Registered card '%s'\n", card->name);
2316
2317 return 0;
2318}
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329static int snd_soc_unregister_card(struct snd_soc_card *card)
2330{
2331 mutex_lock(&client_mutex);
2332 list_del(&card->list);
2333 mutex_unlock(&client_mutex);
2334
2335 dev_dbg(card->dev, "Unregistered card '%s'\n", card->name);
2336
2337 return 0;
2338}
2339
2340
2341
2342
2343
2344
2345int snd_soc_register_dai(struct snd_soc_dai *dai)
2346{
2347 if (!dai->name)
2348 return -EINVAL;
2349
2350
2351 if (!dai->dev)
2352 printk(KERN_WARNING "No device for DAI %s\n", dai->name);
2353
2354 if (!dai->ops)
2355 dai->ops = &null_dai_ops;
2356
2357 INIT_LIST_HEAD(&dai->list);
2358
2359 mutex_lock(&client_mutex);
2360 list_add(&dai->list, &dai_list);
2361 snd_soc_instantiate_cards();
2362 mutex_unlock(&client_mutex);
2363
2364 pr_debug("Registered DAI '%s'\n", dai->name);
2365
2366 return 0;
2367}
2368EXPORT_SYMBOL_GPL(snd_soc_register_dai);
2369
2370
2371
2372
2373
2374
2375void snd_soc_unregister_dai(struct snd_soc_dai *dai)
2376{
2377 mutex_lock(&client_mutex);
2378 list_del(&dai->list);
2379 mutex_unlock(&client_mutex);
2380
2381 pr_debug("Unregistered DAI '%s'\n", dai->name);
2382}
2383EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);
2384
2385
2386
2387
2388
2389
2390
2391int snd_soc_register_dais(struct snd_soc_dai *dai, size_t count)
2392{
2393 int i, ret;
2394
2395 for (i = 0; i < count; i++) {
2396 ret = snd_soc_register_dai(&dai[i]);
2397 if (ret != 0)
2398 goto err;
2399 }
2400
2401 return 0;
2402
2403err:
2404 for (i--; i >= 0; i--)
2405 snd_soc_unregister_dai(&dai[i]);
2406
2407 return ret;
2408}
2409EXPORT_SYMBOL_GPL(snd_soc_register_dais);
2410
2411
2412
2413
2414
2415
2416
2417void snd_soc_unregister_dais(struct snd_soc_dai *dai, size_t count)
2418{
2419 int i;
2420
2421 for (i = 0; i < count; i++)
2422 snd_soc_unregister_dai(&dai[i]);
2423}
2424EXPORT_SYMBOL_GPL(snd_soc_unregister_dais);
2425
2426
2427
2428
2429
2430
2431int snd_soc_register_platform(struct snd_soc_platform *platform)
2432{
2433 if (!platform->name)
2434 return -EINVAL;
2435
2436 INIT_LIST_HEAD(&platform->list);
2437
2438 mutex_lock(&client_mutex);
2439 list_add(&platform->list, &platform_list);
2440 snd_soc_instantiate_cards();
2441 mutex_unlock(&client_mutex);
2442
2443 pr_debug("Registered platform '%s'\n", platform->name);
2444
2445 return 0;
2446}
2447EXPORT_SYMBOL_GPL(snd_soc_register_platform);
2448
2449
2450
2451
2452
2453
2454void snd_soc_unregister_platform(struct snd_soc_platform *platform)
2455{
2456 mutex_lock(&client_mutex);
2457 list_del(&platform->list);
2458 mutex_unlock(&client_mutex);
2459
2460 pr_debug("Unregistered platform '%s'\n", platform->name);
2461}
2462EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
2463
2464static u64 codec_format_map[] = {
2465 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
2466 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
2467 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
2468 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
2469 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
2470 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
2471 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
2472 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
2473 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
2474 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
2475 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
2476 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
2477 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
2478 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
2479 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
2480 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
2481};
2482
2483
2484
2485
2486
2487
2488static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
2489{
2490 int i;
2491
2492 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
2493 if (stream->formats & codec_format_map[i])
2494 stream->formats |= codec_format_map[i];
2495}
2496
2497
2498
2499
2500
2501
2502int snd_soc_register_codec(struct snd_soc_codec *codec)
2503{
2504 int i;
2505
2506 if (!codec->name)
2507 return -EINVAL;
2508
2509
2510 if (!codec->dev)
2511 printk(KERN_WARNING "No device for codec %s\n", codec->name);
2512
2513 INIT_LIST_HEAD(&codec->list);
2514
2515 for (i = 0; i < codec->num_dai; i++) {
2516 fixup_codec_formats(&codec->dai[i].playback);
2517 fixup_codec_formats(&codec->dai[i].capture);
2518 }
2519
2520 mutex_lock(&client_mutex);
2521 list_add(&codec->list, &codec_list);
2522 snd_soc_instantiate_cards();
2523 mutex_unlock(&client_mutex);
2524
2525 pr_debug("Registered codec '%s'\n", codec->name);
2526
2527 return 0;
2528}
2529EXPORT_SYMBOL_GPL(snd_soc_register_codec);
2530
2531
2532
2533
2534
2535
2536void snd_soc_unregister_codec(struct snd_soc_codec *codec)
2537{
2538 mutex_lock(&client_mutex);
2539 list_del(&codec->list);
2540 mutex_unlock(&client_mutex);
2541
2542 pr_debug("Unregistered codec '%s'\n", codec->name);
2543}
2544EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
2545
2546static int __init snd_soc_init(void)
2547{
2548#ifdef CONFIG_DEBUG_FS
2549 debugfs_root = debugfs_create_dir("asoc", NULL);
2550 if (IS_ERR(debugfs_root) || !debugfs_root) {
2551 printk(KERN_WARNING
2552 "ASoC: Failed to create debugfs directory\n");
2553 debugfs_root = NULL;
2554 }
2555#endif
2556
2557 return platform_driver_register(&soc_driver);
2558}
2559
2560static void __exit snd_soc_exit(void)
2561{
2562#ifdef CONFIG_DEBUG_FS
2563 debugfs_remove_recursive(debugfs_root);
2564#endif
2565 platform_driver_unregister(&soc_driver);
2566}
2567
2568module_init(snd_soc_init);
2569module_exit(snd_soc_exit);
2570
2571
2572MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
2573MODULE_DESCRIPTION("ALSA SoC Core");
2574MODULE_LICENSE("GPL");
2575MODULE_ALIAS("platform:soc-audio");
2576