Lines Matching refs:runtime
94 struct snd_pcm_runtime *runtime;
111 runtime = substream->runtime;
112 if (runtime) {
113 info->sync = runtime->sync;
167 struct snd_pcm_hw_constraints *constrs = &substream->runtime->hw_constraints;
313 hw = &substream->runtime->hw;
349 static int period_to_usecs(struct snd_pcm_runtime *runtime)
353 if (! runtime->rate)
357 usecs = (750000 / runtime->rate) * runtime->period_size;
358 usecs += ((750000 % runtime->rate) * runtime->period_size) /
359 runtime->rate;
367 struct snd_pcm_runtime *runtime;
373 runtime = substream->runtime;
374 snd_assert(runtime != NULL, return -ENXIO);
376 switch (runtime->status->state) {
407 runtime->access = params_access(params);
408 runtime->format = params_format(params);
409 runtime->subformat = params_subformat(params);
410 runtime->channels = params_channels(params);
411 runtime->rate = params_rate(params);
412 runtime->period_size = params_period_size(params);
413 runtime->periods = params_periods(params);
414 runtime->buffer_size = params_buffer_size(params);
415 runtime->tick_time = params_tick_time(params);
416 runtime->info = params->info;
417 runtime->rate_num = params->rate_num;
418 runtime->rate_den = params->rate_den;
420 bits = snd_pcm_format_physical_width(runtime->format);
421 runtime->sample_bits = bits;
422 bits *= runtime->channels;
423 runtime->frame_bits = bits;
429 runtime->byte_align = bits / 8;
430 runtime->min_align = frames;
433 runtime->tstamp_mode = SNDRV_PCM_TSTAMP_NONE;
434 runtime->period_step = 1;
435 runtime->sleep_min = 0;
436 runtime->control->avail_min = runtime->period_size;
437 runtime->xfer_align = runtime->period_size;
438 runtime->start_threshold = 1;
439 runtime->stop_threshold = runtime->buffer_size;
440 runtime->silence_threshold = 0;
441 runtime->silence_size = 0;
442 runtime->boundary = runtime->buffer_size;
443 while (runtime->boundary * 2 <= LONG_MAX - runtime->buffer_size)
444 runtime->boundary *= 2;
447 runtime->status->state = SNDRV_PCM_STATE_SETUP;
450 if ((usecs = period_to_usecs(runtime)) >= 0)
457 runtime->status->state = SNDRV_PCM_STATE_OPEN;
490 struct snd_pcm_runtime *runtime;
494 runtime = substream->runtime;
495 snd_assert(runtime != NULL, return -ENXIO);
497 switch (runtime->status->state) {
510 runtime->status->state = SNDRV_PCM_STATE_OPEN;
518 struct snd_pcm_runtime *runtime;
521 runtime = substream->runtime;
522 snd_assert(runtime != NULL, return -ENXIO);
524 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
535 params->xfer_align % runtime->min_align != 0)
537 if (params->silence_size >= runtime->boundary) {
543 if (params->silence_threshold > runtime->buffer_size)
547 runtime->tstamp_mode = params->tstamp_mode;
548 runtime->sleep_min = params->sleep_min;
549 runtime->period_step = params->period_step;
550 runtime->control->avail_min = params->avail_min;
551 runtime->start_threshold = params->start_threshold;
552 runtime->stop_threshold = params->stop_threshold;
553 runtime->silence_threshold = params->silence_threshold;
554 runtime->silence_size = params->silence_size;
555 runtime->xfer_align = params->xfer_align;
556 params->boundary = runtime->boundary;
558 if (runtime->sleep_min)
563 runtime->silence_size > 0)
565 wake_up(&runtime->sleep);
587 struct snd_pcm_runtime *runtime = substream->runtime;
590 status->state = runtime->status->state;
591 status->suspended_state = runtime->status->suspended_state;
594 status->trigger_tstamp = runtime->trigger_tstamp;
597 if (runtime->tstamp_mode & SNDRV_PCM_TSTAMP_MMAP)
598 status->tstamp = runtime->status->tstamp;
603 status->appl_ptr = runtime->control->appl_ptr;
604 status->hw_ptr = runtime->status->hw_ptr;
606 status->avail = snd_pcm_playback_avail(runtime);
607 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
608 runtime->status->state == SNDRV_PCM_STATE_DRAINING)
609 status->delay = runtime->buffer_size - status->avail;
613 status->avail = snd_pcm_capture_avail(runtime);
614 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
619 status->avail_max = runtime->avail_max;
620 status->overrange = runtime->overrange;
621 runtime->avail_max = 0;
622 runtime->overrange = 0;
632 struct snd_pcm_runtime *runtime;
636 runtime = substream->runtime;
649 struct snd_pcm_runtime *runtime;
654 runtime = substream->runtime;
656 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
661 if (channel >= runtime->channels)
686 struct snd_pcm_runtime *runtime = substream->runtime;
687 if (runtime->trigger_master == NULL)
689 if (runtime->trigger_master == substream) {
690 getnstimeofday(&runtime->trigger_tstamp);
692 snd_pcm_trigger_tstamp(runtime->trigger_master);
693 runtime->trigger_tstamp = runtime->trigger_master->runtime->trigger_tstamp;
695 runtime->trigger_master = NULL;
846 struct snd_pcm_runtime *runtime = substream->runtime;
847 if (runtime->status->state != SNDRV_PCM_STATE_PREPARED)
852 runtime->trigger_master = substream;
858 if (substream->runtime->trigger_master != substream)
865 if (substream->runtime->trigger_master == substream)
871 struct snd_pcm_runtime *runtime = substream->runtime;
873 runtime->status->state = state;
875 runtime->silence_size > 0)
877 if (runtime->sleep_min)
881 &runtime->trigger_tstamp);
908 struct snd_pcm_runtime *runtime = substream->runtime;
909 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
911 runtime->trigger_master = substream;
917 if (substream->runtime->trigger_master == substream &&
925 struct snd_pcm_runtime *runtime = substream->runtime;
926 if (runtime->status->state != state) {
930 &runtime->trigger_tstamp);
931 runtime->status->state = state;
934 wake_up(&runtime->sleep);
977 struct snd_pcm_runtime *runtime = substream->runtime;
978 if (!(runtime->info & SNDRV_PCM_INFO_PAUSE))
981 if (runtime->status->state != SNDRV_PCM_STATE_RUNNING)
983 } else if (runtime->status->state != SNDRV_PCM_STATE_PAUSED)
985 runtime->trigger_master = substream;
991 if (substream->runtime->trigger_master != substream)
1000 if (substream->runtime->trigger_master == substream)
1008 struct snd_pcm_runtime *runtime = substream->runtime;
1011 runtime->status->state = SNDRV_PCM_STATE_PAUSED;
1015 &runtime->trigger_tstamp);
1017 wake_up(&runtime->sleep);
1019 runtime->status->state = SNDRV_PCM_STATE_RUNNING;
1020 if (runtime->sleep_min)
1025 &runtime->trigger_tstamp);
1049 struct snd_pcm_runtime *runtime = substream->runtime;
1050 if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1052 runtime->trigger_master = substream;
1058 struct snd_pcm_runtime *runtime = substream->runtime;
1059 if (runtime->trigger_master != substream)
1069 struct snd_pcm_runtime *runtime = substream->runtime;
1073 &runtime->trigger_tstamp);
1074 runtime->status->suspended_state = runtime->status->state;
1075 runtime->status->state = SNDRV_PCM_STATE_SUSPENDED;
1077 wake_up(&runtime->sleep);
1127 if (substream->runtime == NULL)
1143 struct snd_pcm_runtime *runtime = substream->runtime;
1144 if (!(runtime->info & SNDRV_PCM_INFO_RESUME))
1146 runtime->trigger_master = substream;
1152 struct snd_pcm_runtime *runtime = substream->runtime;
1153 if (runtime->trigger_master != substream)
1156 if (runtime->status->suspended_state != SNDRV_PCM_STATE_RUNNING &&
1157 (runtime->status->suspended_state != SNDRV_PCM_STATE_DRAINING ||
1165 if (substream->runtime->trigger_master == substream &&
1172 struct snd_pcm_runtime *runtime = substream->runtime;
1176 &runtime->trigger_tstamp);
1177 runtime->status->state = runtime->status->suspended_state;
1178 if (runtime->sleep_min)
1218 struct snd_pcm_runtime *runtime = substream->runtime;
1222 if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1229 switch (runtime->status->state) {
1250 struct snd_pcm_runtime *runtime = substream->runtime;
1251 switch (runtime->status->state) {
1264 struct snd_pcm_runtime *runtime = substream->runtime;
1268 // snd_assert(runtime->status->hw_ptr < runtime->buffer_size, );
1269 runtime->hw_ptr_base = 0;
1270 runtime->hw_ptr_interrupt = runtime->status->hw_ptr -
1271 runtime->status->hw_ptr % runtime->period_size;
1272 runtime->silence_start = runtime->status->hw_ptr;
1273 runtime->silence_filled = 0;
1279 struct snd_pcm_runtime *runtime = substream->runtime;
1280 runtime->control->appl_ptr = runtime->status->hw_ptr;
1282 runtime->silence_size > 0)
1304 struct snd_pcm_runtime *runtime = substream->runtime;
1305 if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1306 runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
1325 struct snd_pcm_runtime *runtime = substream->runtime;
1326 runtime->control->appl_ptr = runtime->status->hw_ptr;
1327 runtime->status->state = SNDRV_PCM_STATE_PREPARED;
1371 substream->runtime->trigger_master = substream;
1377 struct snd_pcm_runtime *runtime = substream->runtime;
1379 switch (runtime->status->state) {
1388 runtime->status->state = SNDRV_PCM_STATE_DRAINING;
1395 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING) {
1396 int state = snd_pcm_capture_avail(runtime) > 0 ?
1433 struct snd_pcm_runtime *runtime;
1441 runtime = substream->runtime;
1443 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1447 if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1470 runtime = s->runtime;
1475 add_wait_queue(&runtime->sleep, &d->wait);
1479 d->stop_threshold = runtime->stop_threshold;
1480 if (runtime->stop_threshold > runtime->buffer_size)
1481 runtime->stop_threshold = runtime->buffer_size;
1488 if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1506 runtime = drec[i].substream->runtime;
1507 if (runtime->status->state == SNDRV_PCM_STATE_DRAINING)
1520 if (substream->runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
1536 runtime = d->substream->runtime;
1537 remove_wait_queue(&runtime->sleep, &d->wait);
1538 runtime->stop_threshold = d->stop_threshold;
1555 struct snd_pcm_runtime *runtime;
1560 runtime = substream->runtime;
1563 if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1564 runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
1568 if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
1576 if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
1580 /* runtime->control->appl_ptr = runtime->status->hw_ptr; */
1630 if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN ||
1631 substream->runtime->status->state != substream1->runtime->status->state) {
1811 struct snd_pcm_runtime *runtime = substream->runtime;
1812 struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints;
1829 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
1834 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
1840 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
1845 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
1850 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
1855 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FRAME_BITS,
1860 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
1865 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1870 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1875 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS,
1880 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1885 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1890 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1895 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
1900 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
1905 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
1910 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
1915 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1920 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1925 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_TIME,
1935 struct snd_pcm_runtime *runtime = substream->runtime;
1936 struct snd_pcm_hardware *hw = &runtime->hw;
1952 err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask);
1955 err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats);
1958 err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD);
1961 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS,
1965 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
1969 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
1973 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS,
1977 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1981 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1987 if (runtime->dma_bytes) {
1988 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes);
1993 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
2000 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_TICK_TIME,
2002 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
2191 fasync_helper(-1, file, 0, &substream->runtime->fasync);
2205 struct snd_pcm_runtime *runtime = substream->runtime;
2214 switch (runtime->status->state) {
2230 hw_avail = snd_pcm_playback_hw_avail(runtime);
2238 frames -= frames % runtime->xfer_align;
2239 appl_ptr = runtime->control->appl_ptr - frames;
2241 appl_ptr += runtime->boundary;
2242 runtime->control->appl_ptr = appl_ptr;
2243 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING &&
2244 runtime->sleep_min)
2255 struct snd_pcm_runtime *runtime = substream->runtime;
2264 switch (runtime->status->state) {
2280 hw_avail = snd_pcm_capture_hw_avail(runtime);
2288 frames -= frames % runtime->xfer_align;
2289 appl_ptr = runtime->control->appl_ptr - frames;
2291 appl_ptr += runtime->boundary;
2292 runtime->control->appl_ptr = appl_ptr;
2293 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING &&
2294 runtime->sleep_min)
2305 struct snd_pcm_runtime *runtime = substream->runtime;
2314 switch (runtime->status->state) {
2331 avail = snd_pcm_playback_avail(runtime);
2339 frames -= frames % runtime->xfer_align;
2340 appl_ptr = runtime->control->appl_ptr + frames;
2341 if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2342 appl_ptr -= runtime->boundary;
2343 runtime->control->appl_ptr = appl_ptr;
2344 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING &&
2345 runtime->sleep_min)
2356 struct snd_pcm_runtime *runtime = substream->runtime;
2365 switch (runtime->status->state) {
2382 avail = snd_pcm_capture_avail(runtime);
2390 frames -= frames % runtime->xfer_align;
2391 appl_ptr = runtime->control->appl_ptr + frames;
2392 if (appl_ptr >= (snd_pcm_sframes_t)runtime->boundary)
2393 appl_ptr -= runtime->boundary;
2394 runtime->control->appl_ptr = appl_ptr;
2395 if (runtime->status->state == SNDRV_PCM_STATE_RUNNING &&
2396 runtime->sleep_min)
2406 struct snd_pcm_runtime *runtime = substream->runtime;
2410 switch (runtime->status->state) {
2437 struct snd_pcm_runtime *runtime = substream->runtime;
2442 switch (runtime->status->state) {
2454 n = snd_pcm_playback_hw_avail(runtime);
2456 n = snd_pcm_capture_avail(runtime);
2476 struct snd_pcm_runtime *runtime = substream->runtime;
2487 status = runtime->status;
2488 control = runtime->control;
2592 struct snd_pcm_runtime *runtime = substream->runtime;
2594 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2608 struct snd_pcm_runtime *runtime = substream->runtime;
2611 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2613 if (runtime->channels > 128)
2619 bufs = kmalloc(sizeof(void *) * runtime->channels, GFP_KERNEL);
2622 if (copy_from_user(bufs, xfern.bufs, sizeof(void *) * runtime->channels)) {
2672 struct snd_pcm_runtime *runtime = substream->runtime;
2674 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2688 struct snd_pcm_runtime *runtime = substream->runtime;
2691 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2693 if (runtime->channels > 128)
2699 bufs = kmalloc(sizeof(void *) * runtime->channels, GFP_KERNEL);
2702 if (copy_from_user(bufs, xfern.bufs, sizeof(void *) * runtime->channels)) {
2800 struct snd_pcm_runtime *runtime;
2806 runtime = substream->runtime;
2807 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2809 if (!frame_aligned(runtime, count))
2811 count = bytes_to_frames(runtime, count);
2814 result = frames_to_bytes(runtime, result);
2823 struct snd_pcm_runtime *runtime;
2829 runtime = substream->runtime;
2830 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
2834 if (!frame_aligned(runtime, count)) {
2838 count = bytes_to_frames(runtime, count);
2841 result = frames_to_bytes(runtime, result);
2852 struct snd_pcm_runtime *runtime;
2861 runtime = substream->runtime;
2862 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2864 if (nr_segs > 1024 || nr_segs != runtime->channels)
2866 if (!frame_aligned(runtime, iov->iov_len))
2868 frames = bytes_to_samples(runtime, iov->iov_len);
2876 result = frames_to_bytes(runtime, result);
2886 struct snd_pcm_runtime *runtime;
2895 runtime = substream->runtime;
2896 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
2900 if (nr_segs > 128 || nr_segs != runtime->channels ||
2901 !frame_aligned(runtime, iov->iov_len)) {
2905 frames = bytes_to_samples(runtime, iov->iov_len);
2913 result = frames_to_bytes(runtime, result);
2923 struct snd_pcm_runtime *runtime;
2931 runtime = substream->runtime;
2933 poll_wait(file, &runtime->sleep, wait);
2936 avail = snd_pcm_playback_avail(runtime);
2937 switch (runtime->status->state) {
2941 if (avail >= runtime->control->avail_min) {
2961 struct snd_pcm_runtime *runtime;
2969 runtime = substream->runtime;
2971 poll_wait(file, &runtime->sleep, wait);
2974 avail = snd_pcm_capture_avail(runtime);
2975 switch (runtime->status->state) {
2979 if (avail >= runtime->control->avail_min) {
3015 struct snd_pcm_runtime *runtime;
3020 runtime = substream->runtime;
3021 page = virt_to_page(runtime->status);
3036 struct snd_pcm_runtime *runtime;
3040 runtime = substream->runtime;
3041 snd_assert(runtime != NULL, return -EAGAIN);
3058 struct snd_pcm_runtime *runtime;
3063 runtime = substream->runtime;
3064 page = virt_to_page(runtime->control);
3079 struct snd_pcm_runtime *runtime;
3083 runtime = substream->runtime;
3084 snd_assert(runtime != NULL, return -EAGAIN);
3116 struct snd_pcm_runtime *runtime;
3124 runtime = substream->runtime;
3128 dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
3136 vaddr = runtime->dma_area + offset;
3190 (substream->runtime->dma_addr + offset) >> PAGE_SHIFT,
3206 struct snd_pcm_runtime *runtime;
3218 runtime = substream->runtime;
3219 snd_assert(runtime != NULL, return -EAGAIN);
3220 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3222 if (!(runtime->info & SNDRV_PCM_INFO_MMAP))
3224 if (runtime->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED ||
3225 runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
3229 dma_bytes = PAGE_ALIGN(runtime->dma_bytes);
3273 struct snd_pcm_runtime *runtime;
3279 runtime = substream->runtime;
3281 err = fasync_helper(fd, file, on, &runtime->fasync);