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