Lines Matching refs:stream
52 struct snd_compr_stream stream;
58 * a note on stream states used:
60 * SNDRV_PCM_STATE_OPEN: When stream has been opened.
61 * SNDRV_PCM_STATE_SETUP: When stream has been initialized. This is done by
64 * SNDRV_PCM_STATE_PREPARED: When a stream has been written to (for
65 * playback only). User after setting up stream writes the data buffer
66 * before starting the stream.
67 * SNDRV_PCM_STATE_RUNNING: When stream has been started and is
69 * SNDRV_PCM_STATE_DRAINING: When stream is draining current data. This is done
71 * SNDRV_PCM_STATE_PAUSED: When stream is paused. This is done by calling
114 INIT_DELAYED_WORK(&data->stream.error_work, error_delayed_work);
116 data->stream.ops = compr->ops;
117 data->stream.direction = dirn;
118 data->stream.private_data = compr->private_data;
119 data->stream.device = compr;
128 data->stream.runtime = runtime;
131 ret = compr->ops->open(&data->stream);
143 struct snd_compr_runtime *runtime = data->stream.runtime;
145 cancel_delayed_work_sync(&data->stream.error_work);
151 data->stream.ops->trigger(&data->stream, SNDRV_PCM_TRIGGER_STOP);
157 data->stream.ops->free(&data->stream);
158 if (!data->stream.runtime->dma_buffer_p)
159 kfree(data->stream.runtime->buffer);
160 kfree(data->stream.runtime);
165 static int snd_compr_update_tstamp(struct snd_compr_stream *stream,
168 if (!stream->ops->pointer)
170 stream->ops->pointer(stream, tstamp);
173 if (stream->direction == SND_COMPRESS_PLAYBACK)
174 stream->runtime->total_bytes_transferred = tstamp->copied_total;
176 stream->runtime->total_bytes_available = tstamp->copied_total;
180 static size_t snd_compr_calc_avail(struct snd_compr_stream *stream,
184 snd_compr_update_tstamp(stream, &avail->tstamp);
187 if (stream->runtime->total_bytes_available == 0 &&
188 stream->runtime->state == SNDRV_PCM_STATE_SETUP &&
189 stream->direction == SND_COMPRESS_PLAYBACK) {
191 return stream->runtime->buffer_size;
194 stream->runtime->total_bytes_available,
195 stream->runtime->total_bytes_transferred);
196 if (stream->runtime->total_bytes_available ==
197 stream->runtime->total_bytes_transferred) {
198 if (stream->direction == SND_COMPRESS_PLAYBACK) {
200 return stream->runtime->buffer_size;
207 avail->avail = stream->runtime->total_bytes_available -
208 stream->runtime->total_bytes_transferred;
209 if (stream->direction == SND_COMPRESS_PLAYBACK)
210 avail->avail = stream->runtime->buffer_size - avail->avail;
216 static inline size_t snd_compr_get_avail(struct snd_compr_stream *stream)
220 return snd_compr_calc_avail(stream, &avail);
224 snd_compr_ioctl_avail(struct snd_compr_stream *stream, unsigned long arg)
229 avail = snd_compr_calc_avail(stream, &ioctl_avail);
232 switch (stream->runtime->state) {
247 static int snd_compr_write_data(struct snd_compr_stream *stream,
252 struct snd_compr_runtime *runtime = stream->runtime;
273 if (stream->ops->ack)
274 stream->ops->ack(stream, count);
282 struct snd_compr_stream *stream;
289 stream = &data->stream;
290 guard(mutex)(&stream->device->lock);
291 /* write is allowed when stream is running or has been steup */
292 switch (stream->runtime->state) {
301 avail = snd_compr_get_avail(stream);
307 if (stream->ops->copy) {
309 retval = stream->ops->copy(stream, cbuf, avail);
311 retval = snd_compr_write_data(stream, buf, avail);
314 stream->runtime->total_bytes_available += retval;
316 /* while initiating the stream, write should be called before START
318 if (stream->runtime->state == SNDRV_PCM_STATE_SETUP) {
319 stream->runtime->state = SNDRV_PCM_STATE_PREPARED;
320 pr_debug("stream prepared, Houston we are good to go\n");
331 struct snd_compr_stream *stream;
338 stream = &data->stream;
339 guard(mutex)(&stream->device->lock);
341 /* read is allowed when stream is running, paused, draining and setup
345 switch (stream->runtime->state) {
355 avail = snd_compr_get_avail(stream);
361 if (stream->ops->copy)
362 retval = stream->ops->copy(stream, buf, avail);
366 stream->runtime->total_bytes_transferred += retval;
376 static __poll_t snd_compr_get_poll(struct snd_compr_stream *stream)
378 if (stream->direction == SND_COMPRESS_PLAYBACK)
387 struct snd_compr_stream *stream;
394 stream = &data->stream;
396 guard(mutex)(&stream->device->lock);
398 switch (stream->runtime->state) {
401 return snd_compr_get_poll(stream) | EPOLLERR;
406 poll_wait(f, &stream->runtime->sleep, wait);
408 avail = snd_compr_get_avail(stream);
411 switch (stream->runtime->state) {
413 /* stream has been woken up after drain is complete
414 * draining done so set stream state to stopped
416 retval = snd_compr_get_poll(stream);
417 stream->runtime->state = SNDRV_PCM_STATE_SETUP;
422 if (avail >= stream->runtime->fragment_size)
423 retval = snd_compr_get_poll(stream);
426 return snd_compr_get_poll(stream) | EPOLLERR;
433 snd_compr_get_caps(struct snd_compr_stream *stream, unsigned long arg)
438 if (!stream->ops->get_caps)
442 retval = stream->ops->get_caps(stream, &caps);
453 snd_compr_get_codec_caps(struct snd_compr_stream *stream, unsigned long arg)
458 if (!stream->ops->get_codec_caps)
465 retval = stream->ops->get_codec_caps(stream, caps);
474 int snd_compr_malloc_pages(struct snd_compr_stream *stream, size_t size)
479 if (snd_BUG_ON(!(stream) || !(stream)->runtime))
484 dmab->dev = stream->dma_buffer.dev;
491 snd_compr_set_runtime_buffer(stream, dmab);
492 stream->runtime->dma_bytes = size;
497 int snd_compr_free_pages(struct snd_compr_stream *stream)
501 if (snd_BUG_ON(!(stream) || !(stream)->runtime))
503 runtime = stream->runtime;
506 if (runtime->dma_buffer_p != &stream->dma_buffer) {
512 snd_compr_set_runtime_buffer(stream, NULL);
518 static int snd_compr_allocate_buffer(struct snd_compr_stream *stream,
525 if (stream->ops->copy) {
531 if (stream->runtime->dma_buffer_p) {
533 if (buffer_size > stream->runtime->dma_buffer_p->bytes)
534 dev_err(stream->device->dev,
537 buffer = stream->runtime->dma_buffer_p->area;
546 stream->runtime->fragment_size = params->buffer.fragment_size;
547 stream->runtime->fragments = params->buffer.fragments;
548 stream->runtime->buffer = buffer;
549 stream->runtime->buffer_size = buffer_size;
572 snd_compr_set_params(struct snd_compr_stream *stream, unsigned long arg)
577 if (stream->runtime->state == SNDRV_PCM_STATE_OPEN || stream->next_track) {
579 * we should allow parameter change only when stream has been
590 retval = snd_compr_allocate_buffer(stream, params);
594 retval = stream->ops->set_params(stream, params);
598 if (stream->next_track)
601 stream->metadata_set = false;
602 stream->next_track = false;
604 stream->runtime->state = SNDRV_PCM_STATE_SETUP;
612 snd_compr_get_params(struct snd_compr_stream *stream, unsigned long arg)
617 if (!stream->ops->get_params)
623 retval = stream->ops->get_params(stream, params);
632 snd_compr_get_metadata(struct snd_compr_stream *stream, unsigned long arg)
637 if (!stream->ops->get_metadata)
643 retval = stream->ops->get_metadata(stream, &metadata);
654 snd_compr_set_metadata(struct snd_compr_stream *stream, unsigned long arg)
659 if (!stream->ops->set_metadata)
662 * we should allow parameter change only when stream has been
668 retval = stream->ops->set_metadata(stream, &metadata);
669 stream->metadata_set = true;
675 snd_compr_tstamp(struct snd_compr_stream *stream, unsigned long arg)
680 ret = snd_compr_update_tstamp(stream, &tstamp);
687 static int snd_compr_pause(struct snd_compr_stream *stream)
691 switch (stream->runtime->state) {
693 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
695 stream->runtime->state = SNDRV_PCM_STATE_PAUSED;
698 if (!stream->device->use_pause_in_draining)
700 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
702 stream->pause_in_draining = true;
710 static int snd_compr_resume(struct snd_compr_stream *stream)
714 switch (stream->runtime->state) {
716 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
718 stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
721 if (!stream->pause_in_draining)
723 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
725 stream->pause_in_draining = false;
733 static int snd_compr_start(struct snd_compr_stream *stream)
737 switch (stream->runtime->state) {
739 if (stream->direction != SND_COMPRESS_CAPTURE)
748 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_START);
750 stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
754 static int snd_compr_stop(struct snd_compr_stream *stream)
758 switch (stream->runtime->state) {
767 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
770 stream->partial_drain = false;
771 stream->metadata_set = false;
772 stream->pause_in_draining = false;
773 snd_compr_drain_notify(stream);
774 stream->runtime->total_bytes_available = 0;
775 stream->runtime->total_bytes_transferred = 0;
782 struct snd_compr_stream *stream;
784 stream = container_of(work, struct snd_compr_stream, error_work.work);
786 guard(mutex)(&stream->device->lock);
788 stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
789 wake_up(&stream->runtime->sleep);
793 * snd_compr_stop_error: Report a fatal error on a stream
794 * @stream: pointer to stream
795 * @state: state to transition the stream to
797 * Stop the stream and set its state.
803 int snd_compr_stop_error(struct snd_compr_stream *stream,
806 if (stream->runtime->state == state)
809 stream->runtime->state = state;
813 queue_delayed_work(system_power_efficient_wq, &stream->error_work, 0);
819 static int snd_compress_wait_for_drain(struct snd_compr_stream *stream)
828 * stream will be moved to SETUP state, even if draining resulted in an
831 stream->runtime->state = SNDRV_PCM_STATE_DRAINING;
832 mutex_unlock(&stream->device->lock);
840 ret = wait_event_interruptible(stream->runtime->sleep,
841 (stream->runtime->state != SNDRV_PCM_STATE_DRAINING));
848 wake_up(&stream->runtime->sleep);
849 mutex_lock(&stream->device->lock);
854 static int snd_compr_drain(struct snd_compr_stream *stream)
858 switch (stream->runtime->state) {
870 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_DRAIN);
873 wake_up(&stream->runtime->sleep);
877 return snd_compress_wait_for_drain(stream);
880 static int snd_compr_next_track(struct snd_compr_stream *stream)
884 /* only a running stream can transition to next track */
885 if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING)
889 if (stream->direction == SND_COMPRESS_CAPTURE)
892 /* you can signal next track if this is intended to be a gapless stream
895 if (stream->metadata_set == false)
898 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_NEXT_TRACK);
901 stream->metadata_set = false;
902 stream->next_track = true;
906 static int snd_compr_partial_drain(struct snd_compr_stream *stream)
910 switch (stream->runtime->state) {
923 if (stream->direction == SND_COMPRESS_CAPTURE)
926 /* stream can be drained only when next track has been signalled */
927 if (stream->next_track == false)
930 stream->partial_drain = true;
931 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_PARTIAL_DRAIN);
934 wake_up(&stream->runtime->sleep);
938 stream->next_track = false;
939 return snd_compress_wait_for_drain(stream);
945 struct snd_compr_stream *stream;
950 stream = &data->stream;
952 guard(mutex)(&stream->device->lock);
958 return snd_compr_get_caps(stream, arg);
961 return snd_compr_get_codec_caps(stream, arg);
964 return snd_compr_set_params(stream, arg);
966 return snd_compr_get_params(stream, arg);
968 return snd_compr_set_metadata(stream, arg);
970 return snd_compr_get_metadata(stream, arg);
972 return snd_compr_tstamp(stream, arg);
974 return snd_compr_ioctl_avail(stream, arg);
976 return snd_compr_pause(stream);
978 return snd_compr_resume(stream);
980 return snd_compr_start(stream);
982 return snd_compr_stop(stream);
984 return snd_compr_drain(stream);
986 return snd_compr_partial_drain(stream);
988 return snd_compr_next_track(stream);
1057 snd_iprintf(buffer, "stream: %s\n",