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