1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // soc-component.c
4 //
5 // Copyright 2009-2011 Wolfson Microelectronics PLC.
6 // Copyright (C) 2019 Renesas Electronics Corp.
7 //
8 // Mark Brown <broonie@opensource.wolfsonmicro.com>
9 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
10 //
11 #include <linux/module.h>
12 #include <linux/pm_runtime.h>
13 #include <sound/soc.h>
14 #include <linux/bitops.h>
15 
16 #define soc_component_ret(dai, ret) _soc_component_ret(dai, __func__, ret, -1)
17 #define soc_component_ret_reg_rw(dai, ret, reg) _soc_component_ret(dai, __func__, ret, reg)
_soc_component_ret(struct snd_soc_component * component,const char * func,int ret,int reg)18 static inline int _soc_component_ret(struct snd_soc_component *component,
19 				     const char *func, int ret, int reg)
20 {
21 	/* Positive/Zero values are not errors */
22 	if (ret >= 0)
23 		return ret;
24 
25 	/* Negative values might be errors */
26 	switch (ret) {
27 	case -EPROBE_DEFER:
28 	case -ENOTSUPP:
29 		break;
30 	default:
31 		if (reg == -1)
32 			dev_err(component->dev,
33 				"ASoC: error at %s on %s: %d\n",
34 				func, component->name, ret);
35 		else
36 			dev_err(component->dev,
37 				"ASoC: error at %s on %s for register: [0x%08x] %d\n",
38 				func, component->name, reg, ret);
39 	}
40 
41 	return ret;
42 }
43 
soc_component_field_shift(struct snd_soc_component * component,unsigned int mask)44 static inline int soc_component_field_shift(struct snd_soc_component *component,
45 					    unsigned int mask)
46 {
47 	if (!mask) {
48 		dev_err(component->dev,	"ASoC: error field mask is zero for %s\n",
49 			component->name);
50 		return 0;
51 	}
52 
53 	return (ffs(mask) - 1);
54 }
55 
56 /*
57  * We might want to check substream by using list.
58  * In such case, we can update these macros.
59  */
60 #define soc_component_mark_push(component, substream, tgt)	((component)->mark_##tgt = substream)
61 #define soc_component_mark_pop(component, substream, tgt)	((component)->mark_##tgt = NULL)
62 #define soc_component_mark_match(component, substream, tgt)	((component)->mark_##tgt == substream)
63 
snd_soc_component_set_aux(struct snd_soc_component * component,struct snd_soc_aux_dev * aux)64 void snd_soc_component_set_aux(struct snd_soc_component *component,
65 			       struct snd_soc_aux_dev *aux)
66 {
67 	component->init = (aux) ? aux->init : NULL;
68 }
69 
snd_soc_component_init(struct snd_soc_component * component)70 int snd_soc_component_init(struct snd_soc_component *component)
71 {
72 	int ret = 0;
73 
74 	if (component->init)
75 		ret = component->init(component);
76 
77 	return soc_component_ret(component, ret);
78 }
79 
80 /**
81  * snd_soc_component_set_sysclk - configure COMPONENT system or master clock.
82  * @component: COMPONENT
83  * @clk_id: DAI specific clock ID
84  * @source: Source for the clock
85  * @freq: new clock frequency in Hz
86  * @dir: new clock direction - input/output.
87  *
88  * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
89  */
snd_soc_component_set_sysclk(struct snd_soc_component * component,int clk_id,int source,unsigned int freq,int dir)90 int snd_soc_component_set_sysclk(struct snd_soc_component *component,
91 				 int clk_id, int source, unsigned int freq,
92 				 int dir)
93 {
94 	int ret = -ENOTSUPP;
95 
96 	if (component->driver->set_sysclk)
97 		ret = component->driver->set_sysclk(component, clk_id, source,
98 						     freq, dir);
99 
100 	return soc_component_ret(component, ret);
101 }
102 EXPORT_SYMBOL_GPL(snd_soc_component_set_sysclk);
103 
104 /*
105  * snd_soc_component_set_pll - configure component PLL.
106  * @component: COMPONENT
107  * @pll_id: DAI specific PLL ID
108  * @source: DAI specific source for the PLL
109  * @freq_in: PLL input clock frequency in Hz
110  * @freq_out: requested PLL output clock frequency in Hz
111  *
112  * Configures and enables PLL to generate output clock based on input clock.
113  */
snd_soc_component_set_pll(struct snd_soc_component * component,int pll_id,int source,unsigned int freq_in,unsigned int freq_out)114 int snd_soc_component_set_pll(struct snd_soc_component *component, int pll_id,
115 			      int source, unsigned int freq_in,
116 			      unsigned int freq_out)
117 {
118 	int ret = -EINVAL;
119 
120 	if (component->driver->set_pll)
121 		ret = component->driver->set_pll(component, pll_id, source,
122 						  freq_in, freq_out);
123 
124 	return soc_component_ret(component, ret);
125 }
126 EXPORT_SYMBOL_GPL(snd_soc_component_set_pll);
127 
snd_soc_component_seq_notifier(struct snd_soc_component * component,enum snd_soc_dapm_type type,int subseq)128 void snd_soc_component_seq_notifier(struct snd_soc_component *component,
129 				    enum snd_soc_dapm_type type, int subseq)
130 {
131 	if (component->driver->seq_notifier)
132 		component->driver->seq_notifier(component, type, subseq);
133 }
134 
snd_soc_component_stream_event(struct snd_soc_component * component,int event)135 int snd_soc_component_stream_event(struct snd_soc_component *component,
136 				   int event)
137 {
138 	int ret = 0;
139 
140 	if (component->driver->stream_event)
141 		ret = component->driver->stream_event(component, event);
142 
143 	return soc_component_ret(component, ret);
144 }
145 
snd_soc_component_set_bias_level(struct snd_soc_component * component,enum snd_soc_bias_level level)146 int snd_soc_component_set_bias_level(struct snd_soc_component *component,
147 				     enum snd_soc_bias_level level)
148 {
149 	int ret = 0;
150 
151 	if (component->driver->set_bias_level)
152 		ret = component->driver->set_bias_level(component, level);
153 
154 	return soc_component_ret(component, ret);
155 }
156 
snd_soc_component_enable_pin(struct snd_soc_component * component,const char * pin)157 int snd_soc_component_enable_pin(struct snd_soc_component *component,
158 				 const char *pin)
159 {
160 	struct snd_soc_dapm_context *dapm =
161 		snd_soc_component_get_dapm(component);
162 	return snd_soc_dapm_enable_pin(dapm, pin);
163 }
164 EXPORT_SYMBOL_GPL(snd_soc_component_enable_pin);
165 
snd_soc_component_enable_pin_unlocked(struct snd_soc_component * component,const char * pin)166 int snd_soc_component_enable_pin_unlocked(struct snd_soc_component *component,
167 					  const char *pin)
168 {
169 	struct snd_soc_dapm_context *dapm =
170 		snd_soc_component_get_dapm(component);
171 	return snd_soc_dapm_enable_pin_unlocked(dapm, pin);
172 }
173 EXPORT_SYMBOL_GPL(snd_soc_component_enable_pin_unlocked);
174 
snd_soc_component_disable_pin(struct snd_soc_component * component,const char * pin)175 int snd_soc_component_disable_pin(struct snd_soc_component *component,
176 				  const char *pin)
177 {
178 	struct snd_soc_dapm_context *dapm =
179 		snd_soc_component_get_dapm(component);
180 	return snd_soc_dapm_disable_pin(dapm, pin);
181 }
182 EXPORT_SYMBOL_GPL(snd_soc_component_disable_pin);
183 
snd_soc_component_disable_pin_unlocked(struct snd_soc_component * component,const char * pin)184 int snd_soc_component_disable_pin_unlocked(struct snd_soc_component *component,
185 					   const char *pin)
186 {
187 	struct snd_soc_dapm_context *dapm =
188 		snd_soc_component_get_dapm(component);
189 	return snd_soc_dapm_disable_pin_unlocked(dapm, pin);
190 }
191 EXPORT_SYMBOL_GPL(snd_soc_component_disable_pin_unlocked);
192 
snd_soc_component_nc_pin(struct snd_soc_component * component,const char * pin)193 int snd_soc_component_nc_pin(struct snd_soc_component *component,
194 			     const char *pin)
195 {
196 	struct snd_soc_dapm_context *dapm =
197 		snd_soc_component_get_dapm(component);
198 	return snd_soc_dapm_nc_pin(dapm, pin);
199 }
200 EXPORT_SYMBOL_GPL(snd_soc_component_nc_pin);
201 
snd_soc_component_nc_pin_unlocked(struct snd_soc_component * component,const char * pin)202 int snd_soc_component_nc_pin_unlocked(struct snd_soc_component *component,
203 				      const char *pin)
204 {
205 	struct snd_soc_dapm_context *dapm =
206 		snd_soc_component_get_dapm(component);
207 	return snd_soc_dapm_nc_pin_unlocked(dapm, pin);
208 }
209 EXPORT_SYMBOL_GPL(snd_soc_component_nc_pin_unlocked);
210 
snd_soc_component_get_pin_status(struct snd_soc_component * component,const char * pin)211 int snd_soc_component_get_pin_status(struct snd_soc_component *component,
212 				     const char *pin)
213 {
214 	struct snd_soc_dapm_context *dapm =
215 		snd_soc_component_get_dapm(component);
216 	return snd_soc_dapm_get_pin_status(dapm, pin);
217 }
218 EXPORT_SYMBOL_GPL(snd_soc_component_get_pin_status);
219 
snd_soc_component_force_enable_pin(struct snd_soc_component * component,const char * pin)220 int snd_soc_component_force_enable_pin(struct snd_soc_component *component,
221 				       const char *pin)
222 {
223 	struct snd_soc_dapm_context *dapm =
224 		snd_soc_component_get_dapm(component);
225 	return snd_soc_dapm_force_enable_pin(dapm, pin);
226 }
227 EXPORT_SYMBOL_GPL(snd_soc_component_force_enable_pin);
228 
snd_soc_component_force_enable_pin_unlocked(struct snd_soc_component * component,const char * pin)229 int snd_soc_component_force_enable_pin_unlocked(
230 	struct snd_soc_component *component,
231 	const char *pin)
232 {
233 	struct snd_soc_dapm_context *dapm =
234 		snd_soc_component_get_dapm(component);
235 	return snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
236 }
237 EXPORT_SYMBOL_GPL(snd_soc_component_force_enable_pin_unlocked);
238 
239 /**
240  * snd_soc_component_set_jack - configure component jack.
241  * @component: COMPONENTs
242  * @jack: structure to use for the jack
243  * @data: can be used if codec driver need extra data for configuring jack
244  *
245  * Configures and enables jack detection function.
246  */
snd_soc_component_set_jack(struct snd_soc_component * component,struct snd_soc_jack * jack,void * data)247 int snd_soc_component_set_jack(struct snd_soc_component *component,
248 			       struct snd_soc_jack *jack, void *data)
249 {
250 	int ret = -ENOTSUPP;
251 
252 	if (component->driver->set_jack)
253 		ret = component->driver->set_jack(component, jack, data);
254 
255 	return soc_component_ret(component, ret);
256 }
257 EXPORT_SYMBOL_GPL(snd_soc_component_set_jack);
258 
snd_soc_component_module_get(struct snd_soc_component * component,void * mark,int upon_open)259 int snd_soc_component_module_get(struct snd_soc_component *component,
260 				 void *mark, int upon_open)
261 {
262 	int ret = 0;
263 
264 	if (component->driver->module_get_upon_open == !!upon_open &&
265 	    !try_module_get(component->dev->driver->owner))
266 		ret = -ENODEV;
267 
268 	/* mark module if succeeded */
269 	if (ret == 0)
270 		soc_component_mark_push(component, mark, module);
271 
272 	return soc_component_ret(component, ret);
273 }
274 
snd_soc_component_module_put(struct snd_soc_component * component,void * mark,int upon_open,int rollback)275 void snd_soc_component_module_put(struct snd_soc_component *component,
276 				  void *mark, int upon_open, int rollback)
277 {
278 	if (rollback && !soc_component_mark_match(component, mark, module))
279 		return;
280 
281 	if (component->driver->module_get_upon_open == !!upon_open)
282 		module_put(component->dev->driver->owner);
283 
284 	/* remove the mark from module */
285 	soc_component_mark_pop(component, mark, module);
286 }
287 
snd_soc_component_open(struct snd_soc_component * component,struct snd_pcm_substream * substream)288 int snd_soc_component_open(struct snd_soc_component *component,
289 			   struct snd_pcm_substream *substream)
290 {
291 	int ret = 0;
292 
293 	if (component->driver->open)
294 		ret = component->driver->open(component, substream);
295 
296 	/* mark substream if succeeded */
297 	if (ret == 0)
298 		soc_component_mark_push(component, substream, open);
299 
300 	return soc_component_ret(component, ret);
301 }
302 
snd_soc_component_close(struct snd_soc_component * component,struct snd_pcm_substream * substream,int rollback)303 int snd_soc_component_close(struct snd_soc_component *component,
304 			    struct snd_pcm_substream *substream,
305 			    int rollback)
306 {
307 	int ret = 0;
308 
309 	if (rollback && !soc_component_mark_match(component, substream, open))
310 		return 0;
311 
312 	if (component->driver->close)
313 		ret = component->driver->close(component, substream);
314 
315 	/* remove marked substream */
316 	soc_component_mark_pop(component, substream, open);
317 
318 	return soc_component_ret(component, ret);
319 }
320 
snd_soc_component_suspend(struct snd_soc_component * component)321 void snd_soc_component_suspend(struct snd_soc_component *component)
322 {
323 	if (component->driver->suspend)
324 		component->driver->suspend(component);
325 	component->suspended = 1;
326 }
327 
snd_soc_component_resume(struct snd_soc_component * component)328 void snd_soc_component_resume(struct snd_soc_component *component)
329 {
330 	if (component->driver->resume)
331 		component->driver->resume(component);
332 	component->suspended = 0;
333 }
334 
snd_soc_component_is_suspended(struct snd_soc_component * component)335 int snd_soc_component_is_suspended(struct snd_soc_component *component)
336 {
337 	return component->suspended;
338 }
339 
snd_soc_component_probe(struct snd_soc_component * component)340 int snd_soc_component_probe(struct snd_soc_component *component)
341 {
342 	int ret = 0;
343 
344 	if (component->driver->probe)
345 		ret = component->driver->probe(component);
346 
347 	return soc_component_ret(component, ret);
348 }
349 
snd_soc_component_remove(struct snd_soc_component * component)350 void snd_soc_component_remove(struct snd_soc_component *component)
351 {
352 	if (component->driver->remove)
353 		component->driver->remove(component);
354 }
355 
snd_soc_component_of_xlate_dai_id(struct snd_soc_component * component,struct device_node * ep)356 int snd_soc_component_of_xlate_dai_id(struct snd_soc_component *component,
357 				      struct device_node *ep)
358 {
359 	int ret = -ENOTSUPP;
360 
361 	if (component->driver->of_xlate_dai_id)
362 		ret = component->driver->of_xlate_dai_id(component, ep);
363 
364 	return soc_component_ret(component, ret);
365 }
366 
snd_soc_component_of_xlate_dai_name(struct snd_soc_component * component,const struct of_phandle_args * args,const char ** dai_name)367 int snd_soc_component_of_xlate_dai_name(struct snd_soc_component *component,
368 					const struct of_phandle_args *args,
369 					const char **dai_name)
370 {
371 	if (component->driver->of_xlate_dai_name)
372 		return component->driver->of_xlate_dai_name(component,
373 							    args, dai_name);
374 	/*
375 	 * Don't use soc_component_ret here because we may not want to report
376 	 * the error just yet. If a device has more than one component, the
377 	 * first may not match and we don't want spam the log with this.
378 	 */
379 	return -ENOTSUPP;
380 }
381 
snd_soc_component_setup_regmap(struct snd_soc_component * component)382 void snd_soc_component_setup_regmap(struct snd_soc_component *component)
383 {
384 	int val_bytes = regmap_get_val_bytes(component->regmap);
385 
386 	/* Errors are legitimate for non-integer byte multiples */
387 	if (val_bytes > 0)
388 		component->val_bytes = val_bytes;
389 }
390 
391 #ifdef CONFIG_REGMAP
392 
393 /**
394  * snd_soc_component_init_regmap() - Initialize regmap instance for the
395  *                                   component
396  * @component: The component for which to initialize the regmap instance
397  * @regmap: The regmap instance that should be used by the component
398  *
399  * This function allows deferred assignment of the regmap instance that is
400  * associated with the component. Only use this if the regmap instance is not
401  * yet ready when the component is registered. The function must also be called
402  * before the first IO attempt of the component.
403  */
snd_soc_component_init_regmap(struct snd_soc_component * component,struct regmap * regmap)404 void snd_soc_component_init_regmap(struct snd_soc_component *component,
405 				   struct regmap *regmap)
406 {
407 	component->regmap = regmap;
408 	snd_soc_component_setup_regmap(component);
409 }
410 EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap);
411 
412 /**
413  * snd_soc_component_exit_regmap() - De-initialize regmap instance for the
414  *                                   component
415  * @component: The component for which to de-initialize the regmap instance
416  *
417  * Calls regmap_exit() on the regmap instance associated to the component and
418  * removes the regmap instance from the component.
419  *
420  * This function should only be used if snd_soc_component_init_regmap() was used
421  * to initialize the regmap instance.
422  */
snd_soc_component_exit_regmap(struct snd_soc_component * component)423 void snd_soc_component_exit_regmap(struct snd_soc_component *component)
424 {
425 	regmap_exit(component->regmap);
426 	component->regmap = NULL;
427 }
428 EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap);
429 
430 #endif
431 
snd_soc_component_compr_open(struct snd_soc_component * component,struct snd_compr_stream * cstream)432 int snd_soc_component_compr_open(struct snd_soc_component *component,
433 				 struct snd_compr_stream *cstream)
434 {
435 	int ret = 0;
436 
437 	if (component->driver->compress_ops &&
438 	    component->driver->compress_ops->open)
439 		ret = component->driver->compress_ops->open(component, cstream);
440 
441 	/* mark substream if succeeded */
442 	if (ret == 0)
443 		soc_component_mark_push(component, cstream, compr_open);
444 
445 	return soc_component_ret(component, ret);
446 }
447 EXPORT_SYMBOL_GPL(snd_soc_component_compr_open);
448 
snd_soc_component_compr_free(struct snd_soc_component * component,struct snd_compr_stream * cstream,int rollback)449 void snd_soc_component_compr_free(struct snd_soc_component *component,
450 				  struct snd_compr_stream *cstream,
451 				  int rollback)
452 {
453 	if (rollback && !soc_component_mark_match(component, cstream, compr_open))
454 		return;
455 
456 	if (component->driver->compress_ops &&
457 	    component->driver->compress_ops->free)
458 		component->driver->compress_ops->free(component, cstream);
459 
460 	/* remove marked substream */
461 	soc_component_mark_pop(component, cstream, compr_open);
462 }
463 EXPORT_SYMBOL_GPL(snd_soc_component_compr_free);
464 
snd_soc_component_compr_trigger(struct snd_compr_stream * cstream,int cmd)465 int snd_soc_component_compr_trigger(struct snd_compr_stream *cstream, int cmd)
466 {
467 	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
468 	struct snd_soc_component *component;
469 	int i, ret;
470 
471 	for_each_rtd_components(rtd, i, component) {
472 		if (component->driver->compress_ops &&
473 		    component->driver->compress_ops->trigger) {
474 			ret = component->driver->compress_ops->trigger(
475 				component, cstream, cmd);
476 			if (ret < 0)
477 				return soc_component_ret(component, ret);
478 		}
479 	}
480 
481 	return 0;
482 }
483 EXPORT_SYMBOL_GPL(snd_soc_component_compr_trigger);
484 
snd_soc_component_compr_set_params(struct snd_compr_stream * cstream,struct snd_compr_params * params)485 int snd_soc_component_compr_set_params(struct snd_compr_stream *cstream,
486 				       struct snd_compr_params *params)
487 {
488 	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
489 	struct snd_soc_component *component;
490 	int i, ret;
491 
492 	for_each_rtd_components(rtd, i, component) {
493 		if (component->driver->compress_ops &&
494 		    component->driver->compress_ops->set_params) {
495 			ret = component->driver->compress_ops->set_params(
496 				component, cstream, params);
497 			if (ret < 0)
498 				return soc_component_ret(component, ret);
499 		}
500 	}
501 
502 	return 0;
503 }
504 EXPORT_SYMBOL_GPL(snd_soc_component_compr_set_params);
505 
snd_soc_component_compr_get_params(struct snd_compr_stream * cstream,struct snd_codec * params)506 int snd_soc_component_compr_get_params(struct snd_compr_stream *cstream,
507 				       struct snd_codec *params)
508 {
509 	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
510 	struct snd_soc_component *component;
511 	int i, ret;
512 
513 	for_each_rtd_components(rtd, i, component) {
514 		if (component->driver->compress_ops &&
515 		    component->driver->compress_ops->get_params) {
516 			ret = component->driver->compress_ops->get_params(
517 				component, cstream, params);
518 			return soc_component_ret(component, ret);
519 		}
520 	}
521 
522 	return 0;
523 }
524 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_params);
525 
snd_soc_component_compr_get_caps(struct snd_compr_stream * cstream,struct snd_compr_caps * caps)526 int snd_soc_component_compr_get_caps(struct snd_compr_stream *cstream,
527 				     struct snd_compr_caps *caps)
528 {
529 	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
530 	struct snd_soc_component *component;
531 	int i, ret = 0;
532 
533 	mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
534 
535 	for_each_rtd_components(rtd, i, component) {
536 		if (component->driver->compress_ops &&
537 		    component->driver->compress_ops->get_caps) {
538 			ret = component->driver->compress_ops->get_caps(
539 				component, cstream, caps);
540 			break;
541 		}
542 	}
543 
544 	mutex_unlock(&rtd->card->pcm_mutex);
545 
546 	return soc_component_ret(component, ret);
547 }
548 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_caps);
549 
snd_soc_component_compr_get_codec_caps(struct snd_compr_stream * cstream,struct snd_compr_codec_caps * codec)550 int snd_soc_component_compr_get_codec_caps(struct snd_compr_stream *cstream,
551 					   struct snd_compr_codec_caps *codec)
552 {
553 	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
554 	struct snd_soc_component *component;
555 	int i, ret = 0;
556 
557 	mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
558 
559 	for_each_rtd_components(rtd, i, component) {
560 		if (component->driver->compress_ops &&
561 		    component->driver->compress_ops->get_codec_caps) {
562 			ret = component->driver->compress_ops->get_codec_caps(
563 				component, cstream, codec);
564 			break;
565 		}
566 	}
567 
568 	mutex_unlock(&rtd->card->pcm_mutex);
569 
570 	return soc_component_ret(component, ret);
571 }
572 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_codec_caps);
573 
snd_soc_component_compr_ack(struct snd_compr_stream * cstream,size_t bytes)574 int snd_soc_component_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
575 {
576 	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
577 	struct snd_soc_component *component;
578 	int i, ret;
579 
580 	for_each_rtd_components(rtd, i, component) {
581 		if (component->driver->compress_ops &&
582 		    component->driver->compress_ops->ack) {
583 			ret = component->driver->compress_ops->ack(
584 				component, cstream, bytes);
585 			if (ret < 0)
586 				return soc_component_ret(component, ret);
587 		}
588 	}
589 
590 	return 0;
591 }
592 EXPORT_SYMBOL_GPL(snd_soc_component_compr_ack);
593 
snd_soc_component_compr_pointer(struct snd_compr_stream * cstream,struct snd_compr_tstamp * tstamp)594 int snd_soc_component_compr_pointer(struct snd_compr_stream *cstream,
595 				    struct snd_compr_tstamp *tstamp)
596 {
597 	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
598 	struct snd_soc_component *component;
599 	int i, ret;
600 
601 	for_each_rtd_components(rtd, i, component) {
602 		if (component->driver->compress_ops &&
603 		    component->driver->compress_ops->pointer) {
604 			ret = component->driver->compress_ops->pointer(
605 				component, cstream, tstamp);
606 			return soc_component_ret(component, ret);
607 		}
608 	}
609 
610 	return 0;
611 }
612 EXPORT_SYMBOL_GPL(snd_soc_component_compr_pointer);
613 
snd_soc_component_compr_copy(struct snd_compr_stream * cstream,char __user * buf,size_t count)614 int snd_soc_component_compr_copy(struct snd_compr_stream *cstream,
615 				 char __user *buf, size_t count)
616 {
617 	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
618 	struct snd_soc_component *component;
619 	int i, ret = 0;
620 
621 	mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
622 
623 	for_each_rtd_components(rtd, i, component) {
624 		if (component->driver->compress_ops &&
625 		    component->driver->compress_ops->copy) {
626 			ret = component->driver->compress_ops->copy(
627 				component, cstream, buf, count);
628 			break;
629 		}
630 	}
631 
632 	mutex_unlock(&rtd->card->pcm_mutex);
633 
634 	return soc_component_ret(component, ret);
635 }
636 EXPORT_SYMBOL_GPL(snd_soc_component_compr_copy);
637 
snd_soc_component_compr_set_metadata(struct snd_compr_stream * cstream,struct snd_compr_metadata * metadata)638 int snd_soc_component_compr_set_metadata(struct snd_compr_stream *cstream,
639 					 struct snd_compr_metadata *metadata)
640 {
641 	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
642 	struct snd_soc_component *component;
643 	int i, ret;
644 
645 	for_each_rtd_components(rtd, i, component) {
646 		if (component->driver->compress_ops &&
647 		    component->driver->compress_ops->set_metadata) {
648 			ret = component->driver->compress_ops->set_metadata(
649 				component, cstream, metadata);
650 			if (ret < 0)
651 				return soc_component_ret(component, ret);
652 		}
653 	}
654 
655 	return 0;
656 }
657 EXPORT_SYMBOL_GPL(snd_soc_component_compr_set_metadata);
658 
snd_soc_component_compr_get_metadata(struct snd_compr_stream * cstream,struct snd_compr_metadata * metadata)659 int snd_soc_component_compr_get_metadata(struct snd_compr_stream *cstream,
660 					 struct snd_compr_metadata *metadata)
661 {
662 	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
663 	struct snd_soc_component *component;
664 	int i, ret;
665 
666 	for_each_rtd_components(rtd, i, component) {
667 		if (component->driver->compress_ops &&
668 		    component->driver->compress_ops->get_metadata) {
669 			ret = component->driver->compress_ops->get_metadata(
670 				component, cstream, metadata);
671 			return soc_component_ret(component, ret);
672 		}
673 	}
674 
675 	return 0;
676 }
677 EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_metadata);
678 
soc_component_read_no_lock(struct snd_soc_component * component,unsigned int reg)679 static unsigned int soc_component_read_no_lock(
680 	struct snd_soc_component *component,
681 	unsigned int reg)
682 {
683 	int ret;
684 	unsigned int val = 0;
685 
686 	if (component->regmap)
687 		ret = regmap_read(component->regmap, reg, &val);
688 	else if (component->driver->read) {
689 		ret = 0;
690 		val = component->driver->read(component, reg);
691 	}
692 	else
693 		ret = -EIO;
694 
695 	if (ret < 0)
696 		return soc_component_ret_reg_rw(component, ret, reg);
697 
698 	return val;
699 }
700 
701 /**
702  * snd_soc_component_read() - Read register value
703  * @component: Component to read from
704  * @reg: Register to read
705  *
706  * Return: read value
707  */
snd_soc_component_read(struct snd_soc_component * component,unsigned int reg)708 unsigned int snd_soc_component_read(struct snd_soc_component *component,
709 				    unsigned int reg)
710 {
711 	unsigned int val;
712 
713 	mutex_lock(&component->io_mutex);
714 	val = soc_component_read_no_lock(component, reg);
715 	mutex_unlock(&component->io_mutex);
716 
717 	return val;
718 }
719 EXPORT_SYMBOL_GPL(snd_soc_component_read);
720 
soc_component_write_no_lock(struct snd_soc_component * component,unsigned int reg,unsigned int val)721 static int soc_component_write_no_lock(
722 	struct snd_soc_component *component,
723 	unsigned int reg, unsigned int val)
724 {
725 	int ret = -EIO;
726 
727 	if (component->regmap)
728 		ret = regmap_write(component->regmap, reg, val);
729 	else if (component->driver->write)
730 		ret = component->driver->write(component, reg, val);
731 
732 	return soc_component_ret_reg_rw(component, ret, reg);
733 }
734 
735 /**
736  * snd_soc_component_write() - Write register value
737  * @component: Component to write to
738  * @reg: Register to write
739  * @val: Value to write to the register
740  *
741  * Return: 0 on success, a negative error code otherwise.
742  */
snd_soc_component_write(struct snd_soc_component * component,unsigned int reg,unsigned int val)743 int snd_soc_component_write(struct snd_soc_component *component,
744 			    unsigned int reg, unsigned int val)
745 {
746 	int ret;
747 
748 	mutex_lock(&component->io_mutex);
749 	ret = soc_component_write_no_lock(component, reg, val);
750 	mutex_unlock(&component->io_mutex);
751 
752 	return ret;
753 }
754 EXPORT_SYMBOL_GPL(snd_soc_component_write);
755 
snd_soc_component_update_bits_legacy(struct snd_soc_component * component,unsigned int reg,unsigned int mask,unsigned int val,bool * change)756 static int snd_soc_component_update_bits_legacy(
757 	struct snd_soc_component *component, unsigned int reg,
758 	unsigned int mask, unsigned int val, bool *change)
759 {
760 	unsigned int old, new;
761 	int ret = 0;
762 
763 	mutex_lock(&component->io_mutex);
764 
765 	old = soc_component_read_no_lock(component, reg);
766 
767 	new = (old & ~mask) | (val & mask);
768 	*change = old != new;
769 	if (*change)
770 		ret = soc_component_write_no_lock(component, reg, new);
771 
772 	mutex_unlock(&component->io_mutex);
773 
774 	return soc_component_ret_reg_rw(component, ret, reg);
775 }
776 
777 /**
778  * snd_soc_component_update_bits() - Perform read/modify/write cycle
779  * @component: Component to update
780  * @reg: Register to update
781  * @mask: Mask that specifies which bits to update
782  * @val: New value for the bits specified by mask
783  *
784  * Return: 1 if the operation was successful and the value of the register
785  * changed, 0 if the operation was successful, but the value did not change.
786  * Returns a negative error code otherwise.
787  */
snd_soc_component_update_bits(struct snd_soc_component * component,unsigned int reg,unsigned int mask,unsigned int val)788 int snd_soc_component_update_bits(struct snd_soc_component *component,
789 				  unsigned int reg, unsigned int mask, unsigned int val)
790 {
791 	bool change;
792 	int ret;
793 
794 	if (component->regmap)
795 		ret = regmap_update_bits_check(component->regmap, reg, mask,
796 					       val, &change);
797 	else
798 		ret = snd_soc_component_update_bits_legacy(component, reg,
799 							   mask, val, &change);
800 
801 	if (ret < 0)
802 		return soc_component_ret_reg_rw(component, ret, reg);
803 	return change;
804 }
805 EXPORT_SYMBOL_GPL(snd_soc_component_update_bits);
806 
807 /**
808  * snd_soc_component_update_bits_async() - Perform asynchronous
809  *  read/modify/write cycle
810  * @component: Component to update
811  * @reg: Register to update
812  * @mask: Mask that specifies which bits to update
813  * @val: New value for the bits specified by mask
814  *
815  * This function is similar to snd_soc_component_update_bits(), but the update
816  * operation is scheduled asynchronously. This means it may not be completed
817  * when the function returns. To make sure that all scheduled updates have been
818  * completed snd_soc_component_async_complete() must be called.
819  *
820  * Return: 1 if the operation was successful and the value of the register
821  * changed, 0 if the operation was successful, but the value did not change.
822  * Returns a negative error code otherwise.
823  */
snd_soc_component_update_bits_async(struct snd_soc_component * component,unsigned int reg,unsigned int mask,unsigned int val)824 int snd_soc_component_update_bits_async(struct snd_soc_component *component,
825 					unsigned int reg, unsigned int mask, unsigned int val)
826 {
827 	bool change;
828 	int ret;
829 
830 	if (component->regmap)
831 		ret = regmap_update_bits_check_async(component->regmap, reg,
832 						     mask, val, &change);
833 	else
834 		ret = snd_soc_component_update_bits_legacy(component, reg,
835 							   mask, val, &change);
836 
837 	if (ret < 0)
838 		return soc_component_ret_reg_rw(component, ret, reg);
839 	return change;
840 }
841 EXPORT_SYMBOL_GPL(snd_soc_component_update_bits_async);
842 
843 /**
844  * snd_soc_component_read_field() - Read register field value
845  * @component: Component to read from
846  * @reg: Register to read
847  * @mask: mask of the register field
848  *
849  * Return: read value of register field.
850  */
snd_soc_component_read_field(struct snd_soc_component * component,unsigned int reg,unsigned int mask)851 unsigned int snd_soc_component_read_field(struct snd_soc_component *component,
852 					  unsigned int reg, unsigned int mask)
853 {
854 	unsigned int val;
855 
856 	val = snd_soc_component_read(component, reg);
857 
858 	val = (val & mask) >> soc_component_field_shift(component, mask);
859 
860 	return val;
861 }
862 EXPORT_SYMBOL_GPL(snd_soc_component_read_field);
863 
864 /**
865  * snd_soc_component_write_field() - write to register field
866  * @component: Component to write to
867  * @reg: Register to write
868  * @mask: mask of the register field to update
869  * @val: value of the field to write
870  *
871  * Return: 1 for change, otherwise 0.
872  */
snd_soc_component_write_field(struct snd_soc_component * component,unsigned int reg,unsigned int mask,unsigned int val)873 int snd_soc_component_write_field(struct snd_soc_component *component,
874 				  unsigned int reg, unsigned int mask,
875 				  unsigned int val)
876 {
877 
878 	val = (val << soc_component_field_shift(component, mask)) & mask;
879 
880 	return snd_soc_component_update_bits(component, reg, mask, val);
881 }
882 EXPORT_SYMBOL_GPL(snd_soc_component_write_field);
883 
884 /**
885  * snd_soc_component_async_complete() - Ensure asynchronous I/O has completed
886  * @component: Component for which to wait
887  *
888  * This function blocks until all asynchronous I/O which has previously been
889  * scheduled using snd_soc_component_update_bits_async() has completed.
890  */
snd_soc_component_async_complete(struct snd_soc_component * component)891 void snd_soc_component_async_complete(struct snd_soc_component *component)
892 {
893 	if (component->regmap)
894 		regmap_async_complete(component->regmap);
895 }
896 EXPORT_SYMBOL_GPL(snd_soc_component_async_complete);
897 
898 /**
899  * snd_soc_component_test_bits - Test register for change
900  * @component: component
901  * @reg: Register to test
902  * @mask: Mask that specifies which bits to test
903  * @value: Value to test against
904  *
905  * Tests a register with a new value and checks if the new value is
906  * different from the old value.
907  *
908  * Return: 1 for change, otherwise 0.
909  */
snd_soc_component_test_bits(struct snd_soc_component * component,unsigned int reg,unsigned int mask,unsigned int value)910 int snd_soc_component_test_bits(struct snd_soc_component *component,
911 				unsigned int reg, unsigned int mask, unsigned int value)
912 {
913 	unsigned int old, new;
914 
915 	old = snd_soc_component_read(component, reg);
916 	new = (old & ~mask) | value;
917 	return old != new;
918 }
919 EXPORT_SYMBOL_GPL(snd_soc_component_test_bits);
920 
snd_soc_pcm_component_pointer(struct snd_pcm_substream * substream)921 int snd_soc_pcm_component_pointer(struct snd_pcm_substream *substream)
922 {
923 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
924 	struct snd_soc_component *component;
925 	int i;
926 
927 	/* FIXME: use 1st pointer */
928 	for_each_rtd_components(rtd, i, component)
929 		if (component->driver->pointer)
930 			return component->driver->pointer(component, substream);
931 
932 	return 0;
933 }
934 
snd_soc_component_is_codec_on_rtd(struct snd_soc_pcm_runtime * rtd,struct snd_soc_component * component)935 static bool snd_soc_component_is_codec_on_rtd(struct snd_soc_pcm_runtime *rtd,
936 					      struct snd_soc_component *component)
937 {
938 	struct snd_soc_dai *dai;
939 	int i;
940 
941 	for_each_rtd_codec_dais(rtd, i, dai) {
942 		if (dai->component == component)
943 			return true;
944 	}
945 
946 	return false;
947 }
948 
snd_soc_pcm_component_delay(struct snd_pcm_substream * substream,snd_pcm_sframes_t * cpu_delay,snd_pcm_sframes_t * codec_delay)949 void snd_soc_pcm_component_delay(struct snd_pcm_substream *substream,
950 				 snd_pcm_sframes_t *cpu_delay,
951 				 snd_pcm_sframes_t *codec_delay)
952 {
953 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
954 	struct snd_soc_component *component;
955 	snd_pcm_sframes_t delay;
956 	int i;
957 
958 	/*
959 	 * We're looking for the delay through the full audio path so it needs to
960 	 * be the maximum of the Components doing transmit and the maximum of the
961 	 * Components doing receive (ie, all CPUs and all CODECs) rather than
962 	 * just the maximum of all Components.
963 	 */
964 	for_each_rtd_components(rtd, i, component) {
965 		if (!component->driver->delay)
966 			continue;
967 
968 		delay = component->driver->delay(component, substream);
969 
970 		if (snd_soc_component_is_codec_on_rtd(rtd, component))
971 			*codec_delay = max(*codec_delay, delay);
972 		else
973 			*cpu_delay = max(*cpu_delay, delay);
974 	}
975 }
976 
snd_soc_pcm_component_ioctl(struct snd_pcm_substream * substream,unsigned int cmd,void * arg)977 int snd_soc_pcm_component_ioctl(struct snd_pcm_substream *substream,
978 				unsigned int cmd, void *arg)
979 {
980 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
981 	struct snd_soc_component *component;
982 	int i;
983 
984 	/* FIXME: use 1st ioctl */
985 	for_each_rtd_components(rtd, i, component)
986 		if (component->driver->ioctl)
987 			return soc_component_ret(
988 				component,
989 				component->driver->ioctl(component,
990 							 substream, cmd, arg));
991 
992 	return snd_pcm_lib_ioctl(substream, cmd, arg);
993 }
994 
snd_soc_pcm_component_sync_stop(struct snd_pcm_substream * substream)995 int snd_soc_pcm_component_sync_stop(struct snd_pcm_substream *substream)
996 {
997 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
998 	struct snd_soc_component *component;
999 	int i, ret;
1000 
1001 	for_each_rtd_components(rtd, i, component) {
1002 		if (component->driver->sync_stop) {
1003 			ret = component->driver->sync_stop(component,
1004 							   substream);
1005 			if (ret < 0)
1006 				return soc_component_ret(component, ret);
1007 		}
1008 	}
1009 
1010 	return 0;
1011 }
1012 
snd_soc_pcm_component_copy_user(struct snd_pcm_substream * substream,int channel,unsigned long pos,void __user * buf,unsigned long bytes)1013 int snd_soc_pcm_component_copy_user(struct snd_pcm_substream *substream,
1014 				    int channel, unsigned long pos,
1015 				    void __user *buf, unsigned long bytes)
1016 {
1017 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1018 	struct snd_soc_component *component;
1019 	int i;
1020 
1021 	/* FIXME. it returns 1st copy now */
1022 	for_each_rtd_components(rtd, i, component)
1023 		if (component->driver->copy_user)
1024 			return soc_component_ret(
1025 				component,
1026 				component->driver->copy_user(
1027 					component, substream, channel,
1028 					pos, buf, bytes));
1029 
1030 	return -EINVAL;
1031 }
1032 
snd_soc_pcm_component_page(struct snd_pcm_substream * substream,unsigned long offset)1033 struct page *snd_soc_pcm_component_page(struct snd_pcm_substream *substream,
1034 					unsigned long offset)
1035 {
1036 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1037 	struct snd_soc_component *component;
1038 	struct page *page;
1039 	int i;
1040 
1041 	/* FIXME. it returns 1st page now */
1042 	for_each_rtd_components(rtd, i, component) {
1043 		if (component->driver->page) {
1044 			page = component->driver->page(component,
1045 						       substream, offset);
1046 			if (page)
1047 				return page;
1048 		}
1049 	}
1050 
1051 	return NULL;
1052 }
1053 
snd_soc_pcm_component_mmap(struct snd_pcm_substream * substream,struct vm_area_struct * vma)1054 int snd_soc_pcm_component_mmap(struct snd_pcm_substream *substream,
1055 			       struct vm_area_struct *vma)
1056 {
1057 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1058 	struct snd_soc_component *component;
1059 	int i;
1060 
1061 	/* FIXME. it returns 1st mmap now */
1062 	for_each_rtd_components(rtd, i, component)
1063 		if (component->driver->mmap)
1064 			return soc_component_ret(
1065 				component,
1066 				component->driver->mmap(component,
1067 							substream, vma));
1068 
1069 	return -EINVAL;
1070 }
1071 
snd_soc_pcm_component_new(struct snd_soc_pcm_runtime * rtd)1072 int snd_soc_pcm_component_new(struct snd_soc_pcm_runtime *rtd)
1073 {
1074 	struct snd_soc_component *component;
1075 	int ret;
1076 	int i;
1077 
1078 	for_each_rtd_components(rtd, i, component) {
1079 		if (component->driver->pcm_construct) {
1080 			ret = component->driver->pcm_construct(component, rtd);
1081 			if (ret < 0)
1082 				return soc_component_ret(component, ret);
1083 		}
1084 	}
1085 
1086 	return 0;
1087 }
1088 
snd_soc_pcm_component_free(struct snd_soc_pcm_runtime * rtd)1089 void snd_soc_pcm_component_free(struct snd_soc_pcm_runtime *rtd)
1090 {
1091 	struct snd_soc_component *component;
1092 	int i;
1093 
1094 	if (!rtd->pcm)
1095 		return;
1096 
1097 	for_each_rtd_components(rtd, i, component)
1098 		if (component->driver->pcm_destruct)
1099 			component->driver->pcm_destruct(component, rtd->pcm);
1100 }
1101 
snd_soc_pcm_component_prepare(struct snd_pcm_substream * substream)1102 int snd_soc_pcm_component_prepare(struct snd_pcm_substream *substream)
1103 {
1104 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1105 	struct snd_soc_component *component;
1106 	int i, ret;
1107 
1108 	for_each_rtd_components(rtd, i, component) {
1109 		if (component->driver->prepare) {
1110 			ret = component->driver->prepare(component, substream);
1111 			if (ret < 0)
1112 				return soc_component_ret(component, ret);
1113 		}
1114 	}
1115 
1116 	return 0;
1117 }
1118 
snd_soc_pcm_component_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)1119 int snd_soc_pcm_component_hw_params(struct snd_pcm_substream *substream,
1120 				    struct snd_pcm_hw_params *params)
1121 {
1122 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1123 	struct snd_soc_component *component;
1124 	int i, ret;
1125 
1126 	for_each_rtd_components(rtd, i, component) {
1127 		if (component->driver->hw_params) {
1128 			ret = component->driver->hw_params(component,
1129 							   substream, params);
1130 			if (ret < 0)
1131 				return soc_component_ret(component, ret);
1132 		}
1133 		/* mark substream if succeeded */
1134 		soc_component_mark_push(component, substream, hw_params);
1135 	}
1136 
1137 	return 0;
1138 }
1139 
snd_soc_pcm_component_hw_free(struct snd_pcm_substream * substream,int rollback)1140 void snd_soc_pcm_component_hw_free(struct snd_pcm_substream *substream,
1141 				   int rollback)
1142 {
1143 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1144 	struct snd_soc_component *component;
1145 	int i, ret;
1146 
1147 	for_each_rtd_components(rtd, i, component) {
1148 		if (rollback && !soc_component_mark_match(component, substream, hw_params))
1149 			continue;
1150 
1151 		if (component->driver->hw_free) {
1152 			ret = component->driver->hw_free(component, substream);
1153 			if (ret < 0)
1154 				soc_component_ret(component, ret);
1155 		}
1156 
1157 		/* remove marked substream */
1158 		soc_component_mark_pop(component, substream, hw_params);
1159 	}
1160 }
1161 
soc_component_trigger(struct snd_soc_component * component,struct snd_pcm_substream * substream,int cmd)1162 static int soc_component_trigger(struct snd_soc_component *component,
1163 				 struct snd_pcm_substream *substream,
1164 				 int cmd)
1165 {
1166 	int ret = 0;
1167 
1168 	if (component->driver->trigger)
1169 		ret = component->driver->trigger(component, substream, cmd);
1170 
1171 	return soc_component_ret(component, ret);
1172 }
1173 
snd_soc_pcm_component_trigger(struct snd_pcm_substream * substream,int cmd,int rollback)1174 int snd_soc_pcm_component_trigger(struct snd_pcm_substream *substream,
1175 				  int cmd, int rollback)
1176 {
1177 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1178 	struct snd_soc_component *component;
1179 	int i, r, ret = 0;
1180 
1181 	switch (cmd) {
1182 	case SNDRV_PCM_TRIGGER_START:
1183 	case SNDRV_PCM_TRIGGER_RESUME:
1184 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1185 		for_each_rtd_components(rtd, i, component) {
1186 			ret = soc_component_trigger(component, substream, cmd);
1187 			if (ret < 0)
1188 				break;
1189 			soc_component_mark_push(component, substream, trigger);
1190 		}
1191 		break;
1192 	case SNDRV_PCM_TRIGGER_STOP:
1193 	case SNDRV_PCM_TRIGGER_SUSPEND:
1194 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1195 		for_each_rtd_components(rtd, i, component) {
1196 			if (rollback && !soc_component_mark_match(component, substream, trigger))
1197 				continue;
1198 
1199 			r = soc_component_trigger(component, substream, cmd);
1200 			if (r < 0)
1201 				ret = r; /* use last ret */
1202 			soc_component_mark_pop(component, substream, trigger);
1203 		}
1204 	}
1205 
1206 	return ret;
1207 }
1208 
snd_soc_pcm_component_pm_runtime_get(struct snd_soc_pcm_runtime * rtd,void * stream)1209 int snd_soc_pcm_component_pm_runtime_get(struct snd_soc_pcm_runtime *rtd,
1210 					 void *stream)
1211 {
1212 	struct snd_soc_component *component;
1213 	int i;
1214 
1215 	for_each_rtd_components(rtd, i, component) {
1216 		int ret = pm_runtime_get_sync(component->dev);
1217 		if (ret < 0 && ret != -EACCES) {
1218 			pm_runtime_put_noidle(component->dev);
1219 			return soc_component_ret(component, ret);
1220 		}
1221 		/* mark stream if succeeded */
1222 		soc_component_mark_push(component, stream, pm);
1223 	}
1224 
1225 	return 0;
1226 }
1227 
snd_soc_pcm_component_pm_runtime_put(struct snd_soc_pcm_runtime * rtd,void * stream,int rollback)1228 void snd_soc_pcm_component_pm_runtime_put(struct snd_soc_pcm_runtime *rtd,
1229 					  void *stream, int rollback)
1230 {
1231 	struct snd_soc_component *component;
1232 	int i;
1233 
1234 	for_each_rtd_components(rtd, i, component) {
1235 		if (rollback && !soc_component_mark_match(component, stream, pm))
1236 			continue;
1237 
1238 		pm_runtime_mark_last_busy(component->dev);
1239 		pm_runtime_put_autosuspend(component->dev);
1240 
1241 		/* remove marked stream */
1242 		soc_component_mark_pop(component, stream, pm);
1243 	}
1244 }
1245 
snd_soc_pcm_component_ack(struct snd_pcm_substream * substream)1246 int snd_soc_pcm_component_ack(struct snd_pcm_substream *substream)
1247 {
1248 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1249 	struct snd_soc_component *component;
1250 	int i;
1251 
1252 	/* FIXME: use 1st pointer */
1253 	for_each_rtd_components(rtd, i, component)
1254 		if (component->driver->ack)
1255 			return component->driver->ack(component, substream);
1256 
1257 	return 0;
1258 }
1259