Lines Matching +full:diff +full:- +full:channels
1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * Abramo Bagnara <abramo@alsa-project.org>
38 * runtime->silence_start: starting pointer to silence area
39 * runtime->silence_filled: size filled with silence
40 * runtime->silence_threshold: threshold from application
41 * runtime->silence_size: maximal size from application
43 * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
47 struct snd_pcm_runtime *runtime = substream->runtime; in snd_pcm_playback_silence()
51 if (runtime->silence_size < runtime->boundary) { in snd_pcm_playback_silence()
53 snd_pcm_uframes_t appl_ptr = READ_ONCE(runtime->control->appl_ptr); in snd_pcm_playback_silence()
54 if (runtime->silence_start != appl_ptr) { in snd_pcm_playback_silence()
55 n = appl_ptr - runtime->silence_start; in snd_pcm_playback_silence()
57 n += runtime->boundary; in snd_pcm_playback_silence()
58 if ((snd_pcm_uframes_t)n < runtime->silence_filled) in snd_pcm_playback_silence()
59 runtime->silence_filled -= n; in snd_pcm_playback_silence()
61 runtime->silence_filled = 0; in snd_pcm_playback_silence()
62 runtime->silence_start = appl_ptr; in snd_pcm_playback_silence()
64 if (runtime->silence_filled >= runtime->buffer_size) in snd_pcm_playback_silence()
66 noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled; in snd_pcm_playback_silence()
67 if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold) in snd_pcm_playback_silence()
69 frames = runtime->silence_threshold - noise_dist; in snd_pcm_playback_silence()
70 if (frames > runtime->silence_size) in snd_pcm_playback_silence()
71 frames = runtime->silence_size; in snd_pcm_playback_silence()
75 if (avail > runtime->buffer_size) in snd_pcm_playback_silence()
76 avail = runtime->buffer_size; in snd_pcm_playback_silence()
77 runtime->silence_filled = avail > 0 ? avail : 0; in snd_pcm_playback_silence()
78 runtime->silence_start = (runtime->status->hw_ptr + in snd_pcm_playback_silence()
79 runtime->silence_filled) % in snd_pcm_playback_silence()
80 runtime->boundary; in snd_pcm_playback_silence()
82 ofs = runtime->status->hw_ptr; in snd_pcm_playback_silence()
83 frames = new_hw_ptr - ofs; in snd_pcm_playback_silence()
85 frames += runtime->boundary; in snd_pcm_playback_silence()
86 runtime->silence_filled -= frames; in snd_pcm_playback_silence()
87 if ((snd_pcm_sframes_t)runtime->silence_filled < 0) { in snd_pcm_playback_silence()
88 runtime->silence_filled = 0; in snd_pcm_playback_silence()
89 runtime->silence_start = new_hw_ptr; in snd_pcm_playback_silence()
91 runtime->silence_start = ofs; in snd_pcm_playback_silence()
94 frames = runtime->buffer_size - runtime->silence_filled; in snd_pcm_playback_silence()
96 if (snd_BUG_ON(frames > runtime->buffer_size)) in snd_pcm_playback_silence()
100 ofs = runtime->silence_start % runtime->buffer_size; in snd_pcm_playback_silence()
102 transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames; in snd_pcm_playback_silence()
105 runtime->silence_filled += transfer; in snd_pcm_playback_silence()
106 frames -= transfer; in snd_pcm_playback_silence()
116 substream->pcm->card->number, in snd_pcm_debug_name()
117 substream->pcm->device, in snd_pcm_debug_name()
118 substream->stream ? 'c' : 'p', in snd_pcm_debug_name()
119 substream->number); in snd_pcm_debug_name()
131 ((substream)->pstr->xrun_debug & (mask))
144 struct snd_pcm_runtime *runtime = substream->runtime; in __snd_pcm_xrun()
147 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) { in __snd_pcm_xrun()
151 runtime->status->tstamp.tv_sec = tstamp.tv_sec; in __snd_pcm_xrun()
152 runtime->status->tstamp.tv_nsec = tstamp.tv_nsec; in __snd_pcm_xrun()
158 pcm_warn(substream->pcm, "XRUN: %s\n", name); in __snd_pcm_xrun()
186 if (avail > runtime->avail_max) in snd_pcm_update_state()
187 runtime->avail_max = avail; in snd_pcm_update_state()
188 if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) { in snd_pcm_update_state()
189 if (avail >= runtime->buffer_size) { in snd_pcm_update_state()
191 return -EPIPE; in snd_pcm_update_state()
194 if (avail >= runtime->stop_threshold) { in snd_pcm_update_state()
196 return -EPIPE; in snd_pcm_update_state()
199 if (runtime->twake) { in snd_pcm_update_state()
200 if (avail >= runtime->twake) in snd_pcm_update_state()
201 wake_up(&runtime->tsleep); in snd_pcm_update_state()
202 } else if (avail >= runtime->control->avail_min) in snd_pcm_update_state()
203 wake_up(&runtime->sleep); in snd_pcm_update_state()
211 struct snd_pcm_runtime *runtime = substream->runtime; in update_audio_tstamp()
215 if (runtime->tstamp_mode != SNDRV_PCM_TSTAMP_ENABLE) in update_audio_tstamp()
218 if (!(substream->ops->get_time_info) || in update_audio_tstamp()
219 (runtime->audio_tstamp_report.actual_type == in update_audio_tstamp()
227 audio_frames = runtime->hw_ptr_wrap + runtime->status->hw_ptr; in update_audio_tstamp()
229 if (runtime->audio_tstamp_config.report_delay) { in update_audio_tstamp()
230 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) in update_audio_tstamp()
231 audio_frames -= runtime->delay; in update_audio_tstamp()
233 audio_frames += runtime->delay; in update_audio_tstamp()
236 runtime->rate); in update_audio_tstamp()
240 if (runtime->status->audio_tstamp.tv_sec != audio_tstamp->tv_sec || in update_audio_tstamp()
241 runtime->status->audio_tstamp.tv_nsec != audio_tstamp->tv_nsec) { in update_audio_tstamp()
242 runtime->status->audio_tstamp.tv_sec = audio_tstamp->tv_sec; in update_audio_tstamp()
243 runtime->status->audio_tstamp.tv_nsec = audio_tstamp->tv_nsec; in update_audio_tstamp()
244 runtime->status->tstamp.tv_sec = curr_tstamp->tv_sec; in update_audio_tstamp()
245 runtime->status->tstamp.tv_nsec = curr_tstamp->tv_nsec; in update_audio_tstamp()
250 * re-take a driver timestamp to let apps detect if the reference tstamp in update_audio_tstamp()
251 * read by low-level hardware was provided with a delay in update_audio_tstamp()
253 snd_pcm_gettime(substream->runtime, &driver_tstamp); in update_audio_tstamp()
254 runtime->driver_tstamp = driver_tstamp; in update_audio_tstamp()
260 struct snd_pcm_runtime *runtime = substream->runtime; in snd_pcm_update_hw_ptr0()
270 old_hw_ptr = runtime->status->hw_ptr; in snd_pcm_update_hw_ptr0()
278 pos = substream->ops->pointer(substream); in snd_pcm_update_hw_ptr0()
280 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) { in snd_pcm_update_hw_ptr0()
281 if ((substream->ops->get_time_info) && in snd_pcm_update_hw_ptr0()
282 (runtime->audio_tstamp_config.type_requested != SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT)) { in snd_pcm_update_hw_ptr0()
283 substream->ops->get_time_info(substream, &curr_tstamp, in snd_pcm_update_hw_ptr0()
285 &runtime->audio_tstamp_config, in snd_pcm_update_hw_ptr0()
286 &runtime->audio_tstamp_report); in snd_pcm_update_hw_ptr0()
288 /* re-test in case tstamp type is not supported in hardware and was demoted to DEFAULT */ in snd_pcm_update_hw_ptr0()
289 if (runtime->audio_tstamp_report.actual_type == SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT) in snd_pcm_update_hw_ptr0()
297 return -EPIPE; in snd_pcm_update_hw_ptr0()
299 if (pos >= runtime->buffer_size) { in snd_pcm_update_hw_ptr0()
303 pcm_err(substream->pcm, in snd_pcm_update_hw_ptr0()
305 name, pos, runtime->buffer_size, in snd_pcm_update_hw_ptr0()
306 runtime->period_size); in snd_pcm_update_hw_ptr0()
310 pos -= pos % runtime->min_align; in snd_pcm_update_hw_ptr0()
312 hw_base = runtime->hw_ptr_base; in snd_pcm_update_hw_ptr0()
317 delta = runtime->hw_ptr_interrupt + runtime->period_size; in snd_pcm_update_hw_ptr0()
320 hdelta = curr_jiffies - runtime->hw_ptr_jiffies; in snd_pcm_update_hw_ptr0()
321 if (hdelta > runtime->hw_ptr_buffer_jiffies/2 + 1) { in snd_pcm_update_hw_ptr0()
322 hw_base += runtime->buffer_size; in snd_pcm_update_hw_ptr0()
323 if (hw_base >= runtime->boundary) { in snd_pcm_update_hw_ptr0()
335 hw_base += runtime->buffer_size; in snd_pcm_update_hw_ptr0()
336 if (hw_base >= runtime->boundary) { in snd_pcm_update_hw_ptr0()
343 delta = new_hw_ptr - old_hw_ptr; in snd_pcm_update_hw_ptr0()
345 delta += runtime->boundary; in snd_pcm_update_hw_ptr0()
347 if (runtime->no_period_wakeup) { in snd_pcm_update_hw_ptr0()
353 jdelta = curr_jiffies - runtime->hw_ptr_jiffies; in snd_pcm_update_hw_ptr0()
354 if (jdelta < runtime->hw_ptr_buffer_jiffies / 2) in snd_pcm_update_hw_ptr0()
356 hdelta = jdelta - delta * HZ / runtime->rate; in snd_pcm_update_hw_ptr0()
357 xrun_threshold = runtime->hw_ptr_buffer_jiffies / 2 + 1; in snd_pcm_update_hw_ptr0()
359 delta += runtime->buffer_size; in snd_pcm_update_hw_ptr0()
360 hw_base += runtime->buffer_size; in snd_pcm_update_hw_ptr0()
361 if (hw_base >= runtime->boundary) { in snd_pcm_update_hw_ptr0()
366 hdelta -= runtime->hw_ptr_buffer_jiffies; in snd_pcm_update_hw_ptr0()
372 if (delta >= runtime->buffer_size + runtime->period_size) { in snd_pcm_update_hw_ptr0()
375 substream->stream, (long)pos, in snd_pcm_update_hw_ptr0()
388 if (runtime->hw.info & SNDRV_PCM_INFO_BATCH) in snd_pcm_update_hw_ptr0()
391 if (hdelta < runtime->delay) in snd_pcm_update_hw_ptr0()
393 hdelta -= runtime->delay; in snd_pcm_update_hw_ptr0()
394 jdelta = curr_jiffies - runtime->hw_ptr_jiffies; in snd_pcm_update_hw_ptr0()
395 if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) { in snd_pcm_update_hw_ptr0()
397 (((runtime->period_size * HZ) / runtime->rate) in snd_pcm_update_hw_ptr0()
405 new_hw_ptr += runtime->period_size; in snd_pcm_update_hw_ptr0()
406 if (new_hw_ptr >= runtime->boundary) { in snd_pcm_update_hw_ptr0()
407 new_hw_ptr -= runtime->boundary; in snd_pcm_update_hw_ptr0()
408 crossed_boundary--; in snd_pcm_update_hw_ptr0()
410 delta--; in snd_pcm_update_hw_ptr0()
416 (long)runtime->period_size, jdelta, in snd_pcm_update_hw_ptr0()
417 ((hdelta * HZ) / runtime->rate), hw_base, in snd_pcm_update_hw_ptr0()
422 hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size); in snd_pcm_update_hw_ptr0()
425 if (delta > runtime->period_size + runtime->period_size / 2) { in snd_pcm_update_hw_ptr0()
429 substream->stream, (long)delta, in snd_pcm_update_hw_ptr0()
435 if (runtime->status->hw_ptr == new_hw_ptr) { in snd_pcm_update_hw_ptr0()
436 runtime->hw_ptr_jiffies = curr_jiffies; in snd_pcm_update_hw_ptr0()
441 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && in snd_pcm_update_hw_ptr0()
442 runtime->silence_size > 0) in snd_pcm_update_hw_ptr0()
446 delta = new_hw_ptr - runtime->hw_ptr_interrupt; in snd_pcm_update_hw_ptr0()
448 delta += runtime->boundary; in snd_pcm_update_hw_ptr0()
449 delta -= (snd_pcm_uframes_t)delta % runtime->period_size; in snd_pcm_update_hw_ptr0()
450 runtime->hw_ptr_interrupt += delta; in snd_pcm_update_hw_ptr0()
451 if (runtime->hw_ptr_interrupt >= runtime->boundary) in snd_pcm_update_hw_ptr0()
452 runtime->hw_ptr_interrupt -= runtime->boundary; in snd_pcm_update_hw_ptr0()
454 runtime->hw_ptr_base = hw_base; in snd_pcm_update_hw_ptr0()
455 runtime->status->hw_ptr = new_hw_ptr; in snd_pcm_update_hw_ptr0()
456 runtime->hw_ptr_jiffies = curr_jiffies; in snd_pcm_update_hw_ptr0()
459 runtime->hw_ptr_wrap += runtime->boundary; in snd_pcm_update_hw_ptr0()
474 * snd_pcm_set_ops - set the PCM operators
484 struct snd_pcm_str *stream = &pcm->streams[direction]; in snd_pcm_set_ops()
487 for (substream = stream->substream; substream != NULL; substream = substream->next) in snd_pcm_set_ops()
488 substream->ops = ops; in snd_pcm_set_ops()
493 * snd_pcm_set_sync - set the PCM sync id
500 struct snd_pcm_runtime *runtime = substream->runtime; in snd_pcm_set_sync()
502 runtime->sync.id32[0] = substream->pcm->card->number; in snd_pcm_set_sync()
503 runtime->sync.id32[1] = -1; in snd_pcm_set_sync()
504 runtime->sync.id32[2] = -1; in snd_pcm_set_sync()
505 runtime->sync.id32[3] = -1; in snd_pcm_set_sync()
569 * snd_interval_refine - refine the interval value of configurator
584 return -EINVAL; in snd_interval_refine()
585 if (i->min < v->min) { in snd_interval_refine()
586 i->min = v->min; in snd_interval_refine()
587 i->openmin = v->openmin; in snd_interval_refine()
589 } else if (i->min == v->min && !i->openmin && v->openmin) { in snd_interval_refine()
590 i->openmin = 1; in snd_interval_refine()
593 if (i->max > v->max) { in snd_interval_refine()
594 i->max = v->max; in snd_interval_refine()
595 i->openmax = v->openmax; in snd_interval_refine()
597 } else if (i->max == v->max && !i->openmax && v->openmax) { in snd_interval_refine()
598 i->openmax = 1; in snd_interval_refine()
601 if (!i->integer && v->integer) { in snd_interval_refine()
602 i->integer = 1; in snd_interval_refine()
605 if (i->integer) { in snd_interval_refine()
606 if (i->openmin) { in snd_interval_refine()
607 i->min++; in snd_interval_refine()
608 i->openmin = 0; in snd_interval_refine()
610 if (i->openmax) { in snd_interval_refine()
611 i->max--; in snd_interval_refine()
612 i->openmax = 0; in snd_interval_refine()
614 } else if (!i->openmin && !i->openmax && i->min == i->max) in snd_interval_refine()
615 i->integer = 1; in snd_interval_refine()
618 return -EINVAL; in snd_interval_refine()
626 const unsigned int last_max = i->max; in snd_interval_refine_first()
629 return -EINVAL; in snd_interval_refine_first()
632 i->max = i->min; in snd_interval_refine_first()
633 if (i->openmin) in snd_interval_refine_first()
634 i->max++; in snd_interval_refine_first()
636 i->openmax = (i->openmax && i->max >= last_max); in snd_interval_refine_first()
642 const unsigned int last_min = i->min; in snd_interval_refine_last()
645 return -EINVAL; in snd_interval_refine_last()
648 i->min = i->max; in snd_interval_refine_last()
649 if (i->openmax) in snd_interval_refine_last()
650 i->min--; in snd_interval_refine_last()
652 i->openmin = (i->openmin && i->min <= last_min); in snd_interval_refine_last()
658 if (a->empty || b->empty) { in snd_interval_mul()
662 c->empty = 0; in snd_interval_mul()
663 c->min = mul(a->min, b->min); in snd_interval_mul()
664 c->openmin = (a->openmin || b->openmin); in snd_interval_mul()
665 c->max = mul(a->max, b->max); in snd_interval_mul()
666 c->openmax = (a->openmax || b->openmax); in snd_interval_mul()
667 c->integer = (a->integer && b->integer); in snd_interval_mul()
671 * snd_interval_div - refine the interval value with division
678 * Returns non-zero if the value is changed, zero if not changed.
683 if (a->empty || b->empty) { in snd_interval_div()
687 c->empty = 0; in snd_interval_div()
688 c->min = div32(a->min, b->max, &r); in snd_interval_div()
689 c->openmin = (r || a->openmin || b->openmax); in snd_interval_div()
690 if (b->min > 0) { in snd_interval_div()
691 c->max = div32(a->max, b->min, &r); in snd_interval_div()
693 c->max++; in snd_interval_div()
694 c->openmax = 1; in snd_interval_div()
696 c->openmax = (a->openmax || b->openmin); in snd_interval_div()
698 c->max = UINT_MAX; in snd_interval_div()
699 c->openmax = 0; in snd_interval_div()
701 c->integer = 0; in snd_interval_div()
705 * snd_interval_muldivk - refine the interval value
713 * Returns non-zero if the value is changed, zero if not changed.
719 if (a->empty || b->empty) { in snd_interval_muldivk()
723 c->empty = 0; in snd_interval_muldivk()
724 c->min = muldiv32(a->min, b->min, k, &r); in snd_interval_muldivk()
725 c->openmin = (r || a->openmin || b->openmin); in snd_interval_muldivk()
726 c->max = muldiv32(a->max, b->max, k, &r); in snd_interval_muldivk()
728 c->max++; in snd_interval_muldivk()
729 c->openmax = 1; in snd_interval_muldivk()
731 c->openmax = (a->openmax || b->openmax); in snd_interval_muldivk()
732 c->integer = 0; in snd_interval_muldivk()
736 * snd_interval_mulkdiv - refine the interval value
744 * Returns non-zero if the value is changed, zero if not changed.
750 if (a->empty || b->empty) { in snd_interval_mulkdiv()
754 c->empty = 0; in snd_interval_mulkdiv()
755 c->min = muldiv32(a->min, k, b->max, &r); in snd_interval_mulkdiv()
756 c->openmin = (r || a->openmin || b->openmax); in snd_interval_mulkdiv()
757 if (b->min > 0) { in snd_interval_mulkdiv()
758 c->max = muldiv32(a->max, k, b->min, &r); in snd_interval_mulkdiv()
760 c->max++; in snd_interval_mulkdiv()
761 c->openmax = 1; in snd_interval_mulkdiv()
763 c->openmax = (a->openmax || b->openmin); in snd_interval_mulkdiv()
765 c->max = UINT_MAX; in snd_interval_mulkdiv()
766 c->openmax = 0; in snd_interval_mulkdiv()
768 c->integer = 0; in snd_interval_mulkdiv()
771 /* ---- */
775 * snd_interval_ratnum - refine the interval value
801 unsigned int q = i->min; in snd_interval_ratnum()
802 int diff; in snd_interval_ratnum() local
812 r = (den - rats[k].den_min) % rats[k].den_step; in snd_interval_ratnum()
814 den -= r; in snd_interval_ratnum()
816 diff = num - q * den; in snd_interval_ratnum()
817 if (diff < 0) in snd_interval_ratnum()
818 diff = -diff; in snd_interval_ratnum()
820 diff * best_den < best_diff * den) { in snd_interval_ratnum()
821 best_diff = diff; in snd_interval_ratnum()
827 i->empty = 1; in snd_interval_ratnum()
828 return -EINVAL; in snd_interval_ratnum()
840 unsigned int q = i->max; in snd_interval_ratnum()
841 int diff; in snd_interval_ratnum() local
843 i->empty = 1; in snd_interval_ratnum()
844 return -EINVAL; in snd_interval_ratnum()
853 r = (den - rats[k].den_min) % rats[k].den_step; in snd_interval_ratnum()
855 den += rats[k].den_step - r; in snd_interval_ratnum()
857 diff = q * den - num; in snd_interval_ratnum()
858 if (diff < 0) in snd_interval_ratnum()
859 diff = -diff; in snd_interval_ratnum()
861 diff * best_den < best_diff * den) { in snd_interval_ratnum()
862 best_diff = diff; in snd_interval_ratnum()
868 i->empty = 1; in snd_interval_ratnum()
869 return -EINVAL; in snd_interval_ratnum()
893 * snd_interval_ratden - refine the interval value
917 unsigned int q = i->min; in snd_interval_ratden()
918 int diff; in snd_interval_ratden() local
926 r = (num - rats[k].num_min) % rats[k].num_step; in snd_interval_ratden()
928 num += rats[k].num_step - r; in snd_interval_ratden()
930 diff = num - q * den; in snd_interval_ratden()
932 diff * best_den < best_diff * den) { in snd_interval_ratden()
933 best_diff = diff; in snd_interval_ratden()
939 i->empty = 1; in snd_interval_ratden()
940 return -EINVAL; in snd_interval_ratden()
949 unsigned int q = i->max; in snd_interval_ratden()
950 int diff; in snd_interval_ratden() local
958 r = (num - rats[k].num_min) % rats[k].num_step; in snd_interval_ratden()
960 num -= r; in snd_interval_ratden()
962 diff = q * den - num; in snd_interval_ratden()
964 diff * best_den < best_diff * den) { in snd_interval_ratden()
965 best_diff = diff; in snd_interval_ratden()
971 i->empty = 1; in snd_interval_ratden()
972 return -EINVAL; in snd_interval_ratden()
991 * snd_interval_list - refine the interval value from the list
995 * @mask: the bit-mask to evaluate
998 * When mask is non-zero, only the elements corresponding to bit 1 are
1011 i->empty = 1; in snd_interval_list()
1012 return -EINVAL; in snd_interval_list()
1030 * snd_interval_ranges - refine the interval value from the list of ranges
1034 * @mask: the bit-mask to evaluate
1037 * When mask is non-zero, only the elements corresponding to bit 1 are
1052 return -EINVAL; in snd_interval_ranges()
1087 n = i->min % step; in snd_interval_step()
1088 if (n != 0 || i->openmin) { in snd_interval_step()
1089 i->min += step - n; in snd_interval_step()
1090 i->openmin = 0; in snd_interval_step()
1093 n = i->max % step; in snd_interval_step()
1094 if (n != 0 || i->openmax) { in snd_interval_step()
1095 i->max -= n; in snd_interval_step()
1096 i->openmax = 0; in snd_interval_step()
1100 i->empty = 1; in snd_interval_step()
1101 return -EINVAL; in snd_interval_step()
1109 * snd_pcm_hw_rule_add - add the hw-constraint rule
1124 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; in snd_pcm_hw_rule_add()
1129 if (constrs->rules_num >= constrs->rules_all) { in snd_pcm_hw_rule_add()
1131 unsigned int new_rules = constrs->rules_all + 16; in snd_pcm_hw_rule_add()
1132 new = krealloc_array(constrs->rules, new_rules, in snd_pcm_hw_rule_add()
1136 return -ENOMEM; in snd_pcm_hw_rule_add()
1138 constrs->rules = new; in snd_pcm_hw_rule_add()
1139 constrs->rules_all = new_rules; in snd_pcm_hw_rule_add()
1141 c = &constrs->rules[constrs->rules_num]; in snd_pcm_hw_rule_add()
1142 c->cond = cond; in snd_pcm_hw_rule_add()
1143 c->func = func; in snd_pcm_hw_rule_add()
1144 c->var = var; in snd_pcm_hw_rule_add()
1145 c->private = private; in snd_pcm_hw_rule_add()
1148 if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps))) { in snd_pcm_hw_rule_add()
1150 return -EINVAL; in snd_pcm_hw_rule_add()
1152 c->deps[k++] = dep; in snd_pcm_hw_rule_add()
1157 constrs->rules_num++; in snd_pcm_hw_rule_add()
1164 * snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint
1169 * Apply the constraint of the given bitmap mask to a 32-bit mask parameter.
1176 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; in snd_pcm_hw_constraint_mask()
1178 *maskp->bits &= mask; in snd_pcm_hw_constraint_mask()
1179 memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */ in snd_pcm_hw_constraint_mask()
1180 if (*maskp->bits == 0) in snd_pcm_hw_constraint_mask()
1181 return -EINVAL; in snd_pcm_hw_constraint_mask()
1186 * snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint
1191 * Apply the constraint of the given bitmap mask to a 64-bit mask parameter.
1198 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; in snd_pcm_hw_constraint_mask64()
1200 maskp->bits[0] &= (u_int32_t)mask; in snd_pcm_hw_constraint_mask64()
1201 maskp->bits[1] &= (u_int32_t)(mask >> 32); in snd_pcm_hw_constraint_mask64()
1202 memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */ in snd_pcm_hw_constraint_mask64()
1203 if (! maskp->bits[0] && ! maskp->bits[1]) in snd_pcm_hw_constraint_mask64()
1204 return -EINVAL; in snd_pcm_hw_constraint_mask64()
1210 * snd_pcm_hw_constraint_integer - apply an integer constraint to an interval
1221 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; in snd_pcm_hw_constraint_integer()
1227 * snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval
1241 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; in snd_pcm_hw_constraint_minmax()
1254 struct snd_pcm_hw_constraint_list *list = rule->private; in snd_pcm_hw_rule_list()
1255 …return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask… in snd_pcm_hw_rule_list()
1260 * snd_pcm_hw_constraint_list - apply a list of constraints to a parameter
1277 var, -1); in snd_pcm_hw_constraint_list()
1284 struct snd_pcm_hw_constraint_ranges *r = rule->private; in snd_pcm_hw_rule_ranges()
1285 return snd_interval_ranges(hw_param_interval(params, rule->var), in snd_pcm_hw_rule_ranges()
1286 r->count, r->ranges, r->mask); in snd_pcm_hw_rule_ranges()
1291 * snd_pcm_hw_constraint_ranges - apply list of range constraints to a parameter
1308 var, -1); in snd_pcm_hw_constraint_ranges()
1315 const struct snd_pcm_hw_constraint_ratnums *r = rule->private; in snd_pcm_hw_rule_ratnums()
1318 err = snd_interval_ratnum(hw_param_interval(params, rule->var), in snd_pcm_hw_rule_ratnums()
1319 r->nrats, r->rats, &num, &den); in snd_pcm_hw_rule_ratnums()
1320 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) { in snd_pcm_hw_rule_ratnums()
1321 params->rate_num = num; in snd_pcm_hw_rule_ratnums()
1322 params->rate_den = den; in snd_pcm_hw_rule_ratnums()
1328 * snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter
1343 var, -1); in snd_pcm_hw_constraint_ratnums()
1350 const struct snd_pcm_hw_constraint_ratdens *r = rule->private; in snd_pcm_hw_rule_ratdens()
1352 int err = snd_interval_ratden(hw_param_interval(params, rule->var), in snd_pcm_hw_rule_ratdens()
1353 r->nrats, r->rats, &num, &den); in snd_pcm_hw_rule_ratdens()
1354 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) { in snd_pcm_hw_rule_ratdens()
1355 params->rate_num = num; in snd_pcm_hw_rule_ratdens()
1356 params->rate_den = den; in snd_pcm_hw_rule_ratdens()
1362 * snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter
1377 var, -1); in snd_pcm_hw_constraint_ratdens()
1384 unsigned int l = (unsigned long) rule->private; in snd_pcm_hw_rule_msbits()
1395 params->msbits = min_not_zero(params->msbits, msbits); in snd_pcm_hw_rule_msbits()
1401 * snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule
1420 return snd_pcm_hw_rule_add(runtime, cond, -1, in snd_pcm_hw_constraint_msbits()
1423 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); in snd_pcm_hw_constraint_msbits()
1430 unsigned long step = (unsigned long) rule->private; in snd_pcm_hw_rule_step()
1431 return snd_interval_step(hw_param_interval(params, rule->var), step); in snd_pcm_hw_rule_step()
1435 * snd_pcm_hw_constraint_step - add a hw constraint step rule
1450 var, -1); in snd_pcm_hw_constraint_step()
1462 return snd_interval_list(hw_param_interval(params, rule->var), in snd_pcm_hw_rule_pow2()
1467 * snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule
1470 * @var: hw_params variable to apply the power-of-2 constraint
1480 var, -1); in snd_pcm_hw_constraint_pow2()
1487 unsigned int base_rate = (unsigned int)(uintptr_t)rule->private; in snd_pcm_hw_rule_noresample_func()
1495 * snd_pcm_hw_rule_noresample - add a rule to allow disabling hw resampling
1508 SNDRV_PCM_HW_PARAM_RATE, -1); in snd_pcm_hw_rule_noresample()
1517 params->cmask |= 1 << var; in _snd_pcm_hw_param_any()
1518 params->rmask |= 1 << var; in _snd_pcm_hw_param_any()
1523 params->cmask |= 1 << var; in _snd_pcm_hw_param_any()
1524 params->rmask |= 1 << var; in _snd_pcm_hw_param_any()
1538 params->info = ~0U; in _snd_pcm_hw_params_any()
1543 * snd_pcm_hw_param_value - return @params field @var value
1546 * @dir: pointer to the direction (-1,0,1) or %NULL
1549 * defined by @params. -%EINVAL otherwise.
1557 return -EINVAL; in snd_pcm_hw_param_value()
1565 return -EINVAL; in snd_pcm_hw_param_value()
1567 *dir = i->openmin; in snd_pcm_hw_param_value()
1570 return -EINVAL; in snd_pcm_hw_param_value()
1579 params->cmask |= 1 << var; in _snd_pcm_hw_param_setempty()
1580 params->rmask |= 1 << var; in _snd_pcm_hw_param_setempty()
1583 params->cmask |= 1 << var; in _snd_pcm_hw_param_setempty()
1584 params->rmask |= 1 << var; in _snd_pcm_hw_param_setempty()
1600 return -EINVAL; in _snd_pcm_hw_param_first()
1602 params->cmask |= 1 << var; in _snd_pcm_hw_param_first()
1603 params->rmask |= 1 << var; in _snd_pcm_hw_param_first()
1610 * snd_pcm_hw_param_first - refine config space and return minimum value
1614 * @dir: pointer to the direction (-1,0,1) or %NULL
1628 if (params->rmask) { in snd_pcm_hw_param_first()
1646 return -EINVAL; in _snd_pcm_hw_param_last()
1648 params->cmask |= 1 << var; in _snd_pcm_hw_param_last()
1649 params->rmask |= 1 << var; in _snd_pcm_hw_param_last()
1656 * snd_pcm_hw_param_last - refine config space and return maximum value
1660 * @dir: pointer to the direction (-1,0,1) or %NULL
1674 if (params->rmask) { in snd_pcm_hw_param_last()
1686 struct snd_pcm_runtime *runtime = substream->runtime; in snd_pcm_lib_ioctl_reset()
1691 runtime->status->hw_ptr %= runtime->buffer_size; in snd_pcm_lib_ioctl_reset()
1693 runtime->status->hw_ptr = 0; in snd_pcm_lib_ioctl_reset()
1694 runtime->hw_ptr_wrap = 0; in snd_pcm_lib_ioctl_reset()
1704 struct snd_pcm_runtime *runtime = substream->runtime; in snd_pcm_lib_ioctl_channel_info()
1706 if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) { in snd_pcm_lib_ioctl_channel_info()
1707 info->offset = -1; in snd_pcm_lib_ioctl_channel_info()
1710 width = snd_pcm_format_physical_width(runtime->format); in snd_pcm_lib_ioctl_channel_info()
1713 info->offset = 0; in snd_pcm_lib_ioctl_channel_info()
1714 switch (runtime->access) { in snd_pcm_lib_ioctl_channel_info()
1717 info->first = info->channel * width; in snd_pcm_lib_ioctl_channel_info()
1718 info->step = runtime->channels * width; in snd_pcm_lib_ioctl_channel_info()
1723 size_t size = runtime->dma_bytes / runtime->channels; in snd_pcm_lib_ioctl_channel_info()
1724 info->first = info->channel * size * 8; in snd_pcm_lib_ioctl_channel_info()
1725 info->step = width; in snd_pcm_lib_ioctl_channel_info()
1740 int channels; in snd_pcm_lib_ioctl_fifo_size() local
1743 params->fifo_size = substream->runtime->hw.fifo_size; in snd_pcm_lib_ioctl_fifo_size()
1744 if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) { in snd_pcm_lib_ioctl_fifo_size()
1746 channels = params_channels(params); in snd_pcm_lib_ioctl_fifo_size()
1747 frame_size = snd_pcm_format_size(format, channels); in snd_pcm_lib_ioctl_fifo_size()
1749 params->fifo_size /= frame_size; in snd_pcm_lib_ioctl_fifo_size()
1755 * snd_pcm_lib_ioctl - a generic PCM ioctl callback
1776 return -ENXIO; in snd_pcm_lib_ioctl()
1781 * snd_pcm_period_elapsed_under_stream_lock() - update the status of runtime for the next period
1801 …* - .pointer - to retrieve current position of audio data transmission by frame count or XRUN stat…
1802 * - .trigger - with SNDRV_PCM_TRIGGER_STOP at XRUN or DRAINING state.
1803 * - .get_time_info - to retrieve audio time stamp if needed.
1813 runtime = substream->runtime; in snd_pcm_period_elapsed_under_stream_lock()
1820 if (substream->timer_running) in snd_pcm_period_elapsed_under_stream_lock()
1821 snd_timer_interrupt(substream->timer, 1); in snd_pcm_period_elapsed_under_stream_lock()
1824 kill_fasync(&runtime->fasync, SIGIO, POLL_IN); in snd_pcm_period_elapsed_under_stream_lock()
1829 * snd_pcm_period_elapsed() - update the status of runtime for the next period by acquiring lock of
1862 struct snd_pcm_runtime *runtime = substream->runtime; in wait_for_avail()
1863 int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; in wait_for_avail()
1871 add_wait_queue(&runtime->tsleep, &wait); in wait_for_avail()
1873 if (runtime->no_period_wakeup) in wait_for_avail()
1877 if (substream->wait_time) { in wait_for_avail()
1878 wait_time = substream->wait_time; in wait_for_avail()
1882 if (runtime->rate) { in wait_for_avail()
1883 long t = runtime->period_size * 2 / in wait_for_avail()
1884 runtime->rate; in wait_for_avail()
1893 err = -ERESTARTSYS; in wait_for_avail()
1905 if (avail >= runtime->twake) in wait_for_avail()
1913 switch (runtime->status->state) { in wait_for_avail()
1915 err = -ESTRPIPE; in wait_for_avail()
1918 err = -EPIPE; in wait_for_avail()
1922 err = -EPIPE; in wait_for_avail()
1929 err = -EBADFD; in wait_for_avail()
1935 pcm_dbg(substream->pcm, in wait_for_avail()
1938 err = -EIO; in wait_for_avail()
1944 remove_wait_queue(&runtime->tsleep, &wait); in wait_for_avail()
1956 /* calculate the target DMA-buffer position to be written/read */
1960 return runtime->dma_area + hwoff + in get_dma_ptr()
1961 channel * (runtime->dma_bytes / runtime->channels); in get_dma_ptr()
1964 /* default copy_user ops for write; used for both interleaved and non- modes */
1969 if (copy_from_user(get_dma_ptr(substream->runtime, channel, hwoff), in default_write_copy()
1971 return -EFAULT; in default_write_copy()
1980 memcpy(get_dma_ptr(substream->runtime, channel, hwoff), buf, bytes); in default_write_copy_kernel()
1991 struct snd_pcm_runtime *runtime = substream->runtime; in fill_silence()
1993 if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) in fill_silence()
1995 if (substream->ops->fill_silence) in fill_silence()
1996 return substream->ops->fill_silence(substream, channel, in fill_silence()
1999 snd_pcm_format_set_silence(runtime->format, in fill_silence()
2005 /* default copy_user ops for read; used for both interleaved and non- modes */
2011 get_dma_ptr(substream->runtime, channel, hwoff), in default_read_copy()
2013 return -EFAULT; in default_read_copy()
2022 memcpy(buf, get_dma_ptr(substream->runtime, channel, hwoff), bytes); in default_read_copy_kernel()
2035 struct snd_pcm_runtime *runtime = substream->runtime; in interleaved_copy()
2045 * non-interleaved channel; when buffer is NULL, silencing instead of copying
2053 struct snd_pcm_runtime *runtime = substream->runtime; in noninterleaved_copy()
2054 int channels = runtime->channels; in noninterleaved_copy() local
2059 * in non-interleaved mode, we copy for each channel, thus in noninterleaved_copy()
2060 * each copy is n_samples bytes x channels = whole frames. in noninterleaved_copy()
2065 for (c = 0; c < channels; ++c, ++bufs) { in noninterleaved_copy()
2083 if (substream->runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED || in fill_silence_frames()
2084 substream->runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) in fill_silence_frames()
2092 /* sanity-check for read/write methods */
2097 return -ENXIO; in pcm_sanity_check()
2098 runtime = substream->runtime; in pcm_sanity_check()
2099 if (snd_BUG_ON(!substream->ops->copy_user && !runtime->dma_area)) in pcm_sanity_check()
2100 return -EINVAL; in pcm_sanity_check()
2101 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) in pcm_sanity_check()
2102 return -EBADFD; in pcm_sanity_check()
2108 switch (runtime->status->state) { in pcm_accessible_state()
2114 return -EPIPE; in pcm_accessible_state()
2116 return -ESTRPIPE; in pcm_accessible_state()
2118 return -EBADFD; in pcm_accessible_state()
2128 struct snd_pcm_runtime *runtime = substream->runtime; in pcm_lib_apply_appl_ptr()
2129 snd_pcm_uframes_t old_appl_ptr = runtime->control->appl_ptr; in pcm_lib_apply_appl_ptr()
2135 runtime->control->appl_ptr = appl_ptr; in pcm_lib_apply_appl_ptr()
2136 if (substream->ops->ack) { in pcm_lib_apply_appl_ptr()
2137 ret = substream->ops->ack(substream); in pcm_lib_apply_appl_ptr()
2139 runtime->control->appl_ptr = old_appl_ptr; in pcm_lib_apply_appl_ptr()
2154 struct snd_pcm_runtime *runtime = substream->runtime; in __snd_pcm_lib_xfer()
2168 is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; in __snd_pcm_lib_xfer()
2170 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && in __snd_pcm_lib_xfer()
2171 runtime->channels > 1) in __snd_pcm_lib_xfer()
2172 return -EINVAL; in __snd_pcm_lib_xfer()
2175 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) in __snd_pcm_lib_xfer()
2176 return -EINVAL; in __snd_pcm_lib_xfer()
2184 return -EINVAL; in __snd_pcm_lib_xfer()
2186 if (substream->ops->copy_kernel) in __snd_pcm_lib_xfer()
2187 transfer = substream->ops->copy_kernel; in __snd_pcm_lib_xfer()
2192 if (substream->ops->copy_user) in __snd_pcm_lib_xfer()
2193 transfer = (pcm_transfer_f)substream->ops->copy_user; in __snd_pcm_lib_xfer()
2202 nonblock = !!(substream->f_flags & O_NONBLOCK); in __snd_pcm_lib_xfer()
2209 runtime->twake = runtime->control->avail_min ? : 1; in __snd_pcm_lib_xfer()
2210 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING) in __snd_pcm_lib_xfer()
2218 runtime->status->state == SNDRV_PCM_STATE_PREPARED && in __snd_pcm_lib_xfer()
2219 size >= runtime->start_threshold) { in __snd_pcm_lib_xfer()
2232 runtime->status->state == SNDRV_PCM_STATE_DRAINING) { in __snd_pcm_lib_xfer()
2237 err = -EAGAIN; in __snd_pcm_lib_xfer()
2240 runtime->twake = min_t(snd_pcm_uframes_t, size, in __snd_pcm_lib_xfer()
2241 runtime->control->avail_min ? : 1); in __snd_pcm_lib_xfer()
2249 appl_ptr = READ_ONCE(runtime->control->appl_ptr); in __snd_pcm_lib_xfer()
2250 appl_ofs = appl_ptr % runtime->buffer_size; in __snd_pcm_lib_xfer()
2251 cont = runtime->buffer_size - appl_ofs; in __snd_pcm_lib_xfer()
2255 err = -EINVAL; in __snd_pcm_lib_xfer()
2268 if (appl_ptr >= runtime->boundary) in __snd_pcm_lib_xfer()
2269 appl_ptr -= runtime->boundary; in __snd_pcm_lib_xfer()
2275 size -= frames; in __snd_pcm_lib_xfer()
2277 avail -= frames; in __snd_pcm_lib_xfer()
2279 runtime->status->state == SNDRV_PCM_STATE_PREPARED && in __snd_pcm_lib_xfer()
2280 snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) { in __snd_pcm_lib_xfer()
2287 runtime->twake = 0; in __snd_pcm_lib_xfer()
2299 /* default channel maps for multi-channel playbacks, up to 8 channels */
2301 { .channels = 1,
2303 { .channels = 2,
2305 { .channels = 4,
2308 { .channels = 6,
2312 { .channels = 8,
2321 /* alternative channel maps with CLFE <-> surround swapped for 6/8 channels */
2323 { .channels = 1,
2325 { .channels = 2,
2327 { .channels = 4,
2330 { .channels = 6,
2334 { .channels = 8,
2345 if (ch > info->max_channels) in valid_chmap_channels()
2347 return !info->channel_mask || (info->channel_mask & (1U << ch)); in valid_chmap_channels()
2355 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; in pcm_chmap_ctl_info()
2356 uinfo->count = info->max_channels; in pcm_chmap_ctl_info()
2357 uinfo->value.integer.min = 0; in pcm_chmap_ctl_info()
2358 uinfo->value.integer.max = SNDRV_CHMAP_LAST; in pcm_chmap_ctl_info()
2363 * stores the channel position firstly matching with the current channels
2369 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); in pcm_chmap_ctl_get()
2373 if (!info->chmap) in pcm_chmap_ctl_get()
2374 return -EINVAL; in pcm_chmap_ctl_get()
2377 return -ENODEV; in pcm_chmap_ctl_get()
2378 memset(ucontrol->value.integer.value, 0, in pcm_chmap_ctl_get()
2379 sizeof(long) * info->max_channels); in pcm_chmap_ctl_get()
2380 if (!substream->runtime) in pcm_chmap_ctl_get()
2381 return 0; /* no channels set */ in pcm_chmap_ctl_get()
2382 for (map = info->chmap; map->channels; map++) { in pcm_chmap_ctl_get()
2384 if (map->channels == substream->runtime->channels && in pcm_chmap_ctl_get()
2385 valid_chmap_channels(info, map->channels)) { in pcm_chmap_ctl_get()
2386 for (i = 0; i < map->channels; i++) in pcm_chmap_ctl_get()
2387 ucontrol->value.integer.value[i] = map->map[i]; in pcm_chmap_ctl_get()
2391 return -EINVAL; in pcm_chmap_ctl_get()
2395 * expands the pre-defined channel maps in a form of TLV
2405 if (!info->chmap) in pcm_chmap_ctl_tlv()
2406 return -EINVAL; in pcm_chmap_ctl_tlv()
2408 return -ENOMEM; in pcm_chmap_ctl_tlv()
2410 return -EFAULT; in pcm_chmap_ctl_tlv()
2411 size -= 8; in pcm_chmap_ctl_tlv()
2413 for (map = info->chmap; map->channels; map++) { in pcm_chmap_ctl_tlv()
2414 int chs_bytes = map->channels * 4; in pcm_chmap_ctl_tlv()
2415 if (!valid_chmap_channels(info, map->channels)) in pcm_chmap_ctl_tlv()
2418 return -ENOMEM; in pcm_chmap_ctl_tlv()
2421 return -EFAULT; in pcm_chmap_ctl_tlv()
2423 size -= 8; in pcm_chmap_ctl_tlv()
2426 return -ENOMEM; in pcm_chmap_ctl_tlv()
2427 size -= chs_bytes; in pcm_chmap_ctl_tlv()
2429 for (c = 0; c < map->channels; c++) { in pcm_chmap_ctl_tlv()
2430 if (put_user(map->map[c], dst)) in pcm_chmap_ctl_tlv()
2431 return -EFAULT; in pcm_chmap_ctl_tlv()
2436 return -EFAULT; in pcm_chmap_ctl_tlv()
2443 info->pcm->streams[info->stream].chmap_kctl = NULL; in pcm_chmap_ctl_private_free()
2448 * snd_pcm_add_chmap_ctls - create channel-mapping control elements
2452 * @max_channels: the max number of channels for the stream
2454 * @info_ret: store struct snd_pcm_chmap instance if non-NULL
2456 * Create channel-mapping control elements assigned to the given PCM stream(s).
2477 if (WARN_ON(pcm->streams[stream].chmap_kctl)) in snd_pcm_add_chmap_ctls()
2478 return -EBUSY; in snd_pcm_add_chmap_ctls()
2481 return -ENOMEM; in snd_pcm_add_chmap_ctls()
2482 info->pcm = pcm; in snd_pcm_add_chmap_ctls()
2483 info->stream = stream; in snd_pcm_add_chmap_ctls()
2484 info->chmap = chmap; in snd_pcm_add_chmap_ctls()
2485 info->max_channels = max_channels; in snd_pcm_add_chmap_ctls()
2490 knew.device = pcm->device; in snd_pcm_add_chmap_ctls()
2491 knew.count = pcm->streams[stream].substream_count; in snd_pcm_add_chmap_ctls()
2493 info->kctl = snd_ctl_new1(&knew, info); in snd_pcm_add_chmap_ctls()
2494 if (!info->kctl) { in snd_pcm_add_chmap_ctls()
2496 return -ENOMEM; in snd_pcm_add_chmap_ctls()
2498 info->kctl->private_free = pcm_chmap_ctl_private_free; in snd_pcm_add_chmap_ctls()
2499 err = snd_ctl_add(pcm->card, info->kctl); in snd_pcm_add_chmap_ctls()
2502 pcm->streams[stream].chmap_kctl = info->kctl; in snd_pcm_add_chmap_ctls()