Lines Matching +full:num +full:- +full:transfer +full:- +full:bits
1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * Abramo Bagnara <abramo@alsa-project.org>
43 delta = new_ptr - ptr; in update_silence_vars()
47 delta += runtime->boundary; in update_silence_vars()
48 if ((snd_pcm_uframes_t)delta < runtime->silence_filled) in update_silence_vars()
49 runtime->silence_filled -= delta; in update_silence_vars()
51 runtime->silence_filled = 0; in update_silence_vars()
52 runtime->silence_start = new_ptr; in update_silence_vars()
57 * runtime->silence_start: starting pointer to silence area
58 * runtime->silence_filled: size filled with silence
59 * runtime->silence_threshold: threshold from application
60 * runtime->silence_size: maximal size from application
62 * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately
66 struct snd_pcm_runtime *runtime = substream->runtime; in snd_pcm_playback_silence()
67 snd_pcm_uframes_t frames, ofs, transfer; in snd_pcm_playback_silence() local
70 if (runtime->silence_size < runtime->boundary) { in snd_pcm_playback_silence()
72 snd_pcm_uframes_t appl_ptr = READ_ONCE(runtime->control->appl_ptr); in snd_pcm_playback_silence()
73 update_silence_vars(runtime, runtime->silence_start, appl_ptr); in snd_pcm_playback_silence()
76 new_hw_ptr = runtime->status->hw_ptr; in snd_pcm_playback_silence()
78 noise_dist = appl_ptr - new_hw_ptr; in snd_pcm_playback_silence()
80 noise_dist += runtime->boundary; in snd_pcm_playback_silence()
82 noise_dist += runtime->silence_filled; in snd_pcm_playback_silence()
83 if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold) in snd_pcm_playback_silence()
85 frames = runtime->silence_threshold - noise_dist; in snd_pcm_playback_silence()
86 if (frames > runtime->silence_size) in snd_pcm_playback_silence()
87 frames = runtime->silence_size; in snd_pcm_playback_silence()
90 * This filling mode aims at free-running mode (used for example by dmix), in snd_pcm_playback_silence()
93 snd_pcm_uframes_t hw_ptr = runtime->status->hw_ptr; in snd_pcm_playback_silence()
101 snd_pcm_sframes_t avail = runtime->control->appl_ptr - hw_ptr; in snd_pcm_playback_silence()
103 avail += runtime->boundary; in snd_pcm_playback_silence()
105 * In free-running mode, appl_ptr will be zero even while running, in snd_pcm_playback_silence()
109 runtime->silence_filled = avail > runtime->buffer_size ? 0 : avail; in snd_pcm_playback_silence()
110 runtime->silence_start = hw_ptr; in snd_pcm_playback_silence()
119 frames = runtime->buffer_size - runtime->silence_filled; in snd_pcm_playback_silence()
121 if (snd_BUG_ON(frames > runtime->buffer_size)) in snd_pcm_playback_silence()
125 ofs = (runtime->silence_start + runtime->silence_filled) % runtime->buffer_size; in snd_pcm_playback_silence()
127 transfer = ofs + frames > runtime->buffer_size ? runtime->buffer_size - ofs : frames; in snd_pcm_playback_silence()
128 err = fill_silence_frames(substream, ofs, transfer); in snd_pcm_playback_silence()
130 runtime->silence_filled += transfer; in snd_pcm_playback_silence()
131 frames -= transfer; in snd_pcm_playback_silence()
142 substream->pcm->card->number, in snd_pcm_debug_name()
143 substream->pcm->device, in snd_pcm_debug_name()
144 substream->stream ? 'c' : 'p', in snd_pcm_debug_name()
145 substream->number); in snd_pcm_debug_name()
157 ((substream)->pstr->xrun_debug & (mask))
170 struct snd_pcm_runtime *runtime = substream->runtime; in __snd_pcm_xrun()
173 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) { in __snd_pcm_xrun()
177 runtime->status->tstamp.tv_sec = tstamp.tv_sec; in __snd_pcm_xrun()
178 runtime->status->tstamp.tv_nsec = tstamp.tv_nsec; in __snd_pcm_xrun()
184 pcm_warn(substream->pcm, "XRUN: %s\n", name); in __snd_pcm_xrun()
212 if (avail > runtime->avail_max) in snd_pcm_update_state()
213 runtime->avail_max = avail; in snd_pcm_update_state()
214 if (runtime->state == SNDRV_PCM_STATE_DRAINING) { in snd_pcm_update_state()
215 if (avail >= runtime->buffer_size) { in snd_pcm_update_state()
217 return -EPIPE; in snd_pcm_update_state()
220 if (avail >= runtime->stop_threshold) { in snd_pcm_update_state()
222 return -EPIPE; in snd_pcm_update_state()
225 if (runtime->twake) { in snd_pcm_update_state()
226 if (avail >= runtime->twake) in snd_pcm_update_state()
227 wake_up(&runtime->tsleep); in snd_pcm_update_state()
228 } else if (avail >= runtime->control->avail_min) in snd_pcm_update_state()
229 wake_up(&runtime->sleep); in snd_pcm_update_state()
237 struct snd_pcm_runtime *runtime = substream->runtime; in update_audio_tstamp()
241 if (runtime->tstamp_mode != SNDRV_PCM_TSTAMP_ENABLE) in update_audio_tstamp()
244 if (!(substream->ops->get_time_info) || in update_audio_tstamp()
245 (runtime->audio_tstamp_report.actual_type == in update_audio_tstamp()
253 audio_frames = runtime->hw_ptr_wrap + runtime->status->hw_ptr; in update_audio_tstamp()
255 if (runtime->audio_tstamp_config.report_delay) { in update_audio_tstamp()
256 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) in update_audio_tstamp()
257 audio_frames -= runtime->delay; in update_audio_tstamp()
259 audio_frames += runtime->delay; in update_audio_tstamp()
262 runtime->rate); in update_audio_tstamp()
266 if (runtime->status->audio_tstamp.tv_sec != audio_tstamp->tv_sec || in update_audio_tstamp()
267 runtime->status->audio_tstamp.tv_nsec != audio_tstamp->tv_nsec) { in update_audio_tstamp()
268 runtime->status->audio_tstamp.tv_sec = audio_tstamp->tv_sec; in update_audio_tstamp()
269 runtime->status->audio_tstamp.tv_nsec = audio_tstamp->tv_nsec; in update_audio_tstamp()
270 runtime->status->tstamp.tv_sec = curr_tstamp->tv_sec; in update_audio_tstamp()
271 runtime->status->tstamp.tv_nsec = curr_tstamp->tv_nsec; in update_audio_tstamp()
276 * re-take a driver timestamp to let apps detect if the reference tstamp in update_audio_tstamp()
277 * read by low-level hardware was provided with a delay in update_audio_tstamp()
279 snd_pcm_gettime(substream->runtime, &driver_tstamp); in update_audio_tstamp()
280 runtime->driver_tstamp = driver_tstamp; in update_audio_tstamp()
286 struct snd_pcm_runtime *runtime = substream->runtime; in snd_pcm_update_hw_ptr0()
296 old_hw_ptr = runtime->status->hw_ptr; in snd_pcm_update_hw_ptr0()
304 pos = substream->ops->pointer(substream); in snd_pcm_update_hw_ptr0()
306 if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE) { in snd_pcm_update_hw_ptr0()
307 if ((substream->ops->get_time_info) && in snd_pcm_update_hw_ptr0()
308 (runtime->audio_tstamp_config.type_requested != SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT)) { in snd_pcm_update_hw_ptr0()
309 substream->ops->get_time_info(substream, &curr_tstamp, in snd_pcm_update_hw_ptr0()
311 &runtime->audio_tstamp_config, in snd_pcm_update_hw_ptr0()
312 &runtime->audio_tstamp_report); in snd_pcm_update_hw_ptr0()
314 /* re-test in case tstamp type is not supported in hardware and was demoted to DEFAULT */ in snd_pcm_update_hw_ptr0()
315 if (runtime->audio_tstamp_report.actual_type == SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT) in snd_pcm_update_hw_ptr0()
323 return -EPIPE; in snd_pcm_update_hw_ptr0()
325 if (pos >= runtime->buffer_size) { in snd_pcm_update_hw_ptr0()
329 pcm_err(substream->pcm, in snd_pcm_update_hw_ptr0()
331 name, pos, runtime->buffer_size, in snd_pcm_update_hw_ptr0()
332 runtime->period_size); in snd_pcm_update_hw_ptr0()
336 pos -= pos % runtime->min_align; in snd_pcm_update_hw_ptr0()
338 hw_base = runtime->hw_ptr_base; in snd_pcm_update_hw_ptr0()
343 delta = runtime->hw_ptr_interrupt + runtime->period_size; in snd_pcm_update_hw_ptr0()
346 hdelta = curr_jiffies - runtime->hw_ptr_jiffies; in snd_pcm_update_hw_ptr0()
347 if (hdelta > runtime->hw_ptr_buffer_jiffies/2 + 1) { in snd_pcm_update_hw_ptr0()
348 hw_base += runtime->buffer_size; in snd_pcm_update_hw_ptr0()
349 if (hw_base >= runtime->boundary) { in snd_pcm_update_hw_ptr0()
361 hw_base += runtime->buffer_size; in snd_pcm_update_hw_ptr0()
362 if (hw_base >= runtime->boundary) { in snd_pcm_update_hw_ptr0()
369 delta = new_hw_ptr - old_hw_ptr; in snd_pcm_update_hw_ptr0()
371 delta += runtime->boundary; in snd_pcm_update_hw_ptr0()
373 if (runtime->no_period_wakeup) { in snd_pcm_update_hw_ptr0()
379 jdelta = curr_jiffies - runtime->hw_ptr_jiffies; in snd_pcm_update_hw_ptr0()
380 if (jdelta < runtime->hw_ptr_buffer_jiffies / 2) in snd_pcm_update_hw_ptr0()
382 hdelta = jdelta - delta * HZ / runtime->rate; in snd_pcm_update_hw_ptr0()
383 xrun_threshold = runtime->hw_ptr_buffer_jiffies / 2 + 1; in snd_pcm_update_hw_ptr0()
385 delta += runtime->buffer_size; in snd_pcm_update_hw_ptr0()
386 hw_base += runtime->buffer_size; in snd_pcm_update_hw_ptr0()
387 if (hw_base >= runtime->boundary) { in snd_pcm_update_hw_ptr0()
392 hdelta -= runtime->hw_ptr_buffer_jiffies; in snd_pcm_update_hw_ptr0()
398 if (delta >= runtime->buffer_size + runtime->period_size) { in snd_pcm_update_hw_ptr0()
401 substream->stream, (long)pos, in snd_pcm_update_hw_ptr0()
414 if (runtime->hw.info & SNDRV_PCM_INFO_BATCH) in snd_pcm_update_hw_ptr0()
417 if (hdelta < runtime->delay) in snd_pcm_update_hw_ptr0()
419 hdelta -= runtime->delay; in snd_pcm_update_hw_ptr0()
420 jdelta = curr_jiffies - runtime->hw_ptr_jiffies; in snd_pcm_update_hw_ptr0()
421 if (((hdelta * HZ) / runtime->rate) > jdelta + HZ/100) { in snd_pcm_update_hw_ptr0()
423 (((runtime->period_size * HZ) / runtime->rate) in snd_pcm_update_hw_ptr0()
431 new_hw_ptr += runtime->period_size; in snd_pcm_update_hw_ptr0()
432 if (new_hw_ptr >= runtime->boundary) { in snd_pcm_update_hw_ptr0()
433 new_hw_ptr -= runtime->boundary; in snd_pcm_update_hw_ptr0()
434 crossed_boundary--; in snd_pcm_update_hw_ptr0()
436 delta--; in snd_pcm_update_hw_ptr0()
442 (long)runtime->period_size, jdelta, in snd_pcm_update_hw_ptr0()
443 ((hdelta * HZ) / runtime->rate), hw_base, in snd_pcm_update_hw_ptr0()
448 hw_base = new_hw_ptr - (new_hw_ptr % runtime->buffer_size); in snd_pcm_update_hw_ptr0()
451 if (delta > runtime->period_size + runtime->period_size / 2) { in snd_pcm_update_hw_ptr0()
455 substream->stream, (long)delta, in snd_pcm_update_hw_ptr0()
461 if (runtime->status->hw_ptr == new_hw_ptr) { in snd_pcm_update_hw_ptr0()
462 runtime->hw_ptr_jiffies = curr_jiffies; in snd_pcm_update_hw_ptr0()
467 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && in snd_pcm_update_hw_ptr0()
468 runtime->silence_size > 0) in snd_pcm_update_hw_ptr0()
472 delta = new_hw_ptr - runtime->hw_ptr_interrupt; in snd_pcm_update_hw_ptr0()
474 delta += runtime->boundary; in snd_pcm_update_hw_ptr0()
475 delta -= (snd_pcm_uframes_t)delta % runtime->period_size; in snd_pcm_update_hw_ptr0()
476 runtime->hw_ptr_interrupt += delta; in snd_pcm_update_hw_ptr0()
477 if (runtime->hw_ptr_interrupt >= runtime->boundary) in snd_pcm_update_hw_ptr0()
478 runtime->hw_ptr_interrupt -= runtime->boundary; in snd_pcm_update_hw_ptr0()
480 runtime->hw_ptr_base = hw_base; in snd_pcm_update_hw_ptr0()
481 runtime->status->hw_ptr = new_hw_ptr; in snd_pcm_update_hw_ptr0()
482 runtime->hw_ptr_jiffies = curr_jiffies; in snd_pcm_update_hw_ptr0()
485 runtime->hw_ptr_wrap += runtime->boundary; in snd_pcm_update_hw_ptr0()
500 * snd_pcm_set_ops - set the PCM operators
510 struct snd_pcm_str *stream = &pcm->streams[direction]; in snd_pcm_set_ops()
513 for (substream = stream->substream; substream != NULL; substream = substream->next) in snd_pcm_set_ops()
514 substream->ops = ops; in snd_pcm_set_ops()
519 * snd_pcm_set_sync - set the PCM sync id
526 struct snd_pcm_runtime *runtime = substream->runtime; in snd_pcm_set_sync()
528 runtime->sync.id32[0] = substream->pcm->card->number; in snd_pcm_set_sync()
529 runtime->sync.id32[1] = -1; in snd_pcm_set_sync()
530 runtime->sync.id32[2] = -1; in snd_pcm_set_sync()
531 runtime->sync.id32[3] = -1; in snd_pcm_set_sync()
595 * snd_interval_refine - refine the interval value of configurator
610 return -EINVAL; in snd_interval_refine()
611 if (i->min < v->min) { in snd_interval_refine()
612 i->min = v->min; in snd_interval_refine()
613 i->openmin = v->openmin; in snd_interval_refine()
615 } else if (i->min == v->min && !i->openmin && v->openmin) { in snd_interval_refine()
616 i->openmin = 1; in snd_interval_refine()
619 if (i->max > v->max) { in snd_interval_refine()
620 i->max = v->max; in snd_interval_refine()
621 i->openmax = v->openmax; in snd_interval_refine()
623 } else if (i->max == v->max && !i->openmax && v->openmax) { in snd_interval_refine()
624 i->openmax = 1; in snd_interval_refine()
627 if (!i->integer && v->integer) { in snd_interval_refine()
628 i->integer = 1; in snd_interval_refine()
631 if (i->integer) { in snd_interval_refine()
632 if (i->openmin) { in snd_interval_refine()
633 i->min++; in snd_interval_refine()
634 i->openmin = 0; in snd_interval_refine()
636 if (i->openmax) { in snd_interval_refine()
637 i->max--; in snd_interval_refine()
638 i->openmax = 0; in snd_interval_refine()
640 } else if (!i->openmin && !i->openmax && i->min == i->max) in snd_interval_refine()
641 i->integer = 1; in snd_interval_refine()
644 return -EINVAL; in snd_interval_refine()
652 const unsigned int last_max = i->max; in snd_interval_refine_first()
655 return -EINVAL; in snd_interval_refine_first()
658 i->max = i->min; in snd_interval_refine_first()
659 if (i->openmin) in snd_interval_refine_first()
660 i->max++; in snd_interval_refine_first()
662 i->openmax = (i->openmax && i->max >= last_max); in snd_interval_refine_first()
668 const unsigned int last_min = i->min; in snd_interval_refine_last()
671 return -EINVAL; in snd_interval_refine_last()
674 i->min = i->max; in snd_interval_refine_last()
675 if (i->openmax) in snd_interval_refine_last()
676 i->min--; in snd_interval_refine_last()
678 i->openmin = (i->openmin && i->min <= last_min); in snd_interval_refine_last()
684 if (a->empty || b->empty) { in snd_interval_mul()
688 c->empty = 0; in snd_interval_mul()
689 c->min = mul(a->min, b->min); in snd_interval_mul()
690 c->openmin = (a->openmin || b->openmin); in snd_interval_mul()
691 c->max = mul(a->max, b->max); in snd_interval_mul()
692 c->openmax = (a->openmax || b->openmax); in snd_interval_mul()
693 c->integer = (a->integer && b->integer); in snd_interval_mul()
697 * snd_interval_div - refine the interval value with division
704 * Returns non-zero if the value is changed, zero if not changed.
709 if (a->empty || b->empty) { in snd_interval_div()
713 c->empty = 0; in snd_interval_div()
714 c->min = div32(a->min, b->max, &r); in snd_interval_div()
715 c->openmin = (r || a->openmin || b->openmax); in snd_interval_div()
716 if (b->min > 0) { in snd_interval_div()
717 c->max = div32(a->max, b->min, &r); in snd_interval_div()
719 c->max++; in snd_interval_div()
720 c->openmax = 1; in snd_interval_div()
722 c->openmax = (a->openmax || b->openmin); in snd_interval_div()
724 c->max = UINT_MAX; in snd_interval_div()
725 c->openmax = 0; in snd_interval_div()
727 c->integer = 0; in snd_interval_div()
731 * snd_interval_muldivk - refine the interval value
739 * Returns non-zero if the value is changed, zero if not changed.
745 if (a->empty || b->empty) { in snd_interval_muldivk()
749 c->empty = 0; in snd_interval_muldivk()
750 c->min = muldiv32(a->min, b->min, k, &r); in snd_interval_muldivk()
751 c->openmin = (r || a->openmin || b->openmin); in snd_interval_muldivk()
752 c->max = muldiv32(a->max, b->max, k, &r); in snd_interval_muldivk()
754 c->max++; in snd_interval_muldivk()
755 c->openmax = 1; in snd_interval_muldivk()
757 c->openmax = (a->openmax || b->openmax); in snd_interval_muldivk()
758 c->integer = 0; in snd_interval_muldivk()
762 * snd_interval_mulkdiv - refine the interval value
770 * Returns non-zero if the value is changed, zero if not changed.
776 if (a->empty || b->empty) { in snd_interval_mulkdiv()
780 c->empty = 0; in snd_interval_mulkdiv()
781 c->min = muldiv32(a->min, k, b->max, &r); in snd_interval_mulkdiv()
782 c->openmin = (r || a->openmin || b->openmax); in snd_interval_mulkdiv()
783 if (b->min > 0) { in snd_interval_mulkdiv()
784 c->max = muldiv32(a->max, k, b->min, &r); in snd_interval_mulkdiv()
786 c->max++; in snd_interval_mulkdiv()
787 c->openmax = 1; in snd_interval_mulkdiv()
789 c->openmax = (a->openmax || b->openmin); in snd_interval_mulkdiv()
791 c->max = UINT_MAX; in snd_interval_mulkdiv()
792 c->openmax = 0; in snd_interval_mulkdiv()
794 c->integer = 0; in snd_interval_mulkdiv()
797 /* ---- */
801 * snd_interval_ratnum - refine the interval value
825 unsigned int num = rats[k].num; in snd_interval_ratnum() local
827 unsigned int q = i->min; in snd_interval_ratnum()
831 den = div_up(num, q); in snd_interval_ratnum()
838 r = (den - rats[k].den_min) % rats[k].den_step; in snd_interval_ratnum()
840 den -= r; in snd_interval_ratnum()
842 diff = num - q * den; in snd_interval_ratnum()
844 diff = -diff; in snd_interval_ratnum()
849 best_num = num; in snd_interval_ratnum()
853 i->empty = 1; in snd_interval_ratnum()
854 return -EINVAL; in snd_interval_ratnum()
864 unsigned int num = rats[k].num; in snd_interval_ratnum() local
866 unsigned int q = i->max; in snd_interval_ratnum()
869 i->empty = 1; in snd_interval_ratnum()
870 return -EINVAL; in snd_interval_ratnum()
872 den = div_down(num, q); in snd_interval_ratnum()
879 r = (den - rats[k].den_min) % rats[k].den_step; in snd_interval_ratnum()
881 den += rats[k].den_step - r; in snd_interval_ratnum()
883 diff = q * den - num; in snd_interval_ratnum()
885 diff = -diff; in snd_interval_ratnum()
890 best_num = num; in snd_interval_ratnum()
894 i->empty = 1; in snd_interval_ratnum()
895 return -EINVAL; in snd_interval_ratnum()
919 * snd_interval_ratden - refine the interval value
941 unsigned int num; in snd_interval_ratden() local
943 unsigned int q = i->min; in snd_interval_ratden()
945 num = mul(q, den); in snd_interval_ratden()
946 if (num > rats[k].num_max) in snd_interval_ratden()
948 if (num < rats[k].num_min) in snd_interval_ratden()
949 num = rats[k].num_max; in snd_interval_ratden()
952 r = (num - rats[k].num_min) % rats[k].num_step; in snd_interval_ratden()
954 num += rats[k].num_step - r; in snd_interval_ratden()
956 diff = num - q * den; in snd_interval_ratden()
961 best_num = num; in snd_interval_ratden()
965 i->empty = 1; in snd_interval_ratden()
966 return -EINVAL; in snd_interval_ratden()
973 unsigned int num; in snd_interval_ratden() local
975 unsigned int q = i->max; in snd_interval_ratden()
977 num = mul(q, den); in snd_interval_ratden()
978 if (num < rats[k].num_min) in snd_interval_ratden()
980 if (num > rats[k].num_max) in snd_interval_ratden()
981 num = rats[k].num_max; in snd_interval_ratden()
984 r = (num - rats[k].num_min) % rats[k].num_step; in snd_interval_ratden()
986 num -= r; in snd_interval_ratden()
988 diff = q * den - num; in snd_interval_ratden()
993 best_num = num; in snd_interval_ratden()
997 i->empty = 1; in snd_interval_ratden()
998 return -EINVAL; in snd_interval_ratden()
1017 * snd_interval_list - refine the interval value from the list
1021 * @mask: the bit-mask to evaluate
1024 * When mask is non-zero, only the elements corresponding to bit 1 are
1037 i->empty = 1; in snd_interval_list()
1038 return -EINVAL; in snd_interval_list()
1056 * snd_interval_ranges - refine the interval value from the list of ranges
1060 * @mask: the bit-mask to evaluate
1063 * When mask is non-zero, only the elements corresponding to bit 1 are
1078 return -EINVAL; in snd_interval_ranges()
1113 n = i->min % step; in snd_interval_step()
1114 if (n != 0 || i->openmin) { in snd_interval_step()
1115 i->min += step - n; in snd_interval_step()
1116 i->openmin = 0; in snd_interval_step()
1119 n = i->max % step; in snd_interval_step()
1120 if (n != 0 || i->openmax) { in snd_interval_step()
1121 i->max -= n; in snd_interval_step()
1122 i->openmax = 0; in snd_interval_step()
1126 i->empty = 1; in snd_interval_step()
1127 return -EINVAL; in snd_interval_step()
1135 * snd_pcm_hw_rule_add - add the hw-constraint rule
1137 * @cond: condition bits
1150 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; in snd_pcm_hw_rule_add()
1155 if (constrs->rules_num >= constrs->rules_all) { in snd_pcm_hw_rule_add()
1157 unsigned int new_rules = constrs->rules_all + 16; in snd_pcm_hw_rule_add()
1158 new = krealloc_array(constrs->rules, new_rules, in snd_pcm_hw_rule_add()
1162 return -ENOMEM; in snd_pcm_hw_rule_add()
1164 constrs->rules = new; in snd_pcm_hw_rule_add()
1165 constrs->rules_all = new_rules; in snd_pcm_hw_rule_add()
1167 c = &constrs->rules[constrs->rules_num]; in snd_pcm_hw_rule_add()
1168 c->cond = cond; in snd_pcm_hw_rule_add()
1169 c->func = func; in snd_pcm_hw_rule_add()
1170 c->var = var; in snd_pcm_hw_rule_add()
1171 c->private = private; in snd_pcm_hw_rule_add()
1174 if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps))) { in snd_pcm_hw_rule_add()
1176 return -EINVAL; in snd_pcm_hw_rule_add()
1178 c->deps[k++] = dep; in snd_pcm_hw_rule_add()
1183 constrs->rules_num++; in snd_pcm_hw_rule_add()
1190 * snd_pcm_hw_constraint_mask - apply the given bitmap mask constraint
1195 * Apply the constraint of the given bitmap mask to a 32-bit mask parameter.
1202 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; in snd_pcm_hw_constraint_mask()
1204 *maskp->bits &= mask; in snd_pcm_hw_constraint_mask()
1205 memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */ in snd_pcm_hw_constraint_mask()
1206 if (*maskp->bits == 0) in snd_pcm_hw_constraint_mask()
1207 return -EINVAL; in snd_pcm_hw_constraint_mask()
1212 * snd_pcm_hw_constraint_mask64 - apply the given bitmap mask constraint
1217 * Apply the constraint of the given bitmap mask to a 64-bit mask parameter.
1224 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; in snd_pcm_hw_constraint_mask64()
1226 maskp->bits[0] &= (u_int32_t)mask; in snd_pcm_hw_constraint_mask64()
1227 maskp->bits[1] &= (u_int32_t)(mask >> 32); in snd_pcm_hw_constraint_mask64()
1228 memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */ in snd_pcm_hw_constraint_mask64()
1229 if (! maskp->bits[0] && ! maskp->bits[1]) in snd_pcm_hw_constraint_mask64()
1230 return -EINVAL; in snd_pcm_hw_constraint_mask64()
1236 * snd_pcm_hw_constraint_integer - apply an integer constraint to an interval
1247 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; in snd_pcm_hw_constraint_integer()
1253 * snd_pcm_hw_constraint_minmax - apply a min/max range constraint to an interval
1267 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; in snd_pcm_hw_constraint_minmax()
1280 struct snd_pcm_hw_constraint_list *list = rule->private; in snd_pcm_hw_rule_list()
1281 …return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask… in snd_pcm_hw_rule_list()
1286 * snd_pcm_hw_constraint_list - apply a list of constraints to a parameter
1288 * @cond: condition bits
1303 var, -1); in snd_pcm_hw_constraint_list()
1310 struct snd_pcm_hw_constraint_ranges *r = rule->private; in snd_pcm_hw_rule_ranges()
1311 return snd_interval_ranges(hw_param_interval(params, rule->var), in snd_pcm_hw_rule_ranges()
1312 r->count, r->ranges, r->mask); in snd_pcm_hw_rule_ranges()
1317 * snd_pcm_hw_constraint_ranges - apply list of range constraints to a parameter
1319 * @cond: condition bits
1334 var, -1); in snd_pcm_hw_constraint_ranges()
1341 const struct snd_pcm_hw_constraint_ratnums *r = rule->private; in snd_pcm_hw_rule_ratnums()
1342 unsigned int num = 0, den = 0; in snd_pcm_hw_rule_ratnums() local
1344 err = snd_interval_ratnum(hw_param_interval(params, rule->var), in snd_pcm_hw_rule_ratnums()
1345 r->nrats, r->rats, &num, &den); in snd_pcm_hw_rule_ratnums()
1346 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) { in snd_pcm_hw_rule_ratnums()
1347 params->rate_num = num; in snd_pcm_hw_rule_ratnums()
1348 params->rate_den = den; in snd_pcm_hw_rule_ratnums()
1354 * snd_pcm_hw_constraint_ratnums - apply ratnums constraint to a parameter
1356 * @cond: condition bits
1369 var, -1); in snd_pcm_hw_constraint_ratnums()
1376 const struct snd_pcm_hw_constraint_ratdens *r = rule->private; in snd_pcm_hw_rule_ratdens()
1377 unsigned int num = 0, den = 0; in snd_pcm_hw_rule_ratdens() local
1378 int err = snd_interval_ratden(hw_param_interval(params, rule->var), in snd_pcm_hw_rule_ratdens()
1379 r->nrats, r->rats, &num, &den); in snd_pcm_hw_rule_ratdens()
1380 if (err >= 0 && den && rule->var == SNDRV_PCM_HW_PARAM_RATE) { in snd_pcm_hw_rule_ratdens()
1381 params->rate_num = num; in snd_pcm_hw_rule_ratdens()
1382 params->rate_den = den; in snd_pcm_hw_rule_ratdens()
1388 * snd_pcm_hw_constraint_ratdens - apply ratdens constraint to a parameter
1390 * @cond: condition bits
1403 var, -1); in snd_pcm_hw_constraint_ratdens()
1410 unsigned int l = (unsigned long) rule->private; in snd_pcm_hw_rule_msbits()
1421 params->msbits = min_not_zero(params->msbits, msbits); in snd_pcm_hw_rule_msbits()
1427 * snd_pcm_hw_constraint_msbits - add a hw constraint msbits rule
1429 * @cond: condition bits
1430 * @width: sample bits width
1433 * This constraint will set the number of most significant bits (msbits) if a
1446 return snd_pcm_hw_rule_add(runtime, cond, -1, in snd_pcm_hw_constraint_msbits()
1449 SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); in snd_pcm_hw_constraint_msbits()
1456 unsigned long step = (unsigned long) rule->private; in snd_pcm_hw_rule_step()
1457 return snd_interval_step(hw_param_interval(params, rule->var), step); in snd_pcm_hw_rule_step()
1461 * snd_pcm_hw_constraint_step - add a hw constraint step rule
1463 * @cond: condition bits
1476 var, -1); in snd_pcm_hw_constraint_step()
1488 return snd_interval_list(hw_param_interval(params, rule->var), in snd_pcm_hw_rule_pow2()
1493 * snd_pcm_hw_constraint_pow2 - add a hw constraint power-of-2 rule
1495 * @cond: condition bits
1496 * @var: hw_params variable to apply the power-of-2 constraint
1506 var, -1); in snd_pcm_hw_constraint_pow2()
1513 unsigned int base_rate = (unsigned int)(uintptr_t)rule->private; in snd_pcm_hw_rule_noresample_func()
1521 * snd_pcm_hw_rule_noresample - add a rule to allow disabling hw resampling
1534 SNDRV_PCM_HW_PARAM_RATE, -1); in snd_pcm_hw_rule_noresample()
1543 params->cmask |= 1 << var; in _snd_pcm_hw_param_any()
1544 params->rmask |= 1 << var; in _snd_pcm_hw_param_any()
1549 params->cmask |= 1 << var; in _snd_pcm_hw_param_any()
1550 params->rmask |= 1 << var; in _snd_pcm_hw_param_any()
1564 params->info = ~0U; in _snd_pcm_hw_params_any()
1569 * snd_pcm_hw_param_value - return @params field @var value
1572 * @dir: pointer to the direction (-1,0,1) or %NULL
1575 * defined by @params. -%EINVAL otherwise.
1583 return -EINVAL; in snd_pcm_hw_param_value()
1591 return -EINVAL; in snd_pcm_hw_param_value()
1593 *dir = i->openmin; in snd_pcm_hw_param_value()
1596 return -EINVAL; in snd_pcm_hw_param_value()
1605 params->cmask |= 1 << var; in _snd_pcm_hw_param_setempty()
1606 params->rmask |= 1 << var; in _snd_pcm_hw_param_setempty()
1609 params->cmask |= 1 << var; in _snd_pcm_hw_param_setempty()
1610 params->rmask |= 1 << var; in _snd_pcm_hw_param_setempty()
1626 return -EINVAL; in _snd_pcm_hw_param_first()
1628 params->cmask |= 1 << var; in _snd_pcm_hw_param_first()
1629 params->rmask |= 1 << var; in _snd_pcm_hw_param_first()
1636 * snd_pcm_hw_param_first - refine config space and return minimum value
1640 * @dir: pointer to the direction (-1,0,1) or %NULL
1654 if (params->rmask) { in snd_pcm_hw_param_first()
1672 return -EINVAL; in _snd_pcm_hw_param_last()
1674 params->cmask |= 1 << var; in _snd_pcm_hw_param_last()
1675 params->rmask |= 1 << var; in _snd_pcm_hw_param_last()
1682 * snd_pcm_hw_param_last - refine config space and return maximum value
1686 * @dir: pointer to the direction (-1,0,1) or %NULL
1700 if (params->rmask) { in snd_pcm_hw_param_last()
1710 * snd_pcm_hw_params_bits - Get the number of bits per the sample.
1713 * Return: The number of bits per sample based on the format,
1746 struct snd_pcm_runtime *runtime = substream->runtime; in snd_pcm_lib_ioctl_reset()
1751 runtime->status->hw_ptr %= runtime->buffer_size; in snd_pcm_lib_ioctl_reset()
1753 runtime->status->hw_ptr = 0; in snd_pcm_lib_ioctl_reset()
1754 runtime->hw_ptr_wrap = 0; in snd_pcm_lib_ioctl_reset()
1764 struct snd_pcm_runtime *runtime = substream->runtime; in snd_pcm_lib_ioctl_channel_info()
1766 if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) { in snd_pcm_lib_ioctl_channel_info()
1767 info->offset = -1; in snd_pcm_lib_ioctl_channel_info()
1770 width = snd_pcm_format_physical_width(runtime->format); in snd_pcm_lib_ioctl_channel_info()
1773 info->offset = 0; in snd_pcm_lib_ioctl_channel_info()
1774 switch (runtime->access) { in snd_pcm_lib_ioctl_channel_info()
1777 info->first = info->channel * width; in snd_pcm_lib_ioctl_channel_info()
1778 info->step = runtime->channels * width; in snd_pcm_lib_ioctl_channel_info()
1783 size_t size = runtime->dma_bytes / runtime->channels; in snd_pcm_lib_ioctl_channel_info()
1784 info->first = info->channel * size * 8; in snd_pcm_lib_ioctl_channel_info()
1785 info->step = width; in snd_pcm_lib_ioctl_channel_info()
1803 params->fifo_size = substream->runtime->hw.fifo_size; in snd_pcm_lib_ioctl_fifo_size()
1804 if (!(substream->runtime->hw.info & SNDRV_PCM_INFO_FIFO_IN_FRAMES)) { in snd_pcm_lib_ioctl_fifo_size()
1809 params->fifo_size /= frame_size; in snd_pcm_lib_ioctl_fifo_size()
1815 * snd_pcm_lib_ioctl - a generic PCM ioctl callback
1836 return -ENXIO; in snd_pcm_lib_ioctl()
1841 * snd_pcm_period_elapsed_under_stream_lock() - update the status of runtime for the next period
1861 …* - .pointer - to retrieve current position of audio data transmission by frame count or XRUN stat…
1862 * - .trigger - with SNDRV_PCM_TRIGGER_STOP at XRUN or DRAINING state.
1863 * - .get_time_info - to retrieve audio time stamp if needed.
1873 runtime = substream->runtime; in snd_pcm_period_elapsed_under_stream_lock()
1880 if (substream->timer_running) in snd_pcm_period_elapsed_under_stream_lock()
1881 snd_timer_interrupt(substream->timer, 1); in snd_pcm_period_elapsed_under_stream_lock()
1884 snd_kill_fasync(runtime->fasync, SIGIO, POLL_IN); in snd_pcm_period_elapsed_under_stream_lock()
1889 * snd_pcm_period_elapsed() - update the status of runtime for the next period by acquiring lock of
1922 struct snd_pcm_runtime *runtime = substream->runtime; in wait_for_avail()
1923 int is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; in wait_for_avail()
1931 add_wait_queue(&runtime->tsleep, &wait); in wait_for_avail()
1933 if (runtime->no_period_wakeup) in wait_for_avail()
1937 if (substream->wait_time) { in wait_for_avail()
1938 wait_time = substream->wait_time; in wait_for_avail()
1942 if (runtime->rate) { in wait_for_avail()
1943 long t = runtime->buffer_size * 1100 / runtime->rate; in wait_for_avail()
1952 err = -ERESTARTSYS; in wait_for_avail()
1964 if (avail >= runtime->twake) in wait_for_avail()
1972 switch (runtime->state) { in wait_for_avail()
1974 err = -ESTRPIPE; in wait_for_avail()
1977 err = -EPIPE; in wait_for_avail()
1981 err = -EPIPE; in wait_for_avail()
1988 err = -EBADFD; in wait_for_avail()
1994 pcm_dbg(substream->pcm, in wait_for_avail()
1997 err = -EIO; in wait_for_avail()
2003 remove_wait_queue(&runtime->tsleep, &wait); in wait_for_avail()
2016 /* calculate the target DMA-buffer position to be written/read */
2020 return runtime->dma_area + hwoff + in get_dma_ptr()
2021 channel * (runtime->dma_bytes / runtime->channels); in get_dma_ptr()
2024 /* default copy ops for write; used for both interleaved and non- modes */
2029 if (copy_from_iter(get_dma_ptr(substream->runtime, channel, hwoff), in default_write_copy()
2031 return -EFAULT; in default_write_copy()
2035 /* fill silence instead of copy data; called as a transfer helper
2043 struct snd_pcm_runtime *runtime = substream->runtime; in fill_silence()
2045 if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) in fill_silence()
2047 if (substream->ops->fill_silence) in fill_silence()
2048 return substream->ops->fill_silence(substream, channel, in fill_silence()
2051 snd_pcm_format_set_silence(runtime->format, in fill_silence()
2057 /* default copy ops for read; used for both interleaved and non- modes */
2062 if (copy_to_iter(get_dma_ptr(substream->runtime, channel, hwoff), in default_read_copy()
2064 return -EFAULT; in default_read_copy()
2068 /* call transfer with the filled iov_iter */
2071 pcm_transfer_f transfer, bool in_kernel) in do_transfer() argument
2076 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) in do_transfer()
2085 return transfer(substream, c, hwoff, &iter, bytes); in do_transfer()
2091 return transfer(substream, c, hwoff, &iter, bytes); in do_transfer()
2094 /* call transfer function with the converted pointers and sizes;
2101 pcm_transfer_f transfer, in interleaved_copy() argument
2104 struct snd_pcm_runtime *runtime = substream->runtime; in interleaved_copy()
2111 return do_transfer(substream, 0, hwoff, data + off, frames, transfer, in interleaved_copy()
2115 /* call transfer function with the converted pointers and sizes for each
2116 * non-interleaved channel; when buffer is NULL, silencing instead of copying
2122 pcm_transfer_f transfer, in noninterleaved_copy() argument
2125 struct snd_pcm_runtime *runtime = substream->runtime; in noninterleaved_copy()
2126 int channels = runtime->channels; in noninterleaved_copy()
2131 * in non-interleaved mode, we copy for each channel, thus in noninterleaved_copy()
2142 frames, transfer, in_kernel); in noninterleaved_copy()
2155 if (substream->runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED || in fill_silence_frames()
2156 substream->runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) in fill_silence_frames()
2164 /* sanity-check for read/write methods */
2169 return -ENXIO; in pcm_sanity_check()
2170 runtime = substream->runtime; in pcm_sanity_check()
2171 if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area)) in pcm_sanity_check()
2172 return -EINVAL; in pcm_sanity_check()
2173 if (runtime->state == SNDRV_PCM_STATE_OPEN) in pcm_sanity_check()
2174 return -EBADFD; in pcm_sanity_check()
2180 switch (runtime->state) { in pcm_accessible_state()
2186 return -EPIPE; in pcm_accessible_state()
2188 return -ESTRPIPE; in pcm_accessible_state()
2190 return -EBADFD; in pcm_accessible_state()
2200 struct snd_pcm_runtime *runtime = substream->runtime; in pcm_lib_apply_appl_ptr()
2201 snd_pcm_uframes_t old_appl_ptr = runtime->control->appl_ptr; in pcm_lib_apply_appl_ptr()
2208 if (appl_ptr >= runtime->boundary) in pcm_lib_apply_appl_ptr()
2209 return -EINVAL; in pcm_lib_apply_appl_ptr()
2213 if (substream->runtime->info & SNDRV_PCM_INFO_NO_REWINDS) { in pcm_lib_apply_appl_ptr()
2214 diff = appl_ptr - old_appl_ptr; in pcm_lib_apply_appl_ptr()
2216 if (diff > runtime->buffer_size) in pcm_lib_apply_appl_ptr()
2217 return -EINVAL; in pcm_lib_apply_appl_ptr()
2219 if (runtime->boundary + diff > runtime->buffer_size) in pcm_lib_apply_appl_ptr()
2220 return -EINVAL; in pcm_lib_apply_appl_ptr()
2224 runtime->control->appl_ptr = appl_ptr; in pcm_lib_apply_appl_ptr()
2225 if (substream->ops->ack) { in pcm_lib_apply_appl_ptr()
2226 ret = substream->ops->ack(substream); in pcm_lib_apply_appl_ptr()
2228 runtime->control->appl_ptr = old_appl_ptr; in pcm_lib_apply_appl_ptr()
2229 if (ret == -EPIPE) in pcm_lib_apply_appl_ptr()
2245 struct snd_pcm_runtime *runtime = substream->runtime; in __snd_pcm_lib_xfer()
2250 pcm_transfer_f transfer; in __snd_pcm_lib_xfer() local
2259 is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; in __snd_pcm_lib_xfer()
2261 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && in __snd_pcm_lib_xfer()
2262 runtime->channels > 1) in __snd_pcm_lib_xfer()
2263 return -EINVAL; in __snd_pcm_lib_xfer()
2266 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) in __snd_pcm_lib_xfer()
2267 return -EINVAL; in __snd_pcm_lib_xfer()
2273 transfer = fill_silence; in __snd_pcm_lib_xfer()
2275 return -EINVAL; in __snd_pcm_lib_xfer()
2277 if (substream->ops->copy) in __snd_pcm_lib_xfer()
2278 transfer = substream->ops->copy; in __snd_pcm_lib_xfer()
2280 transfer = is_playback ? in __snd_pcm_lib_xfer()
2287 nonblock = !!(substream->f_flags & O_NONBLOCK); in __snd_pcm_lib_xfer()
2294 runtime->twake = runtime->control->avail_min ? : 1; in __snd_pcm_lib_xfer()
2295 if (runtime->state == SNDRV_PCM_STATE_RUNNING) in __snd_pcm_lib_xfer()
2303 runtime->state == SNDRV_PCM_STATE_PREPARED && in __snd_pcm_lib_xfer()
2304 size >= runtime->start_threshold) { in __snd_pcm_lib_xfer()
2317 runtime->state == SNDRV_PCM_STATE_DRAINING) { in __snd_pcm_lib_xfer()
2322 err = -EAGAIN; in __snd_pcm_lib_xfer()
2325 runtime->twake = min_t(snd_pcm_uframes_t, size, in __snd_pcm_lib_xfer()
2326 runtime->control->avail_min ? : 1); in __snd_pcm_lib_xfer()
2334 appl_ptr = READ_ONCE(runtime->control->appl_ptr); in __snd_pcm_lib_xfer()
2335 appl_ofs = appl_ptr % runtime->buffer_size; in __snd_pcm_lib_xfer()
2336 cont = runtime->buffer_size - appl_ofs; in __snd_pcm_lib_xfer()
2340 err = -EINVAL; in __snd_pcm_lib_xfer()
2343 if (!atomic_inc_unless_negative(&runtime->buffer_accessing)) { in __snd_pcm_lib_xfer()
2344 err = -EBUSY; in __snd_pcm_lib_xfer()
2351 transfer, in_kernel); in __snd_pcm_lib_xfer()
2355 atomic_dec(&runtime->buffer_accessing); in __snd_pcm_lib_xfer()
2362 if (appl_ptr >= runtime->boundary) in __snd_pcm_lib_xfer()
2363 appl_ptr -= runtime->boundary; in __snd_pcm_lib_xfer()
2369 size -= frames; in __snd_pcm_lib_xfer()
2371 avail -= frames; in __snd_pcm_lib_xfer()
2373 runtime->state == SNDRV_PCM_STATE_PREPARED && in __snd_pcm_lib_xfer()
2374 snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) { in __snd_pcm_lib_xfer()
2381 runtime->twake = 0; in __snd_pcm_lib_xfer()
2393 /* default channel maps for multi-channel playbacks, up to 8 channels */
2415 /* alternative channel maps with CLFE <-> surround swapped for 6/8 channels */
2439 if (ch > info->max_channels) in valid_chmap_channels()
2441 return !info->channel_mask || (info->channel_mask & (1U << ch)); in valid_chmap_channels()
2449 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; in pcm_chmap_ctl_info()
2450 uinfo->count = info->max_channels; in pcm_chmap_ctl_info()
2451 uinfo->value.integer.min = 0; in pcm_chmap_ctl_info()
2452 uinfo->value.integer.max = SNDRV_CHMAP_LAST; in pcm_chmap_ctl_info()
2463 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); in pcm_chmap_ctl_get()
2467 if (!info->chmap) in pcm_chmap_ctl_get()
2468 return -EINVAL; in pcm_chmap_ctl_get()
2471 return -ENODEV; in pcm_chmap_ctl_get()
2472 memset(ucontrol->value.integer.value, 0, in pcm_chmap_ctl_get()
2473 sizeof(long) * info->max_channels); in pcm_chmap_ctl_get()
2474 if (!substream->runtime) in pcm_chmap_ctl_get()
2476 for (map = info->chmap; map->channels; map++) { in pcm_chmap_ctl_get()
2478 if (map->channels == substream->runtime->channels && in pcm_chmap_ctl_get()
2479 valid_chmap_channels(info, map->channels)) { in pcm_chmap_ctl_get()
2480 for (i = 0; i < map->channels; i++) in pcm_chmap_ctl_get()
2481 ucontrol->value.integer.value[i] = map->map[i]; in pcm_chmap_ctl_get()
2485 return -EINVAL; in pcm_chmap_ctl_get()
2489 * expands the pre-defined channel maps in a form of TLV
2499 if (!info->chmap) in pcm_chmap_ctl_tlv()
2500 return -EINVAL; in pcm_chmap_ctl_tlv()
2502 return -ENOMEM; in pcm_chmap_ctl_tlv()
2504 return -EFAULT; in pcm_chmap_ctl_tlv()
2505 size -= 8; in pcm_chmap_ctl_tlv()
2507 for (map = info->chmap; map->channels; map++) { in pcm_chmap_ctl_tlv()
2508 int chs_bytes = map->channels * 4; in pcm_chmap_ctl_tlv()
2509 if (!valid_chmap_channels(info, map->channels)) in pcm_chmap_ctl_tlv()
2512 return -ENOMEM; in pcm_chmap_ctl_tlv()
2515 return -EFAULT; in pcm_chmap_ctl_tlv()
2517 size -= 8; in pcm_chmap_ctl_tlv()
2520 return -ENOMEM; in pcm_chmap_ctl_tlv()
2521 size -= chs_bytes; in pcm_chmap_ctl_tlv()
2523 for (c = 0; c < map->channels; c++) { in pcm_chmap_ctl_tlv()
2524 if (put_user(map->map[c], dst)) in pcm_chmap_ctl_tlv()
2525 return -EFAULT; in pcm_chmap_ctl_tlv()
2530 return -EFAULT; in pcm_chmap_ctl_tlv()
2537 info->pcm->streams[info->stream].chmap_kctl = NULL; in pcm_chmap_ctl_private_free()
2542 * snd_pcm_add_chmap_ctls - create channel-mapping control elements
2548 * @info_ret: store struct snd_pcm_chmap instance if non-NULL
2550 * Create channel-mapping control elements assigned to the given PCM stream(s).
2571 if (WARN_ON(pcm->streams[stream].chmap_kctl)) in snd_pcm_add_chmap_ctls()
2572 return -EBUSY; in snd_pcm_add_chmap_ctls()
2575 return -ENOMEM; in snd_pcm_add_chmap_ctls()
2576 info->pcm = pcm; in snd_pcm_add_chmap_ctls()
2577 info->stream = stream; in snd_pcm_add_chmap_ctls()
2578 info->chmap = chmap; in snd_pcm_add_chmap_ctls()
2579 info->max_channels = max_channels; in snd_pcm_add_chmap_ctls()
2584 knew.device = pcm->device; in snd_pcm_add_chmap_ctls()
2585 knew.count = pcm->streams[stream].substream_count; in snd_pcm_add_chmap_ctls()
2587 info->kctl = snd_ctl_new1(&knew, info); in snd_pcm_add_chmap_ctls()
2588 if (!info->kctl) { in snd_pcm_add_chmap_ctls()
2590 return -ENOMEM; in snd_pcm_add_chmap_ctls()
2592 info->kctl->private_free = pcm_chmap_ctl_private_free; in snd_pcm_add_chmap_ctls()
2593 err = snd_ctl_add(pcm->card, info->kctl); in snd_pcm_add_chmap_ctls()
2596 pcm->streams[stream].chmap_kctl = info->kctl; in snd_pcm_add_chmap_ctls()