From b308b2c92f8e56708fc9dcb8c10522dde3cc8e66 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Tue, 7 Sep 2021 12:20:20 -0700 Subject: [PATCH 01/22] buffer: rename buffer_invalidate/writeback APIs Rename the buffer_invalidate/writeback APIs to buffer_stream_invalidate/writeback() to be more precise. Signed-off-by: Ranjani Sridharan --- src/audio/asrc/asrc.c | 5 ++--- src/audio/codec_adapter/codec_adapter.c | 6 +++--- src/audio/copier.c | 4 ++-- src/audio/crossover/crossover.c | 4 ++-- src/audio/dcblock/dcblock.c | 4 ++-- src/audio/drc/drc.c | 4 ++-- src/audio/eq_fir/eq_fir.c | 4 ++-- src/audio/eq_iir/eq_iir.c | 4 ++-- src/audio/google_hotword_detect.c | 2 +- src/audio/igo_nr/igo_nr.c | 4 ++-- src/audio/kpb.c | 6 +++--- src/audio/mixer.c | 6 +++--- src/audio/multiband_drc/multiband_drc.c | 4 ++-- src/audio/mux/mux.c | 8 ++++---- src/audio/rtnr/rtnr.c | 4 ++-- src/audio/selector/selector.c | 4 ++-- src/audio/smart_amp/smart_amp.c | 6 +++--- src/audio/src/src.c | 5 ++--- src/audio/tdfb/tdfb.c | 4 ++-- src/audio/tone.c | 2 +- src/audio/volume/volume.c | 4 ++-- src/include/sof/audio/buffer.h | 4 ++-- src/lib/dma.c | 4 ++-- src/samples/audio/detect_test.c | 2 +- src/samples/audio/smart_amp_test.c | 6 +++--- 25 files changed, 54 insertions(+), 56 deletions(-) diff --git a/src/audio/asrc/asrc.c b/src/audio/asrc/asrc.c index 8d4cf23deb40..52fd7db11cae 100644 --- a/src/audio/asrc/asrc.c +++ b/src/audio/asrc/asrc.c @@ -806,11 +806,10 @@ static void asrc_process(struct comp_dev *dev, struct comp_buffer *source, int produced = 0; /* consumed bytes are not known at this point */ - buffer_invalidate(source, source->stream.size); + buffer_stream_invalidate(source, source->stream.size); cd->asrc_func(dev, &source->stream, &sink->stream, &consumed, &produced); - buffer_writeback(sink, produced * - audio_stream_frame_bytes(&sink->stream)); + buffer_stream_writeback(sink, produced * audio_stream_frame_bytes(&sink->stream)); comp_dbg(dev, "asrc_copy(), consumed = %u, produced = %u", consumed, produced); diff --git a/src/audio/codec_adapter/codec_adapter.c b/src/audio/codec_adapter/codec_adapter.c index 1b8a9aebb293..dd8669c1435c 100644 --- a/src/audio/codec_adapter/codec_adapter.c +++ b/src/audio/codec_adapter/codec_adapter.c @@ -382,7 +382,7 @@ int codec_adapter_copy(struct comp_dev *dev) if (bytes_to_process < codec_buff_size) goto db_verify; - buffer_invalidate(source, codec_buff_size); + buffer_stream_invalidate(source, codec_buff_size); codec_adapter_copy_from_source_to_lib(&source->stream, &codec->cpd, codec_buff_size); codec->cpd.avail = codec_buff_size; @@ -411,7 +411,7 @@ int codec_adapter_copy(struct comp_dev *dev) if (local_buff->stream.free < get_output_bytes(dev)) goto db_verify; - buffer_invalidate(source, codec_buff_size); + buffer_stream_invalidate(source, codec_buff_size); codec_adapter_copy_from_source_to_lib(&source->stream, &codec->cpd, codec_buff_size); codec->cpd.avail = codec_buff_size; @@ -465,7 +465,7 @@ int codec_adapter_copy(struct comp_dev *dev) audio_stream_copy(&local_buff->stream, 0, &sink->stream, 0, copy_bytes / cd->stream_params.sample_container_bytes); - buffer_writeback(sink, copy_bytes); + buffer_stream_writeback(sink, copy_bytes); comp_update_buffer_produce(sink, copy_bytes); comp_update_buffer_consume(local_buff, copy_bytes); diff --git a/src/audio/copier.c b/src/audio/copier.c index 9c1bc8a829a6..eaaf1f808269 100644 --- a/src/audio/copier.c +++ b/src/audio/copier.c @@ -471,7 +471,7 @@ static int copier_copy(struct comp_dev *dev) sink_bytes = c.frames * c.sink_frame_bytes; i = IPC4_SINK_QUEUE_ID(sink->id); - buffer_invalidate(src, src_bytes); + buffer_stream_invalidate(src, src_bytes); cd->converter[i](&src->stream, 0, &sink->stream, 0, c.frames * sink->stream.channels); if (cd->attenuation > 0) { @@ -480,7 +480,7 @@ static int copier_copy(struct comp_dev *dev) return ret; } - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); comp_update_buffer_produce(sink, sink_bytes); } diff --git a/src/audio/crossover/crossover.c b/src/audio/crossover/crossover.c index f2a9966107b8..711f539fa02a 100644 --- a/src/audio/crossover/crossover.c +++ b/src/audio/crossover/crossover.c @@ -703,13 +703,13 @@ static int crossover_copy(struct comp_dev *dev) } /* Process crossover */ - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->crossover_process(dev, source, sinks, num_sinks, frames); for (i = 0; i < num_sinks; i++) { if (!sinks[i]) continue; - buffer_writeback(sinks[i], sinks_bytes[i]); + buffer_stream_writeback(sinks[i], sinks_bytes[i]); comp_update_buffer_produce(sinks[i], sinks_bytes[i]); } comp_update_buffer_consume(source, source_bytes); diff --git a/src/audio/dcblock/dcblock.c b/src/audio/dcblock/dcblock.c index f314d973682b..61454d1fafae 100644 --- a/src/audio/dcblock/dcblock.c +++ b/src/audio/dcblock/dcblock.c @@ -270,11 +270,11 @@ static void dcblock_process(struct comp_dev *dev, struct comp_buffer *source, { struct comp_data *cd = comp_get_drvdata(dev); - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->dcblock_func(dev, &source->stream, &sink->stream, frames); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* calc new free and available */ comp_update_buffer_consume(source, source_bytes); diff --git a/src/audio/drc/drc.c b/src/audio/drc/drc.c index 0bc1bdce48b4..4ffa8cb8cb13 100644 --- a/src/audio/drc/drc.c +++ b/src/audio/drc/drc.c @@ -309,11 +309,11 @@ static void drc_process(struct comp_dev *dev, struct comp_buffer *source, { struct drc_comp_data *cd = comp_get_drvdata(dev); - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->drc_func(dev, &source->stream, &sink->stream, frames); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* calc new free and available */ comp_update_buffer_consume(source, source_bytes); diff --git a/src/audio/eq_fir/eq_fir.c b/src/audio/eq_fir/eq_fir.c index 242cd01e4c1d..b462eb34536e 100644 --- a/src/audio/eq_fir/eq_fir.c +++ b/src/audio/eq_fir/eq_fir.c @@ -474,12 +474,12 @@ static void eq_fir_process(struct comp_dev *dev, struct comp_buffer *source, { struct comp_data *cd = comp_get_drvdata(dev); - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->eq_fir_func(cd->fir, &source->stream, &sink->stream, frames, source->stream.channels); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* calc new free and available */ comp_update_buffer_consume(source, source_bytes); diff --git a/src/audio/eq_iir/eq_iir.c b/src/audio/eq_iir/eq_iir.c index f7d008d35411..d01a593c4990 100644 --- a/src/audio/eq_iir/eq_iir.c +++ b/src/audio/eq_iir/eq_iir.c @@ -700,11 +700,11 @@ static void eq_iir_process(struct comp_dev *dev, struct comp_buffer *source, { struct comp_data *cd = comp_get_drvdata(dev); - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->eq_iir_func(dev, &source->stream, &sink->stream, frames); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* calc new free and available */ comp_update_buffer_consume(source, source_bytes); diff --git a/src/audio/google_hotword_detect.c b/src/audio/google_hotword_detect.c index d3a0d7b930fe..734f11cc0516 100644 --- a/src/audio/google_hotword_detect.c +++ b/src/audio/google_hotword_detect.c @@ -410,7 +410,7 @@ static int ghd_copy(struct comp_dev *dev) (uint32_t)stream->end_addr); /* copy and perform detection */ - buffer_invalidate(source, bytes); + buffer_stream_invalidate(source, bytes); tail_bytes = (char *)stream->end_addr - (char *)stream->r_ptr; if (bytes <= tail_bytes) diff --git a/src/audio/igo_nr/igo_nr.c b/src/audio/igo_nr/igo_nr.c index dde57ce10ea9..88257a6f5701 100755 --- a/src/audio/igo_nr/igo_nr.c +++ b/src/audio/igo_nr/igo_nr.c @@ -619,11 +619,11 @@ static void igo_nr_process(struct comp_dev *dev, uint32_t source_bytes = frames * cl->source_frame_bytes; uint32_t sink_bytes = frames * cl->sink_frame_bytes; - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->igo_nr_func(cd, &source->stream, &sink->stream, frames); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* calc new free and available */ comp_update_buffer_consume(source, source_bytes); diff --git a/src/audio/kpb.c b/src/audio/kpb.c index b2008ee063c6..bc35723fc32f 100644 --- a/src/audio/kpb.c +++ b/src/audio/kpb.c @@ -764,7 +764,7 @@ static int kpb_copy(struct comp_dev *dev) copy_bytes = MIN(avail_bytes, kpb->hd.free); ret = PPL_STATUS_PATH_STOP; if (copy_bytes) { - buffer_invalidate(source, copy_bytes); + buffer_stream_invalidate(source, copy_bytes); ret = kpb_buffer_data(dev, source, copy_bytes); dd->buffered_while_draining += copy_bytes; kpb->hd.free -= copy_bytes; @@ -1488,7 +1488,7 @@ static void kpb_copy_samples(struct comp_buffer *sink, struct audio_stream *istream = &source->stream; struct audio_stream *ostream = &sink->stream; - buffer_invalidate(source, size); + buffer_stream_invalidate(source, size); for (i = 0; i < frames; i++) { for (channel = 0; channel < KPB_NUM_OF_CHANNELS; channel++) { @@ -1517,7 +1517,7 @@ static void kpb_copy_samples(struct comp_buffer *sink, } } - buffer_writeback(sink, size); + buffer_stream_writeback(sink, size); } /** diff --git a/src/audio/mixer.c b/src/audio/mixer.c index df584229e70c..71b5b55d8f92 100644 --- a/src/audio/mixer.c +++ b/src/audio/mixer.c @@ -309,7 +309,7 @@ static int mixer_copy(struct comp_dev *dev) buffer_unlock(sink, sink_flags); if (!audio_stream_set_zero(&sink->stream, sink_bytes)) { - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); comp_update_buffer_produce(sink, sink_bytes); } @@ -341,10 +341,10 @@ static int mixer_copy(struct comp_dev *dev) /* mix streams */ for (i = num_mix_sources - 1; i >= 0; i--) - buffer_invalidate(sources[i], source_bytes); + buffer_stream_invalidate(sources[i], source_bytes); md->mix_func(dev, &sink->stream, sources_stream, num_mix_sources, frames); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* update source buffer pointers */ for (i = num_mix_sources - 1; i >= 0; i--) diff --git a/src/audio/multiband_drc/multiband_drc.c b/src/audio/multiband_drc/multiband_drc.c index 2c021ea14985..0df5fb17f5dd 100644 --- a/src/audio/multiband_drc/multiband_drc.c +++ b/src/audio/multiband_drc/multiband_drc.c @@ -454,11 +454,11 @@ static void multiband_drc_process(struct comp_dev *dev, struct comp_buffer *sour { struct multiband_drc_comp_data *cd = comp_get_drvdata(dev); - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->multiband_drc_func(dev, &source->stream, &sink->stream, frames); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* calc new free and available */ comp_update_buffer_consume(source, source_bytes); diff --git a/src/audio/mux/mux.c b/src/audio/mux/mux.c index ba830ddf2461..0624e326fa85 100644 --- a/src/audio/mux/mux.c +++ b/src/audio/mux/mux.c @@ -495,10 +495,10 @@ static int demux_copy(struct comp_dev *dev) demux_prepare_active_look_up(dev, &sinks[i]->stream, &source->stream, look_ups[i]); - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->demux(dev, &sinks[i]->stream, &source->stream, frames, &cd->active_lookup); - buffer_writeback(sinks[i], sinks_bytes[i]); + buffer_stream_writeback(sinks[i], sinks_bytes[i]); } /* update components */ @@ -591,7 +591,7 @@ static int mux_copy(struct comp_dev *dev) continue; sources_bytes[i] = frames * audio_stream_frame_bytes(sources_stream[i]); - buffer_invalidate(sources[i], sources_bytes[i]); + buffer_stream_invalidate(sources[i], sources_bytes[i]); } sink_bytes = frames * audio_stream_frame_bytes(&sink->stream); @@ -600,7 +600,7 @@ static int mux_copy(struct comp_dev *dev) /* produce output */ cd->mux(dev, &sink->stream, &sources_stream[0], frames, &cd->active_lookup); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* update components */ comp_update_buffer_produce(sink, sink_bytes); diff --git a/src/audio/rtnr/rtnr.c b/src/audio/rtnr/rtnr.c index 64ae79cb1d76..9f1e741d7c7f 100644 --- a/src/audio/rtnr/rtnr.c +++ b/src/audio/rtnr/rtnr.c @@ -551,7 +551,7 @@ static int rtnr_copy(struct comp_dev *dev) source_bytes = frames * audio_stream_frame_bytes(&source->stream); sink_bytes = frames * audio_stream_frame_bytes(&sink->stream); - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); /* Run processing function */ @@ -568,7 +568,7 @@ static int rtnr_copy(struct comp_dev *dev) */ RTKMA_API_Process(cd->rtk_agl, 0, cd->source_rate, MicNum); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* Track consume and produce */ comp_update_buffer_consume(source, source_bytes); diff --git a/src/audio/selector/selector.c b/src/audio/selector/selector.c index d3142a0082b3..c8dd4e030d1f 100644 --- a/src/audio/selector/selector.c +++ b/src/audio/selector/selector.c @@ -405,9 +405,9 @@ static int selector_copy(struct comp_dev *dev) source_bytes, sink_bytes); /* copy selected channels from in to out */ - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->sel_func(dev, &sink->stream, &source->stream, frames); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* calculate new free and available */ comp_update_buffer_produce(sink, sink_bytes); diff --git a/src/audio/smart_amp/smart_amp.c b/src/audio/smart_amp/smart_amp.c index 9749fcd41fe7..aefbb9c6dea8 100644 --- a/src/audio/smart_amp/smart_amp.c +++ b/src/audio/smart_amp/smart_amp.c @@ -612,7 +612,7 @@ static int smart_amp_copy(struct comp_dev *dev) avail_frames, avail_passthrough_frames); /* perform buffer writeback after source_buf process */ - buffer_invalidate(sad->feedback_buf, feedback_bytes); + buffer_stream_invalidate(sad->feedback_buf, feedback_bytes); sad->process(dev, &sad->feedback_buf->stream, &sad->sink_buf->stream, avail_frames, sad->config.feedback_ch_map, true); @@ -635,10 +635,10 @@ static int smart_amp_copy(struct comp_dev *dev) buffer_unlock(sad->sink_buf, sink_flags); /* process data */ - buffer_invalidate(sad->source_buf, source_bytes); + buffer_stream_invalidate(sad->source_buf, source_bytes); sad->process(dev, &sad->source_buf->stream, &sad->sink_buf->stream, avail_frames, sad->config.source_ch_map, false); - buffer_writeback(sad->sink_buf, sink_bytes); + buffer_stream_writeback(sad->sink_buf, sink_bytes); /* source/sink buffer pointers update */ comp_update_buffer_consume(sad->source_buf, source_bytes); diff --git a/src/audio/src/src.c b/src/audio/src/src.c index c6ef3203fa14..ca4649755dc8 100644 --- a/src/audio/src/src.c +++ b/src/audio/src/src.c @@ -739,10 +739,9 @@ static void src_process(struct comp_dev *dev, struct comp_buffer *source, int produced = 0; /* consumed bytes are not known at this point */ - buffer_invalidate(source, source->stream.size); + buffer_stream_invalidate(source, source->stream.size); cd->src_func(dev, &source->stream, &sink->stream, &consumed, &produced); - buffer_writeback(sink, produced * - audio_stream_frame_bytes(&sink->stream)); + buffer_stream_writeback(sink, produced * audio_stream_frame_bytes(&sink->stream)); comp_dbg(dev, "src_copy(), consumed = %u, produced = %u", consumed, produced); diff --git a/src/audio/tdfb/tdfb.c b/src/audio/tdfb/tdfb.c index 80a6604bfb13..5cd787ec8a4e 100644 --- a/src/audio/tdfb/tdfb.c +++ b/src/audio/tdfb/tdfb.c @@ -664,11 +664,11 @@ static void tdfb_process(struct comp_dev *dev, struct comp_buffer *source, { struct tdfb_comp_data *cd = comp_get_drvdata(dev); - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->tdfb_func(cd, &source->stream, &sink->stream, frames); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* calc new free and available */ comp_update_buffer_consume(source, source_bytes); diff --git a/src/audio/tone.c b/src/audio/tone.c index 923fa1608c3e..d913acb14d0b 100644 --- a/src/audio/tone.c +++ b/src/audio/tone.c @@ -633,7 +633,7 @@ static int tone_copy(struct comp_dev *dev) if (free >= cd->period_bytes) { /* create tone */ cd->tone_func(dev, &sink->stream, dev->frames); - buffer_writeback(sink, cd->period_bytes); + buffer_stream_writeback(sink, cd->period_bytes); /* calc new free and available */ comp_update_buffer_produce(sink, cd->period_bytes); diff --git a/src/audio/volume/volume.c b/src/audio/volume/volume.c index 728fe44fbeda..9c04bbff9618 100644 --- a/src/audio/volume/volume.c +++ b/src/audio/volume/volume.c @@ -799,9 +799,9 @@ static int volume_copy(struct comp_dev *dev) sink_bytes = frames * c.sink_frame_bytes; /* copy and scale volume */ - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); cd->scale_vol(dev, &sink->stream, &source->stream, frames); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* calculate new free and available */ comp_update_buffer_produce(sink, sink_bytes); diff --git a/src/include/sof/audio/buffer.h b/src/include/sof/audio/buffer.h index 8e3c28d4d151..519751b7a9fc 100644 --- a/src/include/sof/audio/buffer.h +++ b/src/include/sof/audio/buffer.h @@ -171,7 +171,7 @@ int buffer_set_params(struct comp_buffer *buffer, struct sof_ipc_stream_params * bool buffer_params_match(struct comp_buffer *buffer, struct sof_ipc_stream_params *params, uint32_t flag); -static inline void buffer_invalidate(struct comp_buffer *buffer, uint32_t bytes) +static inline void buffer_stream_invalidate(struct comp_buffer *buffer, uint32_t bytes) { if (!buffer->inter_core) return; @@ -179,7 +179,7 @@ static inline void buffer_invalidate(struct comp_buffer *buffer, uint32_t bytes) audio_stream_invalidate(&buffer->stream, bytes); } -static inline void buffer_writeback(struct comp_buffer *buffer, uint32_t bytes) +static inline void buffer_stream_writeback(struct comp_buffer *buffer, uint32_t bytes) { if (!buffer->inter_core) return; diff --git a/src/lib/dma.c b/src/lib/dma.c index a2f9b1e261d9..c4c6918be025 100644 --- a/src/lib/dma.c +++ b/src/lib/dma.c @@ -198,7 +198,7 @@ int dma_buffer_copy_from(struct comp_buffer *source, struct comp_buffer *sink, /* process data */ ret = process(istream, 0, &sink->stream, 0, samples); - buffer_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); /* * consume istream using audio_stream API because this buffer doesn't @@ -220,7 +220,7 @@ int dma_buffer_copy_to(struct comp_buffer *source, struct comp_buffer *sink, samples; int ret; - buffer_invalidate(source, source_bytes); + buffer_stream_invalidate(source, source_bytes); /* process data */ ret = process(&source->stream, 0, ostream, 0, samples); diff --git a/src/samples/audio/detect_test.c b/src/samples/audio/detect_test.c index 046d8def3b51..056c7478919c 100644 --- a/src/samples/audio/detect_test.c +++ b/src/samples/audio/detect_test.c @@ -641,7 +641,7 @@ static int test_keyword_copy(struct comp_dev *dev) buffer_unlock(source, flags); /* copy and perform detection */ - buffer_invalidate(source, audio_stream_get_avail_bytes(&source->stream)); + buffer_stream_invalidate(source, audio_stream_get_avail_bytes(&source->stream)); cd->detect_func(dev, &source->stream, frames); /* calc new available */ diff --git a/src/samples/audio/smart_amp_test.c b/src/samples/audio/smart_amp_test.c index 8d52f8defffc..77b1e55ed90c 100644 --- a/src/samples/audio/smart_amp_test.c +++ b/src/samples/audio/smart_amp_test.c @@ -453,7 +453,7 @@ static int smart_amp_copy(struct comp_dev *dev) avail_frames, avail_passthrough_frames); /* perform buffer writeback after source_buf process */ - buffer_invalidate(sad->feedback_buf, feedback_bytes); + buffer_stream_invalidate(sad->feedback_buf, feedback_bytes); sad->process(dev, &sad->feedback_buf->stream, &sad->sink_buf->stream, avail_frames, sad->config.feedback_ch_map); @@ -476,10 +476,10 @@ static int smart_amp_copy(struct comp_dev *dev) buffer_unlock(sad->sink_buf, sink_flags); /* process data */ - buffer_invalidate(sad->source_buf, source_bytes); + buffer_stream_invalidate(sad->source_buf, source_bytes); sad->process(dev, &sad->source_buf->stream, &sad->sink_buf->stream, avail_frames, sad->config.source_ch_map); - buffer_writeback(sad->sink_buf, sink_bytes); + buffer_stream_writeback(sad->sink_buf, sink_bytes); /* source/sink buffer pointers update */ comp_update_buffer_consume(sad->source_buf, source_bytes); From b41c4e66d36a65a954656cdadef4fb93a16eb674 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Thu, 26 Aug 2021 17:16:15 -0700 Subject: [PATCH 02/22] multicore: coherent: Add APIs for coherent access to shared objects Certain data structures such as buffers, pipelines, comp_dev's are used across cores and cache boundaries. Introduce APIs to handle cached access to such objects by stipulating that the lock is held during access and releasing the lock after. For example: /* uncached work */ if (buffer->flag == somevalue) do this; /* cached work */ buffer = coherent_acquire(buffer); buffer->state = true; /* back to uncached */ buffer = coherent_release(buffer); Also, add a new kconfig INCOHERENT which will need to ibe set for platforms that need software-managed coherency. Signed-off-by: Liam Girdwood Signed-off-by: Ranjani Sridharan --- src/arch/host/include/arch/lib/cache.h | 2 + src/arch/xtensa/Kconfig | 9 + src/arch/xtensa/configs/tgph_defconfig | 1 + src/arch/xtensa/configs/tgplp_defconfig | 1 + src/include/sof/coherent.h | 266 ++++++++++++++++++++++++ src/include/sof/common.h | 3 + 6 files changed, 282 insertions(+) create mode 100644 src/include/sof/coherent.h diff --git a/src/arch/host/include/arch/lib/cache.h b/src/arch/host/include/arch/lib/cache.h index a849c1c77fc8..e1ca9714e290 100644 --- a/src/arch/host/include/arch/lib/cache.h +++ b/src/arch/host/include/arch/lib/cache.h @@ -18,6 +18,8 @@ static inline void icache_invalidate_region(void *addr, size_t size) {} static inline void dcache_writeback_invalidate_region(void *addr, size_t size) {} +#define DCACHE_LINE_SIZE 64 + #endif /* __ARCH_LIB_CACHE_H__ */ #else diff --git a/src/arch/xtensa/Kconfig b/src/arch/xtensa/Kconfig index e015a80f1e2a..b6bb3313a8be 100644 --- a/src/arch/xtensa/Kconfig +++ b/src/arch/xtensa/Kconfig @@ -17,3 +17,12 @@ config WAKEUP_HOOK This config should be selected by other platform-level configs. Platforms that use it, have to implement hook function platform_interrupt_on_wakeup. + +config INCOHERENT + bool + default n + help + The architecture is cache incoherent. i.e FW has to manually manage + cache coherency amongst objects that are used on multiple cores. + This setting should only be disabled for cache incoherent + architectures if they are being used in UP mode. diff --git a/src/arch/xtensa/configs/tgph_defconfig b/src/arch/xtensa/configs/tgph_defconfig index af16d3926927..9be98fe0478e 100644 --- a/src/arch/xtensa/configs/tgph_defconfig +++ b/src/arch/xtensa/configs/tgph_defconfig @@ -9,3 +9,4 @@ CONFIG_HP_MEMORY_BANKS=30 CONFIG_L1_DRAM=y CONFIG_L1_DRAM_MEMORY_BANKS=8 CONFIG_L1_DRAM_MEMORY_BANK_SIZE=8192 +CONFIG_INCOHERENT=y diff --git a/src/arch/xtensa/configs/tgplp_defconfig b/src/arch/xtensa/configs/tgplp_defconfig index 8c5d4e912b58..d496ebcbc565 100644 --- a/src/arch/xtensa/configs/tgplp_defconfig +++ b/src/arch/xtensa/configs/tgplp_defconfig @@ -4,3 +4,4 @@ CONFIG_INTEL_SSP=y CONFIG_INTEL_ALH=y CONFIG_LP_MEMORY_BANKS=1 CONFIG_HP_MEMORY_BANKS=46 +CONFIG_INCOHERENT=y diff --git a/src/include/sof/coherent.h b/src/include/sof/coherent.h new file mode 100644 index 000000000000..a3fa493a2148 --- /dev/null +++ b/src/include/sof/coherent.h @@ -0,0 +1,266 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * + * Copyright(c) 2021 Intel Corporation. All rights reserved. + * + * Author: Liam Girdwood + */ + +#ifndef __SOF_COHERENT_H__ +#define __SOF_COHERENT_H__ + +#include +#include +#include + +#include +#include +#include +#include + +#define __coherent __attribute__((packed, aligned(DCACHE_LINE_SIZE))) + +/* + * This structure needs to be embedded at the start of any container to ensure + * container object cache alignment and to minimise non cache access when + * acquiring ownership. + * + * This structure should not be accessed outside of these APIs. + * The shared flag is only set at coherent init and thereafter it's RO. + */ +struct coherent { + spinlock_t lock; /* locking mechanism */ + uint32_t flags; /* lock flags */ + uint16_t shared; /* shared on other non coherent cores */ + uint16_t core; /* owner core if not shared */ + struct list_item list; /* coherent list iteration */ +} __coherent; + +/* debug address aliases */ +#ifdef COHERENT_CHECK_ALIAS +#define ADDR_IS_INCOHERENT(_c) assert(!is_uncached(_c)) +#define ADDR_IS_COHERENT(_c) assert(is_uncached(_c)) +#else +#define ADDR_IS_INCOHERENT(_c) +#define ADDR_IS_COHERENT(_c) +#endif + +/* debug sharing amongst cores */ +#ifdef COHERENT_CHECK_NONSHARED_CORES +#define CHECK_COHERENT_CORE(_c) assert((_c)->core == cpu_get_id()) +#else +#define CHECK_COHERENT_CORE(_c) +#endif + +/* debug usage in IRQ contexts - check non IRQ being used in IRQ context TODO */ +#ifdef COHERENT_CHECK_IN_IRQ +#define CHECK_COHERENT_IRQ(_c) assert(1) +#else +#define CHECK_COHERENT_IRQ(_c) +#endif + +/* + * Incoherent devices require manual cache invalidation and writeback as + * well as locking to manage shared access. + */ + +#if CONFIG_INCOHERENT +__must_check static inline struct coherent *coherent_acquire(struct coherent *c, + const size_t size) +{ + /* assert if someone passes a cache/local address in here. */ + ADDR_IS_COHERENT(c); + + /* this flavour should not be used in IRQ context */ + CHECK_COHERENT_IRQ(c); + + /* access the shared coherent object */ + if (c->shared) { + CHECK_COHERENT_CORE(c); + + spin_lock(&c->lock); + + /* invalidate local copy */ + dcache_invalidate_region(uncache_to_cache(c), size); + } + + /* client can now use cached object safely */ + return uncache_to_cache(c); +} + +static inline struct coherent *coherent_release(struct coherent *c, const size_t size) +{ + /* assert if someone passes a coherent address in here. */ + ADDR_IS_INCOHERENT(c); + + /* this flavour should not be used in IRQ context */ + CHECK_COHERENT_IRQ(c); + + /* access the local copy of object */ + if (c->shared) { + CHECK_COHERENT_CORE(c); + + /* wtb and inv local data to coherent object */ + dcache_writeback_invalidate_region(c, size); + + /* unlock on uncache alias */ + spin_unlock(&(cache_to_uncache(c))->lock); + } + + return cache_to_uncache(c); +} + +__must_check static inline struct coherent *coherent_acquire_irq(struct coherent *c, + const size_t size) +{ + /* assert if someone passes a cache/local address in here. */ + ADDR_IS_COHERENT(c); + + /* access the shared coherent object */ + if (c->shared) { + CHECK_COHERENT_CORE(c); + + spin_lock_irq(&c->lock, c->flags); + + /* invalidate local copy */ + dcache_invalidate_region(uncache_to_cache(c), size); + } + + /* client can now use cached object safely */ + return uncache_to_cache(c); +} + +static inline struct coherent *coherent_release_irq(struct coherent *c, const size_t size) +{ + /* assert if someone passes a coherent address in here. */ + ADDR_IS_INCOHERENT(c); + + /* access the local copy of object */ + if (c->shared) { + CHECK_COHERENT_CORE(c); + + /* wtb and inv local data to coherent object */ + dcache_writeback_invalidate_region(c, size); + + /* unlock on uncache alias */ + spin_unlock_irq(&(cache_to_uncache(c))->lock, + (cache_to_uncache(c))->flags); + } + + return cache_to_uncache(c); +} + +#define coherent_init(object, member) \ + do { \ + /* assert if someone passes a cache/local address in here. */ \ + ADDR_IS_COHERENT(object); \ + /* TODO static assert if we are not cache aligned */ \ + spinlock_init(&object->member.lock); \ + object->member.shared = false; \ + object->member.core = cpu_get_id(); \ + list_init(&object->member.list); \ + /* wtb and inv local data to coherent object */ \ + dcache_writeback_invalidate_region(uncache_to_cache(object), sizeof(*object)); \ + } while (0) + +#define coherent_free(object, member) \ + do { \ + /* assert if someone passes a cache address in here. */ \ + ADDR_IS_COHERENT(object); \ + /* wtb and inv local data to coherent object */ \ + dcache_writeback_invalidate_region(uncache_to_cache(object), sizeof(*object)); \ + } while (0) + +/* set the object to shared mode with coherency managed by SW */ +#define coherent_shared(object, member) \ + do { \ + /* assert if someone passes a cache/local address in here. */ \ + ADDR_IS_COHERENT(object); \ + spin_lock(&(object)->member.lock); \ + (object)->member.shared = true; \ + dcache_writeback_invalidate_region(object, sizeof(*object)); \ + spin_unlock(&(object)->member.lock); \ + } while (0) + +/* set the object to shared mode with coherency managed by SW */ +#define coherent_shared_irq(object, member) \ + do { \ + /* assert if someone passes a cache/local address in here. */ \ + ADDR_IS_COHERENT(object); \ + spin_lock_irq(&(object)->member.lock, &(object)->member.flags); \ + (object)->member.shared = true; \ + dcache_writeback_invalidate_region(object, sizeof(*object)); \ + spin_unlock_irq(&(object)->member.lock, &(object)->member.flags); \ + } while (0) +#else + +/* + * Coherent devices only require locking to manage shared access. + */ +__must_check static inline struct coherent *coherent_acquire(struct coherent *c, const size_t size) +{ + if (c->shared) { + spin_lock(&c->lock); + + /* invalidate local copy */ + dcache_invalidate_region(uncache_to_cache(c), size); + } + + return c; +} + +static inline struct coherent *coherent_release(struct coherent *c, const size_t size) +{ + if (c->shared) { + /* wtb and inv local data to coherent object */ + dcache_writeback_invalidate_region(uncache_to_cache(c), size); + + spin_unlock(&c->lock); + } + + return c; +} + +__must_check static inline struct coherent *coherent_acquire_irq(struct coherent *c, + const size_t size) +{ + if (c->shared) { + spin_lock_irq(&c->lock, c->flags); + + /* invalidate local copy */ + dcache_invalidate_region(uncache_to_cache(c), size); + } + + return c; +} + +static inline struct coherent *coherent_release_irq(struct coherent *c, const size_t size) +{ + if (c->shared) { + /* wtb and inv local data to coherent object */ + dcache_writeback_invalidate_region(uncache_to_cache(c), size); + + spin_unlock_irq(&c->lock, c->flags); + } + + return c; +} + +#define coherent_init(object, member) \ + do { \ + /* TODO static assert if we are not cache aligned */ \ + spinlock_init(&object->member.lock); \ + object->member.shared = 0; \ + object->member.core = cpu_get_id(); \ + list_init(&object->member.list); \ + } while (0) + +#define coherent_free(object, member) + +/* no function on cache coherent architectures */ +#define coherent_shared(object, member) ((object)->member.shared = true) +#define coherent_shared_irq(object, member) ((object)->member.shared = true) + +#endif /* CONFIG_CAVS && CONFIG_CORE_COUNT > 1 */ + +#define is_coherent_shared(object, member) ((object)->member.shared) +#endif diff --git a/src/include/sof/common.h b/src/include/sof/common.h index d8e7c0f340c4..d42dd88686bc 100644 --- a/src/include/sof/common.h +++ b/src/include/sof/common.h @@ -11,6 +11,9 @@ #if !defined(LINKER) +/* callers must check/use the return value */ +#define __must_check __attribute__((warn_unused_result)) + /* Align the number to the nearest alignment value */ #define IS_ALIGNED(size, alignment) ((size) % (alignment) == 0) From 77b59dfc3d249f212ce8141e59c58fad250a79e5 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Thu, 26 Aug 2021 17:30:04 -0700 Subject: [PATCH 03/22] multicore: buffer: use coherent APIs Buffer are shared hot data structures that are used across core and cache boundaries. Manage cached buffer access by stipulating that cached access is granted by holding the buffer lock (which invalidates) and releasing the lock (invalidates and writeback). Signed-off-by: Liam Girdwood Signed-off-by: Ranjani Sridharan --- src/audio/buffer.c | 30 ++++---------- src/include/sof/audio/buffer.h | 76 ++++++++++++++++++++++++---------- src/ipc/ipc-helper.c | 11 ++--- src/ipc/ipc3/helper.c | 25 +++-------- 4 files changed, 72 insertions(+), 70 deletions(-) diff --git a/src/audio/buffer.c b/src/audio/buffer.c index fb90ddf3326a..0df050f53bff 100644 --- a/src/audio/buffer.c +++ b/src/audio/buffer.c @@ -45,17 +45,8 @@ struct comp_buffer *buffer_alloc(uint32_t size, uint32_t caps, uint32_t align) return NULL; } - buffer->lock = rzalloc(SOF_MEM_ZONE_RUNTIME_SHARED, 0, SOF_MEM_CAPS_RAM, - sizeof(*buffer->lock)); - if (!buffer->lock) { - rfree(buffer); - tr_err(&buffer_tr, "buffer_alloc(): could not alloc lock"); - return NULL; - } - buffer->stream.addr = rballoc_align(0, caps, size, align); if (!buffer->stream.addr) { - rfree(buffer->lock); rfree(buffer); tr_err(&buffer_tr, "buffer_alloc(): could not alloc size = %u bytes of type = %u", size, caps); @@ -63,10 +54,9 @@ struct comp_buffer *buffer_alloc(uint32_t size, uint32_t caps, uint32_t align) } buffer_init(buffer, size, caps); - + coherent_init(buffer, c); list_init(&buffer->source_list); list_init(&buffer->sink_list); - spinlock_init(buffer->lock); return buffer; } @@ -145,7 +135,7 @@ int buffer_set_params(struct comp_buffer *buffer, struct sof_ipc_stream_params * bool buffer_params_match(struct comp_buffer *buffer, struct sof_ipc_stream_params *params, uint32_t flag) { - assert(params && buffer); + assert(params); if ((flag & BUFF_PARAMS_FRAME_FMT) && buffer->stream.frame_fmt != params->frame_fmt) @@ -177,14 +167,13 @@ void buffer_free(struct comp_buffer *buffer) /* In case some listeners didn't unregister from buffer's callbacks */ notifier_unregister_all(NULL, buffer); + coherent_free(buffer, c); rfree(buffer->stream.addr); - rfree(buffer->lock); rfree(buffer); } void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes) { - uint32_t flags = 0; struct buffer_cb_transact cb_data = { .buffer = buffer, .transaction_amount = bytes, @@ -202,15 +191,13 @@ void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes) return; } - buffer_lock(buffer, &flags); + buffer = buffer_acquire_irq(buffer); audio_stream_produce(&buffer->stream, bytes); notifier_event(buffer, NOTIFIER_ID_BUFFER_PRODUCE, NOTIFIER_TARGET_CORE_LOCAL, &cb_data, sizeof(cb_data)); - buffer_unlock(buffer, flags); - addr = buffer->stream.addr; buf_dbg(buffer, "comp_update_buffer_produce(), ((buffer->avail << 16) | buffer->free) = %08x, ((buffer->id << 16) | buffer->size) = %08x", @@ -220,11 +207,12 @@ void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes) buf_dbg(buffer, "comp_update_buffer_produce(), ((buffer->r_ptr - buffer->addr) << 16 | (buffer->w_ptr - buffer->addr)) = %08x", ((char *)buffer->stream.r_ptr - addr) << 16 | ((char *)buffer->stream.w_ptr - addr)); + + buffer = buffer_release_irq(buffer); } void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes) { - uint32_t flags = 0; struct buffer_cb_transact cb_data = { .buffer = buffer, .transaction_amount = bytes, @@ -242,15 +230,13 @@ void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes) return; } - buffer_lock(buffer, &flags); + buffer = buffer_acquire_irq(buffer); audio_stream_consume(&buffer->stream, bytes); notifier_event(buffer, NOTIFIER_ID_BUFFER_CONSUME, NOTIFIER_TARGET_CORE_LOCAL, &cb_data, sizeof(cb_data)); - buffer_unlock(buffer, flags); - addr = buffer->stream.addr; buf_dbg(buffer, "comp_update_buffer_consume(), (buffer->avail << 16) | buffer->free = %08x, (buffer->id << 16) | buffer->size = %08x, (buffer->r_ptr - buffer->addr) << 16 | (buffer->w_ptr - buffer->addr)) = %08x", @@ -259,4 +245,6 @@ void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes) (buffer->id << 16) | buffer->stream.size, ((char *)buffer->stream.r_ptr - addr) << 16 | ((char *)buffer->stream.w_ptr - addr)); + + buffer = buffer_release_irq(buffer); } diff --git a/src/include/sof/audio/buffer.h b/src/include/sof/audio/buffer.h index 519751b7a9fc..797cc298550a 100644 --- a/src/include/sof/audio/buffer.h +++ b/src/include/sof/audio/buffer.h @@ -17,6 +17,7 @@ #include #include #include +#include #include #include #include @@ -83,9 +84,21 @@ extern struct tr_ctx buffer_tr; #define BUFF_PARAMS_RATE BIT(2) #define BUFF_PARAMS_CHANNELS BIT(3) -/* audio component buffer - connects 2 audio components together in pipeline */ +/* + * audio component buffer - connects 2 audio components together in pipeline. + * + * The buffer is a hot structure that must be shared on certain cache + * incoherent architectures. + * + * Access flow (on cache incoherent architectures only) + * 1) buffer acquired by using uncache cache coherent pointer. + * 2) buffer is invalidated after lock acquired. + * 3) buffer is safe to use cached pointer for access. + * 4) release buffer cached pointer + * 5) write back cached data and release lock using uncache pointer. + */ struct comp_buffer { - spinlock_t *lock; /* locking mechanism */ + struct coherent c; /* data buffer */ struct audio_stream stream; @@ -95,7 +108,6 @@ struct comp_buffer { uint32_t pipeline_id; uint32_t caps; uint32_t core; - bool inter_core; /* true if connected to a comp from another core */ struct tr_ctx tctx; /* trace settings */ /* connected components */ @@ -173,7 +185,7 @@ bool buffer_params_match(struct comp_buffer *buffer, struct sof_ipc_stream_param static inline void buffer_stream_invalidate(struct comp_buffer *buffer, uint32_t bytes) { - if (!buffer->inter_core) + if (!is_coherent_shared(buffer, c)) return; audio_stream_invalidate(&buffer->stream, bytes); @@ -181,7 +193,7 @@ static inline void buffer_stream_invalidate(struct comp_buffer *buffer, uint32_t static inline void buffer_stream_writeback(struct comp_buffer *buffer, uint32_t bytes) { - if (!buffer->inter_core) + if (!is_coherent_shared(buffer, c)) return; audio_stream_writeback(&buffer->stream, bytes); @@ -196,7 +208,7 @@ static inline void buffer_stream_writeback(struct comp_buffer *buffer, uint32_t */ static inline void buffer_lock(struct comp_buffer *buffer, uint32_t *flags) { - if (!buffer->inter_core) { + if (!is_coherent_shared(buffer, c)) { /* Ignored by buffer_unlock() below, silences "may be * used uninitialized" warning. */ @@ -205,7 +217,7 @@ static inline void buffer_lock(struct comp_buffer *buffer, uint32_t *flags) } /* Expands to: *flags = ... */ - spin_lock_irq(buffer->lock, *flags); + spin_lock_irq(&buffer->c.lock, *flags); /* invalidate in case something has changed during our wait */ dcache_invalidate_region(uncache_to_cache(buffer), sizeof(*buffer)); @@ -221,23 +233,46 @@ static inline void buffer_lock(struct comp_buffer *buffer, uint32_t *flags) */ static inline void buffer_unlock(struct comp_buffer *buffer, uint32_t flags) { - if (!buffer->inter_core) + if (!is_coherent_shared(buffer, c)) return; - /* save lock pointer to avoid memory access after cache flushing */ - spinlock_t *lock = buffer->lock; - /* wtb and inv to avoid buffer locking in read only situations */ dcache_writeback_invalidate_region(uncache_to_cache(buffer), sizeof(*buffer)); - spin_unlock_irq(lock, flags); + spin_unlock_irq(&buffer->c.lock, flags); } -static inline void buffer_reset_pos(struct comp_buffer *buffer, void *data) +__must_check static inline struct comp_buffer *buffer_acquire(struct comp_buffer *buffer) +{ + struct coherent *c = coherent_acquire(&buffer->c, sizeof(*buffer)); + + return container_of(c, struct comp_buffer, c); +} + +static inline struct comp_buffer *buffer_release(struct comp_buffer *buffer) +{ + struct coherent *c = coherent_release(&buffer->c, sizeof(*buffer)); + + return container_of(c, struct comp_buffer, c); +} + +__must_check static inline struct comp_buffer *buffer_acquire_irq(struct comp_buffer *buffer) { - uint32_t flags = 0; + struct coherent *c = coherent_acquire_irq(&buffer->c, sizeof(*buffer)); + + return container_of(c, struct comp_buffer, c); +} - buffer_lock(buffer, &flags); +static inline struct comp_buffer *buffer_release_irq(struct comp_buffer *buffer) +{ + struct coherent *c = coherent_release_irq(&buffer->c, sizeof(*buffer)); + + return container_of(c, struct comp_buffer, c); +} + +static inline void buffer_reset_pos(struct comp_buffer *buffer, void *data) +{ + buffer = buffer_acquire_irq(buffer); /* reset rw pointers and avail/free bytes counters */ audio_stream_reset(&buffer->stream); @@ -245,11 +280,10 @@ static inline void buffer_reset_pos(struct comp_buffer *buffer, void *data) /* clear buffer contents */ buffer_zero(buffer); - buffer_unlock(buffer, flags); + buffer = buffer_release_irq(buffer); } -static inline void buffer_init(struct comp_buffer *buffer, uint32_t size, - uint32_t caps) +static inline void buffer_init(struct comp_buffer *buffer, uint32_t size, uint32_t caps) { buffer->caps = caps; @@ -259,13 +293,11 @@ static inline void buffer_init(struct comp_buffer *buffer, uint32_t size, static inline void buffer_reset_params(struct comp_buffer *buffer, void *data) { - uint32_t flags = 0; - - buffer_lock(buffer, &flags); + buffer = buffer_acquire_irq(buffer); buffer->hw_params_configured = false; - buffer_unlock(buffer, flags); + buffer = buffer_release_irq(buffer); } #endif /* __SOF_AUDIO_BUFFER_H__ */ diff --git a/src/ipc/ipc-helper.c b/src/ipc/ipc-helper.c index f5aa740b1225..d142aa9aadcf 100644 --- a/src/ipc/ipc-helper.c +++ b/src/ipc/ipc-helper.c @@ -180,22 +180,17 @@ int comp_verify_params(struct comp_dev *dev, uint32_t flag, int comp_buffer_connect(struct comp_dev *comp, uint32_t comp_core, struct comp_buffer *buffer, uint32_t dir) { - int ret; - /* check if it's a connection between cores */ if (buffer->core != comp_core) { - dcache_invalidate_region(uncache_to_cache(buffer), sizeof(*buffer)); - buffer->inter_core = true; + /* set the buffer as a coherent object */ + coherent_shared(buffer, c); if (!comp->is_shared) comp = comp_make_shared(comp); } - ret = pipeline_connect(comp, buffer, dir); - dcache_writeback_invalidate_region(uncache_to_cache(buffer), sizeof(*buffer)); - - return ret; + return pipeline_connect(comp, buffer, dir); } int ipc_pipeline_complete(struct ipc *ipc, uint32_t comp_id) diff --git a/src/ipc/ipc3/helper.c b/src/ipc/ipc3/helper.c index 2101c01c7398..7e4dda9a9d95 100644 --- a/src/ipc/ipc3/helper.c +++ b/src/ipc/ipc3/helper.c @@ -522,7 +522,6 @@ int ipc_buffer_free(struct ipc *ipc, uint32_t buffer_id) static int ipc_comp_to_buffer_connect(struct ipc_comp_dev *comp, struct ipc_comp_dev *buffer) { - int ret; if (!cpu_is_me(comp->core)) return ipc_process_on_core(comp->core, false); @@ -532,27 +531,20 @@ static int ipc_comp_to_buffer_connect(struct ipc_comp_dev *comp, /* check if it's a connection between cores */ if (buffer->core != comp->core) { - dcache_invalidate_region(uncache_to_cache(buffer->cb), sizeof(*buffer->cb)); - buffer->cb->inter_core = true; + /* set the buffer as a coherent object */ + coherent_shared(buffer->cb, c); if (!comp->cd->is_shared) comp->cd = comp_make_shared(comp->cd); } - ret = pipeline_connect(comp->cd, buffer->cb, - PPL_CONN_DIR_COMP_TO_BUFFER); - - dcache_writeback_invalidate_region(uncache_to_cache(buffer->cb), sizeof(*buffer->cb)); - - return ret; + return pipeline_connect(comp->cd, buffer->cb, PPL_CONN_DIR_COMP_TO_BUFFER); } static int ipc_buffer_to_comp_connect(struct ipc_comp_dev *buffer, struct ipc_comp_dev *comp) { - int ret; - if (!cpu_is_me(comp->core)) return ipc_process_on_core(comp->core, false); @@ -561,20 +553,15 @@ static int ipc_buffer_to_comp_connect(struct ipc_comp_dev *buffer, /* check if it's a connection between cores */ if (buffer->core != comp->core) { - dcache_invalidate_region(uncache_to_cache(buffer->cb), sizeof(*buffer->cb)); - buffer->cb->inter_core = true; + /* set the buffer as a coherent object */ + coherent_shared(buffer->cb, c); if (!comp->cd->is_shared) comp->cd = comp_make_shared(comp->cd); } - ret = pipeline_connect(comp->cd, buffer->cb, - PPL_CONN_DIR_BUFFER_TO_COMP); - - dcache_writeback_invalidate_region(uncache_to_cache(buffer->cb), sizeof(*buffer->cb)); - - return ret; + return pipeline_connect(comp->cd, buffer->cb, PPL_CONN_DIR_BUFFER_TO_COMP); } int ipc_comp_connect(struct ipc *ipc, ipc_pipe_comp_connect *_connect) From cdbb2fc191cd8f4c45d79c60b4d2643356271e3d Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Mon, 25 Oct 2021 20:38:14 -0700 Subject: [PATCH 04/22] host: use buffer acquire/release API instead of buffer_lock/unlock() which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/host.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/audio/host.c b/src/audio/host.c index 525d6389d45b..0989b22cb2ff 100644 --- a/src/audio/host.c +++ b/src/audio/host.c @@ -265,19 +265,19 @@ static uint32_t host_get_copy_bytes_one_shot(struct comp_dev *dev) { struct host_data *hd = comp_get_drvdata(dev); struct dma_sg_elem *local_elem = hd->config.elem_array.elems; + struct comp_buffer *buffer = hd->local_buffer; uint32_t copy_bytes = 0; uint32_t split_value; - uint32_t flags = 0; - buffer_lock(hd->local_buffer, &flags); + buffer = buffer_acquire_irq(buffer); /* calculate minimum size to copy */ if (dev->direction == SOF_IPC_STREAM_PLAYBACK) - copy_bytes = audio_stream_get_free_bytes(&hd->local_buffer->stream); + copy_bytes = audio_stream_get_free_bytes(&buffer->stream); else - copy_bytes = audio_stream_get_avail_bytes(&hd->local_buffer->stream); + copy_bytes = audio_stream_get_avail_bytes(&buffer->stream); - buffer_unlock(hd->local_buffer, flags); + buffer_release_irq(buffer); /* copy_bytes should be aligned to minimum possible chunk of * data to be copied by dma. @@ -337,10 +337,10 @@ static int host_copy_one_shot(struct comp_dev *dev) static uint32_t host_get_copy_bytes_normal(struct comp_dev *dev) { struct host_data *hd = comp_get_drvdata(dev); + struct comp_buffer *buffer = hd->local_buffer; uint32_t avail_bytes = 0; uint32_t free_bytes = 0; uint32_t copy_bytes = 0; - uint32_t flags = 0; int ret; /* get data sizes from DMA */ @@ -353,26 +353,27 @@ static uint32_t host_get_copy_bytes_normal(struct comp_dev *dev) return 0; } - buffer_lock(hd->local_buffer, &flags); + buffer = buffer_acquire_irq(buffer); /* calculate minimum size to copy */ if (dev->direction == SOF_IPC_STREAM_PLAYBACK) { /* limit bytes per copy to one period for the whole pipeline * in order to avoid high load spike */ - free_bytes = audio_stream_get_free_bytes(&hd->local_buffer->stream); + free_bytes = audio_stream_get_free_bytes(&buffer->stream); copy_bytes = MIN(hd->period_bytes, MIN(avail_bytes, free_bytes)); if (!copy_bytes) comp_info(dev, "no bytes to copy, %d free in buffer, %d available in DMA", free_bytes, avail_bytes); } else { - avail_bytes = audio_stream_get_avail_bytes(&hd->local_buffer->stream); + avail_bytes = audio_stream_get_avail_bytes(&buffer->stream); copy_bytes = MIN(avail_bytes, free_bytes); if (!copy_bytes) comp_info(dev, "no bytes to copy, %d avail in buffer, %d free in DMA", avail_bytes, free_bytes); } - buffer_unlock(hd->local_buffer, flags); + + buffer = buffer_release_irq(buffer); /* copy_bytes should be aligned to minimum possible chunk of * data to be copied by dma. From 78cc2aec34d0a198bd78af97806dfd99cd8c220e Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Mon, 25 Oct 2021 20:42:14 -0700 Subject: [PATCH 05/22] dai: use buffer acquire/release instead of buffer_lock/unlock() which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/dai.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/audio/dai.c b/src/audio/dai.c index 0a576c912181..67fc5c1e2464 100644 --- a/src/audio/dai.c +++ b/src/audio/dai.c @@ -898,7 +898,6 @@ static int dai_copy(struct comp_dev *dev) uint32_t sink_samples; uint32_t samples; int ret = 0; - uint32_t flags = 0; comp_dbg(dev, "dai_copy()"); @@ -909,7 +908,7 @@ static int dai_copy(struct comp_dev *dev) return ret; } - buffer_lock(buf, &flags); + buf = buffer_acquire_irq(buf); /* calculate minimum size to copy */ if (dev->direction == SOF_IPC_STREAM_PLAYBACK) { @@ -929,7 +928,7 @@ static int dai_copy(struct comp_dev *dev) copy_bytes = samples * sampling; - buffer_unlock(buf, flags); + buffer_release_irq(buf); comp_dbg(dev, "dai_copy(), dir: %d copy_bytes= 0x%x, frames= %d", dev->direction, copy_bytes, From 48cd865ff77c0d2d5b38361dbff0c1a22e2a13d6 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Mon, 25 Oct 2021 20:42:31 -0700 Subject: [PATCH 06/22] mixer: use buffer acquire/release instead of buffer_lock/unlock() which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/mixer.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/audio/mixer.c b/src/audio/mixer.c index 71b5b55d8f92..7aabd5c6ac97 100644 --- a/src/audio/mixer.c +++ b/src/audio/mixer.c @@ -274,7 +274,6 @@ static int mixer_copy(struct comp_dev *dev) uint32_t frames = INT32_MAX; uint32_t source_bytes; uint32_t sink_bytes; - uint32_t sink_flags, source_flags; comp_dbg(dev, "mixer_copy()"); @@ -302,11 +301,11 @@ static int mixer_copy(struct comp_dev *dev) /* write zeros if all sources are inactive */ if (num_mix_sources == 0) { uint32_t free_frames; - buffer_lock(sink, &sink_flags); + sink = buffer_acquire_irq(sink); free_frames = audio_stream_get_free_frames(&sink->stream); frames = MIN(frames, free_frames); sink_bytes = frames * audio_stream_frame_bytes(&sink->stream); - buffer_unlock(sink, sink_flags); + sink = buffer_release_irq(sink); if (!audio_stream_set_zero(&sink->stream, sink_bytes)) { buffer_stream_writeback(sink, sink_bytes); @@ -316,19 +315,19 @@ static int mixer_copy(struct comp_dev *dev) return 0; } - buffer_lock(sink, &sink_flags); + sink = buffer_acquire_irq(sink); /* check for underruns */ for (i = 0; i < num_mix_sources; i++) { uint32_t avail_frames; - buffer_lock(sources[i], &source_flags); + sources[i] = buffer_acquire_irq(sources[i]); avail_frames = audio_stream_avail_frames(sources_stream[i], &sink->stream); frames = MIN(frames, avail_frames); - buffer_unlock(sources[i], source_flags); + sources[i] = buffer_release_irq(sources[i]); } - buffer_unlock(sink, sink_flags); + sink = buffer_release_irq(sink); /* Every source has the same format, so calculate bytes based * on the first one. From 9491e57666f460cdd0326e88bd72d0e121a83172 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Mon, 25 Oct 2021 20:44:05 -0700 Subject: [PATCH 07/22] component: use buffer acquire/release instead of buffer_lock/unlock() which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/include/sof/audio/component.h | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/include/sof/audio/component.h b/src/include/sof/audio/component.h index a3e9e7abd7e6..11d6fa8221a7 100644 --- a/src/include/sof/audio/component.h +++ b/src/include/sof/audio/component.h @@ -773,16 +773,13 @@ void comp_get_copy_limits_with_lock(struct comp_buffer *source, struct comp_buffer *sink, struct comp_copy_limits *cl) { - uint32_t source_flags = 0; - uint32_t sink_flags = 0; - - buffer_lock(source, &source_flags); - buffer_lock(sink, &sink_flags); + source = buffer_acquire_irq(source); + sink = buffer_acquire_irq(sink); comp_get_copy_limits(source, sink, cl); - buffer_unlock(sink, sink_flags); - buffer_unlock(source, source_flags); + source = buffer_release_irq(source); + sink = buffer_release_irq(sink); } /** From 10f07f98d378e832d09fe21a7315f0d80f77281e Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Mon, 25 Oct 2021 20:46:20 -0700 Subject: [PATCH 08/22] ipc-helper: use buffer acquire/release instead of buffer_lock/unlock() which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/ipc/ipc-helper.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/ipc/ipc-helper.c b/src/ipc/ipc-helper.c index d142aa9aadcf..50b2d4cb8ae4 100644 --- a/src/ipc/ipc-helper.c +++ b/src/ipc/ipc-helper.c @@ -109,7 +109,6 @@ int comp_verify_params(struct comp_dev *dev, uint32_t flag, struct comp_buffer *sinkb; struct comp_buffer *buf; int dir = dev->direction; - uint32_t flags = 0; if (!params) { comp_err(dev, "comp_verify_params(): !params"); @@ -132,7 +131,7 @@ int comp_verify_params(struct comp_dev *dev, uint32_t flag, struct comp_buffer, source_list); - buffer_lock(buf, &flags); + buf = buffer_acquire_irq(buf); /* update specific pcm parameter with buffer parameter if * specific flag is set. @@ -147,7 +146,7 @@ int comp_verify_params(struct comp_dev *dev, uint32_t flag, /* set component period frames */ component_set_period_frames(dev, buf->stream.rate); - buffer_unlock(buf, flags); + buf = buffer_release_irq(buf); } else { /* for other components we iterate over all downstream buffers * (for playback) or upstream buffers (for capture). @@ -158,20 +157,20 @@ int comp_verify_params(struct comp_dev *dev, uint32_t flag, while (clist != buffer_list) { curr = clist; buf = buffer_from_list(curr, struct comp_buffer, dir); - buffer_lock(buf, &flags); + buf = buffer_acquire_irq(buf); clist = clist->next; comp_update_params(flag, params, buf); buffer_set_params(buf, params, BUFFER_UPDATE_FORCE); - buffer_unlock(buf, flags); + buf = buffer_release_irq(buf); } /* fetch sink buffer in order to calculate period frames */ sinkb = list_first_item(&dev->bsink_list, struct comp_buffer, source_list); - buffer_lock(sinkb, &flags); + sinkb = buffer_acquire_irq(sinkb); component_set_period_frames(dev, sinkb->stream.rate); - buffer_unlock(sinkb, flags); + sinkb = buffer_release_irq(sinkb); } return 0; From ce7d76801a22bb3c957027eef7233fb1f85433ea Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Mon, 25 Oct 2021 20:47:50 -0700 Subject: [PATCH 09/22] src: use buffer acquire/release instead of buffer_lock/unlock() which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/src/src.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/audio/src/src.c b/src/audio/src/src.c index ca4649755dc8..fcb898362ca2 100644 --- a/src/audio/src/src.c +++ b/src/audio/src/src.c @@ -759,7 +759,6 @@ static int src_copy(struct comp_dev *dev) struct comp_buffer *source; struct comp_buffer *sink; int ret; - uint32_t flags = 0; comp_dbg(dev, "src_copy()"); @@ -769,8 +768,8 @@ static int src_copy(struct comp_dev *dev) sink = list_first_item(&dev->bsink_list, struct comp_buffer, source_list); - buffer_lock(source, &flags); - buffer_lock(sink, &flags); + source = buffer_acquire_irq(source); + sink = buffer_acquire_irq(sink); /* Get from buffers and SRC conversion specific block constraints * how many frames can be processed. If sufficient number of samples @@ -778,8 +777,8 @@ static int src_copy(struct comp_dev *dev) */ ret = src_get_copy_limits(cd, source, sink); - buffer_unlock(sink, flags); - buffer_unlock(source, flags); + buffer_release_irq(sink); + buffer_release_irq(source); if (ret) { comp_info(dev, "No data to process."); From d2046301a4446a1141f5b324e5dcd25c998386f3 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Mon, 25 Oct 2021 20:48:57 -0700 Subject: [PATCH 10/22] asrc: use buffer acquire/release instead of buffer_lock/unlock() which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/asrc/asrc.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/audio/asrc/asrc.c b/src/audio/asrc/asrc.c index 52fd7db11cae..870f23a91c66 100644 --- a/src/audio/asrc/asrc.c +++ b/src/audio/asrc/asrc.c @@ -829,7 +829,6 @@ static int asrc_copy(struct comp_dev *dev) int frames_src; int frames_snk; int ret; - uint32_t flags = 0; comp_dbg(dev, "asrc_copy()"); @@ -843,14 +842,14 @@ static int asrc_copy(struct comp_dev *dev) sink = list_first_item(&dev->bsink_list, struct comp_buffer, source_list); - buffer_lock(source, &flags); - buffer_lock(sink, &flags); + source = buffer_acquire_irq(source); + sink = buffer_acquire_irq(sink); frames_src = audio_stream_get_avail_frames(&source->stream); frames_snk = audio_stream_get_free_frames(&sink->stream); - buffer_unlock(sink, flags); - buffer_unlock(source, flags); + buffer_release_irq(sink); + buffer_release_irq(source); if (cd->mode == ASRC_OM_PULL) { /* Let ASRC access max number of source frames in pull mode. From 43c1213d72f16b66e4ffc1914dfd9dc0f8e02fe5 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Mon, 25 Oct 2021 20:52:14 -0700 Subject: [PATCH 11/22] pipeline: use buffer acquire/release instead of buffer_lock/unlock() which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/pipeline/pipeline-graph.c | 9 ++++----- src/audio/pipeline/pipeline-params.c | 10 ++++------ 2 files changed, 8 insertions(+), 11 deletions(-) diff --git a/src/audio/pipeline/pipeline-graph.c b/src/audio/pipeline/pipeline-graph.c index f0d92bb50135..52bcabcdb066 100644 --- a/src/audio/pipeline/pipeline-graph.c +++ b/src/audio/pipeline/pipeline-graph.c @@ -359,7 +359,6 @@ int pipeline_for_each_comp(struct comp_dev *current, struct list_item *clist; struct comp_buffer *buffer; struct comp_dev *buffer_comp; - uint32_t flags; /* run this operation further */ list_for_item(clist, buffer_list) { @@ -382,15 +381,15 @@ int pipeline_for_each_comp(struct comp_dev *current, /* continue further */ if (ctx->comp_func) { - buffer_lock(buffer, &flags); + buffer = buffer_acquire_irq(buffer); buffer->walking = true; - buffer_unlock(buffer, flags); + buffer = buffer_release_irq(buffer); int err = ctx->comp_func(buffer_comp, buffer, ctx, dir); - buffer_lock(buffer, &flags); + buffer = buffer_acquire_irq(buffer); buffer->walking = false; - buffer_unlock(buffer, flags); + buffer = buffer_release_irq(buffer); if (err < 0 || err == PPL_STATUS_PATH_STOP) return err; } diff --git a/src/audio/pipeline/pipeline-params.c b/src/audio/pipeline/pipeline-params.c index 44406474a225..c7a0cd80e5be 100644 --- a/src/audio/pipeline/pipeline-params.c +++ b/src/audio/pipeline/pipeline-params.c @@ -25,7 +25,6 @@ static int pipeline_comp_params_neg(struct comp_dev *current, int dir) { struct pipeline_data *ppl_data = ctx->comp_data; - uint32_t flags = 0; int err = 0; pipe_dbg(current->pipeline, "pipeline_comp_params_neg(), current->comp.id = %u, dir = %u", @@ -57,11 +56,11 @@ static int pipeline_comp_params_neg(struct comp_dev *current, * should explicitly configure the channels of the branched buffers. */ if (calling_buf) { - buffer_lock(calling_buf, &flags); + calling_buf = buffer_acquire_irq(calling_buf); err = buffer_set_params(calling_buf, &ppl_data->params->params, BUFFER_UPDATE_FORCE); - buffer_unlock(calling_buf, flags); + calling_buf = buffer_release_irq(calling_buf); } return err; @@ -148,7 +147,6 @@ static int pipeline_comp_hw_params(struct comp_dev *current, struct pipeline_walk_context *ctx, int dir) { struct pipeline_data *ppl_data = ctx->comp_data; - uint32_t flags = 0; int ret; pipe_dbg(current->pipeline, "pipeline_comp_hw_params(), current->comp.id = %u, dir = %u", @@ -172,10 +170,10 @@ static int pipeline_comp_hw_params(struct comp_dev *current, /* set buffer parameters */ if (calling_buf) { - buffer_lock(calling_buf, &flags); + calling_buf = buffer_acquire_irq(calling_buf); ret = buffer_set_params(calling_buf, &ppl_data->params->params, BUFFER_UPDATE_IF_UNSET); - buffer_unlock(calling_buf, flags); + calling_buf = buffer_release_irq(calling_buf); if (ret < 0) pipe_err(current->pipeline, "pipeline_comp_hw_params(): buffer_set_params(): %d", ret); From c6b379b017bc16f5c4ab541e0f296f56891a0ff8 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Wed, 27 Oct 2021 08:12:53 -0700 Subject: [PATCH 12/22] crossover: use buffer acquire/release instead of buffer_lock/unlock() which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/crossover/crossover.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/audio/crossover/crossover.c b/src/audio/crossover/crossover.c index 711f539fa02a..3808b034531a 100644 --- a/src/audio/crossover/crossover.c +++ b/src/audio/crossover/crossover.c @@ -633,7 +633,6 @@ static int crossover_copy(struct comp_dev *dev) uint32_t num_assigned_sinks = 0; uint32_t frames = UINT_MAX; uint32_t source_bytes, avail; - uint32_t flags = 0; uint32_t sinks_bytes[SOF_CROSSOVER_MAX_STREAMS] = { 0 }; comp_dbg(dev, "crossover_copy()"); @@ -672,11 +671,11 @@ static int crossover_copy(struct comp_dev *dev) else num_sinks = num_assigned_sinks; - buffer_lock(source, &flags); + source = buffer_acquire_irq(source); /* Check if source is active */ if (source->source->state != dev->state) { - buffer_unlock(source, flags); + source = buffer_release_irq(source); return -EINVAL; } @@ -684,14 +683,14 @@ static int crossover_copy(struct comp_dev *dev) for (i = 0; i < num_sinks; i++) { if (!sinks[i]) continue; - buffer_lock(sinks[i], &flags); + sinks[i] = buffer_acquire_irq(sinks[i]); avail = audio_stream_avail_frames(&source->stream, &sinks[i]->stream); frames = MIN(frames, avail); - buffer_unlock(sinks[i], flags); + buffer_release_irq(sinks[i]); } - buffer_unlock(source, flags); + source = buffer_release_irq(source); source_bytes = frames * audio_stream_frame_bytes(&source->stream); From 2e8696dff5525a7431435d3291ca2d5c735d25cd Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Wed, 27 Oct 2021 08:14:49 -0700 Subject: [PATCH 13/22] google_hotword_detec: use buffer acquire/release instead of buffer_lock/unlock which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/google_hotword_detect.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/audio/google_hotword_detect.c b/src/audio/google_hotword_detect.c index 734f11cc0516..c44c8f28194c 100644 --- a/src/audio/google_hotword_detect.c +++ b/src/audio/google_hotword_detect.c @@ -383,7 +383,7 @@ static int ghd_copy(struct comp_dev *dev) struct comp_data *cd = comp_get_drvdata(dev); struct comp_buffer *source; struct audio_stream *stream; - uint32_t bytes, flags, tail_bytes, head_bytes = 0; + uint32_t bytes, tail_bytes, head_bytes = 0; int ret; /* Check for new model */ @@ -399,9 +399,9 @@ static int ghd_copy(struct comp_dev *dev) struct comp_buffer, sink_list); stream = &source->stream; - buffer_lock(source, &flags); + source = buffer_acquire_irq(source); bytes = audio_stream_get_avail_bytes(&source->stream); - buffer_unlock(source, flags); + source = buffer_release_irq(source); comp_dbg(dev, "ghd_copy() avail_bytes %u", bytes); comp_dbg(dev, "buffer begin/r_ptr/end [0x%x 0x%x 0x%x]", From 6aac6ee4f8105ff3c6c412b3c74fdf470d910396 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Wed, 27 Oct 2021 08:17:03 -0700 Subject: [PATCH 14/22] tone: use buffer acquire/release instead of buffer lock/unlock which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/tone.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/src/audio/tone.c b/src/audio/tone.c index d913acb14d0b..5a67a2510c24 100644 --- a/src/audio/tone.c +++ b/src/audio/tone.c @@ -426,7 +426,6 @@ static int tone_params(struct comp_dev *dev, struct comp_data *cd = comp_get_drvdata(dev); struct comp_buffer *sourceb; struct comp_buffer *sinkb; - uint32_t flags = 0; sourceb = list_first_item(&dev->bsource_list, struct comp_buffer, sink_list); @@ -441,8 +440,8 @@ static int tone_params(struct comp_dev *dev, if (dev->ipc_config.frame_fmt != SOF_IPC_FRAME_S32_LE) return -EINVAL; - buffer_lock(sourceb, &flags); - buffer_lock(sinkb, &flags); + sourceb = buffer_acquire_irq(sourceb); + sinkb = buffer_acquire_irq(sinkb); sourceb->stream.frame_fmt = dev->ipc_config.frame_fmt; sinkb->stream.frame_fmt = dev->ipc_config.frame_fmt; @@ -451,8 +450,8 @@ static int tone_params(struct comp_dev *dev, cd->period_bytes = dev->frames * audio_stream_frame_bytes(&sourceb->stream); - buffer_unlock(sinkb, flags); - buffer_unlock(sourceb, flags); + sinkb = buffer_release_irq(sinkb); + sourceb = buffer_release_irq(sourceb); return 0; } @@ -615,7 +614,6 @@ static int tone_copy(struct comp_dev *dev) struct comp_buffer *sink; struct comp_data *cd = comp_get_drvdata(dev); uint32_t free; - uint32_t flags = 0; comp_dbg(dev, "tone_copy()"); @@ -623,9 +621,9 @@ static int tone_copy(struct comp_dev *dev) sink = list_first_item(&dev->bsink_list, struct comp_buffer, source_list); - buffer_lock(sink, &flags); + sink = buffer_acquire_irq(sink); free = audio_stream_get_free_bytes(&sink->stream); - buffer_unlock(sink, flags); + sink = buffer_release_irq(sink); /* Test that sink has enough free frames. Then run once to maintain * low latency and steady load for tones. From 433dfb9a40cdc4575b14874891c3aa7d745b57cc Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Wed, 27 Oct 2021 08:21:18 -0700 Subject: [PATCH 15/22] kpb: use buffer_acquire/release instead of buffer_lock/unlock which will be deprecated Signed-off-by: Ranjani Sridharan --- src/audio/kpb.c | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/src/audio/kpb.c b/src/audio/kpb.c index bc35723fc32f..8065d7a9fc7d 100644 --- a/src/audio/kpb.c +++ b/src/audio/kpb.c @@ -625,7 +625,6 @@ static int kpb_copy(struct comp_dev *dev) struct comp_buffer *sink = NULL; size_t copy_bytes = 0; size_t sample_width = kpb->config.sampling_width; - uint32_t flags = 0; struct draining_data *dd = &kpb->draining_task_data; uint32_t avail_bytes; @@ -641,17 +640,17 @@ static int kpb_copy(struct comp_dev *dev) goto out; } - buffer_lock(source, &flags); + source = buffer_acquire_irq(source); /* Validate source */ if (!source->stream.r_ptr) { comp_err(dev, "kpb_copy(): invalid source pointers."); ret = -EINVAL; - buffer_unlock(source, flags); + source = buffer_release_irq(source); goto out; } - buffer_unlock(source, flags); + source = buffer_release_irq(source); switch (kpb->state) { case KPB_STATE_RUN: @@ -665,17 +664,17 @@ static int kpb_copy(struct comp_dev *dev) goto out; } - buffer_lock(sink, &flags); + sink = buffer_acquire_irq(sink); /* Validate sink */ if (!sink->stream.w_ptr) { comp_err(dev, "kpb_copy(): invalid selector sink pointers."); ret = -EINVAL; - buffer_unlock(sink, flags); + sink = buffer_release_irq(sink); goto out; } - buffer_unlock(sink, flags); + sink = buffer_release_irq(sink); copy_bytes = audio_stream_get_copy_bytes(&source->stream, &sink->stream); if (!copy_bytes) { @@ -724,17 +723,17 @@ static int kpb_copy(struct comp_dev *dev) goto out; } - buffer_lock(sink, &flags); + sink = buffer_acquire_irq(sink); /* Validate sink */ if (!sink->stream.w_ptr) { comp_err(dev, "kpb_copy(): invalid host sink pointers."); ret = -EINVAL; - buffer_unlock(sink, flags); + sink = buffer_release_irq(sink); goto out; } - buffer_unlock(sink, flags); + sink = buffer_release_irq(sink); copy_bytes = audio_stream_get_copy_bytes(&source->stream, &sink->stream); if (!copy_bytes) { From 4f0717af4d0b771cd45453f7effa7bfd34c6c82f Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Wed, 27 Oct 2021 08:34:35 -0700 Subject: [PATCH 16/22] mux: use buffer acquire/release instead of buffer_lock/unlock which will be deprecated Signed-off-by: Ranjani Sridharan --- src/audio/mux/mux.c | 30 ++++++++++++++---------------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/src/audio/mux/mux.c b/src/audio/mux/mux.c index 0624e326fa85..4146c2e930ec 100644 --- a/src/audio/mux/mux.c +++ b/src/audio/mux/mux.c @@ -425,7 +425,6 @@ static int demux_copy(struct comp_dev *dev) uint32_t source_bytes; uint32_t avail; uint32_t sinks_bytes[MUX_MAX_STREAMS] = { 0 }; - uint32_t flags = 0; int i; comp_dbg(dev, "demux_copy()"); @@ -439,7 +438,7 @@ static int demux_copy(struct comp_dev *dev) // align sink streams with their respective configurations list_for_item(clist, &dev->bsink_list) { sink = container_of(clist, struct comp_buffer, source_list); - buffer_lock(sink, &flags); + sink = buffer_acquire_irq(sink); if (sink->sink->state == dev->state) { num_sinks++; i = get_stream_index(cd, sink->pipeline_id); @@ -450,7 +449,7 @@ static int demux_copy(struct comp_dev *dev) sinks[i] = sink; look_ups[i] = look_up; } - buffer_unlock(sink, flags); + sink = buffer_release_irq(sink); } /* if there are no sinks active */ @@ -460,25 +459,25 @@ static int demux_copy(struct comp_dev *dev) source = list_first_item(&dev->bsource_list, struct comp_buffer, sink_list); - buffer_lock(source, &flags); + source = buffer_acquire_irq(source); /* check if source is active */ if (source->source->state != dev->state) { - buffer_unlock(source, flags); + source = buffer_release_irq(source); return 0; } for (i = 0; i < MUX_MAX_STREAMS; i++) { if (!sinks[i]) continue; - buffer_lock(sinks[i], &flags); + sinks[i] = buffer_acquire_irq(sinks[i]); avail = audio_stream_avail_frames(&source->stream, &sinks[i]->stream); frames = MIN(frames, avail); - buffer_unlock(sinks[i], flags); + buffer_release_irq(sinks[i]); } - buffer_unlock(source, flags); + source = buffer_release_irq(source); source_bytes = frames * audio_stream_frame_bytes(&source->stream); for (i = 0; i < MUX_MAX_STREAMS; i++) { @@ -525,7 +524,6 @@ static int mux_copy(struct comp_dev *dev) uint32_t frames = -1; uint32_t sources_bytes[MUX_MAX_STREAMS] = { 0 }; uint32_t sink_bytes; - uint32_t flags = 0; int i; comp_dbg(dev, "mux_copy()"); @@ -539,7 +537,7 @@ static int mux_copy(struct comp_dev *dev) /* align source streams with their respective configurations */ list_for_item(clist, &dev->bsource_list) { source = container_of(clist, struct comp_buffer, sink_list); - buffer_lock(source, &flags); + source = buffer_acquire_irq(source); if (source->source->state == dev->state) { num_sources++; i = get_stream_index(cd, source->pipeline_id); @@ -549,7 +547,7 @@ static int mux_copy(struct comp_dev *dev) sources[i] = source; sources_stream[i] = &source->stream; } else { - buffer_unlock(source, flags); + source = buffer_release_irq(source); } } @@ -560,17 +558,17 @@ static int mux_copy(struct comp_dev *dev) sink = list_first_item(&dev->bsink_list, struct comp_buffer, source_list); - buffer_lock(sink, &flags); + sink = buffer_acquire_irq(sink); /* check if sink is active */ if (sink->sink->state != dev->state) { for (i = 0; i < MUX_MAX_STREAMS; i++) { if (!sources[i]) continue; - buffer_unlock(sources[i], flags); + buffer_release_irq(sources[i]); } - buffer_unlock(sink, flags); + sink = buffer_release_irq(sink); return 0; } @@ -581,10 +579,10 @@ static int mux_copy(struct comp_dev *dev) avail_frames = audio_stream_avail_frames(sources_stream[i], &sink->stream); frames = MIN(frames, avail_frames); - buffer_unlock(sources[i], flags); + sources[i] = buffer_release_irq(sources[i]); } - buffer_unlock(sink, flags); + sink = buffer_release_irq(sink); for (i = 0; i < MUX_MAX_STREAMS; i++) { if (!sources[i]) From 407744bfc87d2af4c94de36de96798847e38713b Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Wed, 27 Oct 2021 08:43:06 -0700 Subject: [PATCH 17/22] selector: use buffer acquire/release instead of buffer_lock/unlock() which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/selector/selector.c | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/src/audio/selector/selector.c b/src/audio/selector/selector.c index c8dd4e030d1f..5db34a943810 100644 --- a/src/audio/selector/selector.c +++ b/src/audio/selector/selector.c @@ -103,7 +103,6 @@ static int selector_verify_params(struct comp_dev *dev, struct comp_buffer *sinkb; uint32_t in_channels; uint32_t out_channels; - uint32_t flags = 0; comp_dbg(dev, "selector_verify_params()"); @@ -127,7 +126,7 @@ static int selector_verify_params(struct comp_dev *dev, } in_channels = cd->config.in_channels_count; - buffer_lock(buffer, &flags); + buffer = buffer_acquire_irq(buffer); /* if cd->config.out_channels_count are equal to 0 * (it can vary), we set params->channels to sink buffer @@ -148,7 +147,7 @@ static int selector_verify_params(struct comp_dev *dev, } out_channels = cd->config.out_channels_count; - buffer_lock(buffer, &flags); + buffer = buffer_acquire_irq(buffer); /* if cd->config.in_channels_count are equal to 0 * (it can vary), we set params->channels to source buffer @@ -166,7 +165,7 @@ static int selector_verify_params(struct comp_dev *dev, /* set component period frames */ component_set_period_frames(dev, sinkb->stream.rate); - buffer_unlock(buffer, flags); + buffer_release_irq(buffer); /* verify input channels */ switch (in_channels) { @@ -378,7 +377,6 @@ static int selector_copy(struct comp_dev *dev) uint32_t frames; uint32_t source_bytes; uint32_t sink_bytes; - uint32_t flags = 0; comp_dbg(dev, "selector_copy()"); @@ -391,15 +389,15 @@ static int selector_copy(struct comp_dev *dev) if (!source->stream.avail) return PPL_STATUS_PATH_STOP; - buffer_lock(source, &flags); - buffer_lock(sink, &flags); + source = buffer_acquire_irq(source); + sink = buffer_acquire_irq(sink); frames = audio_stream_avail_frames(&source->stream, &sink->stream); source_bytes = frames * audio_stream_frame_bytes(&source->stream); sink_bytes = frames * audio_stream_frame_bytes(&sink->stream); - buffer_unlock(sink, flags); - buffer_unlock(source, flags); + sink = buffer_release_irq(sink); + source = buffer_release_irq(source); comp_dbg(dev, "selector_copy(), source_bytes = 0x%x, sink_bytes = 0x%x", source_bytes, sink_bytes); From 708ec8e6c78572a9ff8ad6d2e96cf96c6078ebc5 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Wed, 27 Oct 2021 09:00:53 -0700 Subject: [PATCH 18/22] smart_amp: use buffer_acquire/release instead of buffer_lock/unlock which will be deprecated. Signed-off-by: Ranjani Sridharan --- src/audio/smart_amp/smart_amp.c | 55 ++++++++++++++++----------------- 1 file changed, 27 insertions(+), 28 deletions(-) diff --git a/src/audio/smart_amp/smart_amp.c b/src/audio/smart_amp/smart_amp.c index aefbb9c6dea8..bea823d6f2f8 100644 --- a/src/audio/smart_amp/smart_amp.c +++ b/src/audio/smart_amp/smart_amp.c @@ -567,46 +567,47 @@ static smart_amp_proc get_smart_amp_process(struct comp_dev *dev) static int smart_amp_copy(struct comp_dev *dev) { struct smart_amp_data *sad = comp_get_drvdata(dev); + struct comp_buffer *source_buf = sad->source_buf; + struct comp_buffer *sink_buf = sad->sink_buf; uint32_t avail_passthrough_frames; uint32_t avail_feedback_frames; uint32_t avail_frames; uint32_t source_bytes; uint32_t sink_bytes; uint32_t feedback_bytes; - uint32_t source_flags = 0; - uint32_t sink_flags = 0; - uint32_t feedback_flags = 0; int ret = 0; comp_dbg(dev, "smart_amp_copy()"); - buffer_lock(sad->source_buf, &source_flags); - buffer_lock(sad->sink_buf, &sink_flags); + source_buf = buffer_acquire_irq(source_buf); + sink_buf = buffer_acquire_irq(sink_buf); /* available bytes and samples calculation */ avail_passthrough_frames = audio_stream_avail_frames(&sad->source_buf->stream, &sad->sink_buf->stream); - buffer_unlock(sad->source_buf, source_flags); - buffer_unlock(sad->sink_buf, sink_flags); + source_buf = buffer_release_irq(source_buf); + sink_buf = buffer_release_irq(sink_buf); avail_frames = avail_passthrough_frames; if (sad->feedback_buf) { - buffer_lock(sad->feedback_buf, &feedback_flags); - if (comp_get_state(dev, sad->feedback_buf->source) == dev->state) { + struct comp_buffer *buf = sad->feedback_buf; + + buf = buffer_acquire_irq(buf); + if (comp_get_state(dev, buf->source) == dev->state) { /* feedback */ avail_feedback_frames = - audio_stream_get_avail_frames(&sad->feedback_buf->stream); + audio_stream_get_avail_frames(&buf->stream); avail_frames = MIN(avail_passthrough_frames, avail_feedback_frames); feedback_bytes = avail_frames * - audio_stream_frame_bytes(&sad->feedback_buf->stream); + audio_stream_frame_bytes(&buf->stream); - buffer_unlock(sad->feedback_buf, feedback_flags); + buffer_release_irq(buf); comp_dbg(dev, "smart_amp_copy(): processing %d feedback frames (avail_passthrough_frames: %d)", avail_frames, avail_passthrough_frames); @@ -619,20 +620,18 @@ static int smart_amp_copy(struct comp_dev *dev) comp_update_buffer_consume(sad->feedback_buf, feedback_bytes); } else { - buffer_unlock(sad->feedback_buf, feedback_flags); + buffer_release_irq(buf); } } /* bytes calculation */ - buffer_lock(sad->source_buf, &source_flags); - source_bytes = avail_frames * - audio_stream_frame_bytes(&sad->source_buf->stream); - buffer_unlock(sad->source_buf, source_flags); + source_buf = buffer_acquire_irq(source_buf); + source_bytes = avail_frames * audio_stream_frame_bytes(&source_buf->stream); + source_buf = buffer_release_irq(source_buf); - buffer_lock(sad->sink_buf, &sink_flags); - sink_bytes = avail_frames * - audio_stream_frame_bytes(&sad->sink_buf->stream); - buffer_unlock(sad->sink_buf, sink_flags); + sink_buf = buffer_acquire_irq(sink_buf); + sink_bytes = avail_frames * audio_stream_frame_bytes(&sink_buf->stream); + sink_buf = buffer_release_irq(sink_buf); /* process data */ buffer_stream_invalidate(sad->source_buf, source_bytes); @@ -661,7 +660,6 @@ static int smart_amp_prepare(struct comp_dev *dev) struct smart_amp_data *sad = comp_get_drvdata(dev); struct comp_buffer *source_buffer; struct list_item *blist; - uint32_t flags = 0; int ret; int bitwidth; @@ -675,12 +673,12 @@ static int smart_amp_prepare(struct comp_dev *dev) list_for_item(blist, &dev->bsource_list) { source_buffer = container_of(blist, struct comp_buffer, sink_list); - buffer_lock(source_buffer, &flags); + source_buffer = buffer_acquire_irq(source_buffer); if (source_buffer->source->ipc_config.type == SOF_COMP_DEMUX) sad->feedback_buf = source_buffer; else sad->source_buf = source_buffer; - buffer_unlock(source_buffer, flags); + source_buffer = buffer_release_irq(source_buffer); } sad->sink_buf = list_first_item(&dev->bsink_list, struct comp_buffer, @@ -690,10 +688,12 @@ static int smart_amp_prepare(struct comp_dev *dev) sad->out_channels = sad->sink_buf->stream.channels; if (sad->feedback_buf) { - buffer_lock(sad->feedback_buf, &flags); - sad->feedback_buf->stream.channels = sad->config.feedback_channels; - sad->feedback_buf->stream.rate = sad->source_buf->stream.rate; + struct comp_buffer *buf = sad->feedback_buf; + buf = buffer_acquire_irq(buf); + buf->stream.channels = sad->config.feedback_channels; + buf->stream.rate = sad->source_buf->stream.rate; + buffer_release_irq(buf); ret = smart_amp_check_audio_fmt(sad->source_buf->stream.rate, sad->source_buf->stream.channels); if (ret) { @@ -702,7 +702,6 @@ static int smart_amp_prepare(struct comp_dev *dev) sad->source_buf->stream.channels); goto error; } - buffer_unlock(sad->feedback_buf, flags); } switch (sad->source_buf->stream.frame_fmt) { From 515181ad272cc09e3d31ba73093cd87e0fefb58e Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Wed, 27 Oct 2021 09:01:57 -0700 Subject: [PATCH 19/22] detect_test: use buffer acquire/release instead of buffer_lock/unlock which will be deprecated Signed-off-by: Ranjani Sridharan --- src/samples/audio/detect_test.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/samples/audio/detect_test.c b/src/samples/audio/detect_test.c index 056c7478919c..b44bc32a6e2c 100644 --- a/src/samples/audio/detect_test.c +++ b/src/samples/audio/detect_test.c @@ -625,7 +625,6 @@ static int test_keyword_copy(struct comp_dev *dev) struct comp_data *cd = comp_get_drvdata(dev); struct comp_buffer *source; uint32_t frames; - uint32_t flags = 0; comp_dbg(dev, "test_keyword_copy()"); @@ -636,9 +635,9 @@ static int test_keyword_copy(struct comp_dev *dev) if (!source->stream.avail) return PPL_STATUS_PATH_STOP; - buffer_lock(source, &flags); + source = buffer_acquire_irq(source); frames = audio_stream_get_avail_frames(&source->stream); - buffer_unlock(source, flags); + source = buffer_release_irq(source); /* copy and perform detection */ buffer_stream_invalidate(source, audio_stream_get_avail_bytes(&source->stream)); From 3dcae7cbe9450cb542650801350fc6a35267c90e Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Wed, 27 Oct 2021 09:10:22 -0700 Subject: [PATCH 20/22] smart_amp_test: use buffer acquire/release instead of buffer lock/unlock which will be deprecated Signed-off-by: Ranjani Sridharan --- src/samples/audio/smart_amp_test.c | 40 ++++++++++++++++-------------- 1 file changed, 21 insertions(+), 19 deletions(-) diff --git a/src/samples/audio/smart_amp_test.c b/src/samples/audio/smart_amp_test.c index 77b1e55ed90c..4746857d0ea0 100644 --- a/src/samples/audio/smart_amp_test.c +++ b/src/samples/audio/smart_amp_test.c @@ -408,34 +408,35 @@ static smart_amp_proc get_smart_amp_process(struct comp_dev *dev) static int smart_amp_copy(struct comp_dev *dev) { struct smart_amp_data *sad = comp_get_drvdata(dev); + struct comp_buffer *source_buf = sad->source_buf; + struct comp_buffer *sink_buf = sad->sink_buf; uint32_t avail_passthrough_frames; uint32_t avail_feedback_frames; uint32_t avail_frames; uint32_t source_bytes; uint32_t sink_bytes; uint32_t feedback_bytes; - uint32_t source_flags = 0; - uint32_t sink_flags = 0; - uint32_t feedback_flags = 0; int ret = 0; comp_dbg(dev, "smart_amp_copy()"); - buffer_lock(sad->source_buf, &source_flags); - buffer_lock(sad->sink_buf, &sink_flags); + source_buf = buffer_release_irq(source_buf); + sink_buf = buffer_release_irq(sink_buf); /* available bytes and samples calculation */ avail_passthrough_frames = audio_stream_avail_frames(&sad->source_buf->stream, &sad->sink_buf->stream); - buffer_unlock(sad->source_buf, source_flags); - buffer_unlock(sad->sink_buf, sink_flags); + source_buf = buffer_release_irq(source_buf); + sink_buf = buffer_release_irq(sink_buf); avail_frames = avail_passthrough_frames; if (sad->feedback_buf) { - buffer_lock(sad->feedback_buf, &feedback_flags); + struct comp_buffer *buf = sad->feedback_buf; + + buf = buffer_acquire_irq(buf); if (comp_get_state(dev, sad->feedback_buf->source) == dev->state) { /* feedback */ avail_feedback_frames = @@ -447,7 +448,7 @@ static int smart_amp_copy(struct comp_dev *dev) feedback_bytes = avail_frames * audio_stream_frame_bytes(&sad->feedback_buf->stream); - buffer_unlock(sad->feedback_buf, feedback_flags); + buffer_release_irq(buf); comp_dbg(dev, "smart_amp_copy(): processing %d feedback frames (avail_passthrough_frames: %d)", avail_frames, avail_passthrough_frames); @@ -460,20 +461,20 @@ static int smart_amp_copy(struct comp_dev *dev) comp_update_buffer_consume(sad->feedback_buf, feedback_bytes); } else { - buffer_unlock(sad->feedback_buf, feedback_flags); + buffer_release_irq(buf); } } /* bytes calculation */ - buffer_lock(sad->source_buf, &source_flags); + source_buf = buffer_acquire_irq(source_buf); source_bytes = avail_frames * audio_stream_frame_bytes(&sad->source_buf->stream); - buffer_unlock(sad->source_buf, source_flags); + source_buf = buffer_release_irq(source_buf); - buffer_lock(sad->sink_buf, &sink_flags); + sink_buf = buffer_acquire_irq(sink_buf); sink_bytes = avail_frames * audio_stream_frame_bytes(&sad->sink_buf->stream); - buffer_unlock(sad->sink_buf, sink_flags); + sink_buf = buffer_release_irq(sink_buf); /* process data */ buffer_stream_invalidate(sad->source_buf, source_bytes); @@ -502,7 +503,6 @@ static int smart_amp_prepare(struct comp_dev *dev) struct smart_amp_data *sad = comp_get_drvdata(dev); struct comp_buffer *source_buffer; struct list_item *blist; - uint32_t flags = 0; int ret; comp_info(dev, "smart_amp_prepare()"); @@ -518,12 +518,12 @@ static int smart_amp_prepare(struct comp_dev *dev) list_for_item(blist, &dev->bsource_list) { source_buffer = container_of(blist, struct comp_buffer, sink_list); - buffer_lock(source_buffer, &flags); + source_buffer = buffer_acquire_irq(source_buffer); if (source_buffer->source->ipc_config.type == SOF_COMP_DEMUX) sad->feedback_buf = source_buffer; else sad->source_buf = source_buffer; - buffer_unlock(source_buffer, flags); + source_buffer = buffer_release_irq(source_buffer); } sad->sink_buf = list_first_item(&dev->bsink_list, struct comp_buffer, @@ -533,10 +533,12 @@ static int smart_amp_prepare(struct comp_dev *dev) sad->out_channels = sad->sink_buf->stream.channels; if (sad->feedback_buf) { - buffer_lock(sad->feedback_buf, &flags); + struct comp_buffer *buf = sad->feedback_buf; + + buf = buffer_acquire_irq(buf); sad->feedback_buf->stream.channels = sad->config.feedback_channels; sad->feedback_buf->stream.rate = sad->source_buf->stream.rate; - buffer_unlock(sad->feedback_buf, flags); + buf = buffer_release_irq(buf); } sad->process = get_smart_amp_process(dev); From 5b7743743e845050d1e48f36fb1a671e9a11efc5 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Wed, 27 Oct 2021 09:25:42 -0700 Subject: [PATCH 21/22] buffer: deprecate buffer_lock/unlock all users replaced with buffer_acquire/release Signed-off-by: Ranjani Sridharan --- src/include/sof/audio/buffer.h | 43 ---------------------------------- 1 file changed, 43 deletions(-) diff --git a/src/include/sof/audio/buffer.h b/src/include/sof/audio/buffer.h index 797cc298550a..81e604b038ef 100644 --- a/src/include/sof/audio/buffer.h +++ b/src/include/sof/audio/buffer.h @@ -199,49 +199,6 @@ static inline void buffer_stream_writeback(struct comp_buffer *buffer, uint32_t audio_stream_writeback(&buffer->stream, bytes); } -/** - * Locks buffer instance for buffers connecting components - * running on different cores. Buffer parameters will be invalidated - * to make sure the latest data can be retrieved. - * @param buffer Buffer instance. - * @param flags IRQ flags. - */ -static inline void buffer_lock(struct comp_buffer *buffer, uint32_t *flags) -{ - if (!is_coherent_shared(buffer, c)) { - /* Ignored by buffer_unlock() below, silences "may be - * used uninitialized" warning. - */ - *flags = 0xffffffff; - return; - } - - /* Expands to: *flags = ... */ - spin_lock_irq(&buffer->c.lock, *flags); - - /* invalidate in case something has changed during our wait */ - dcache_invalidate_region(uncache_to_cache(buffer), sizeof(*buffer)); -} - -/** - * Unlocks buffer instance for buffers connecting components - * running on different cores. Buffer parameters will be flushed - * to make sure all the changes are saved. Also they will be invalidated - * to spare the need of locking/unlocking buffer, when only reading parameters. - * @param buffer Buffer instance. - * @param flags IRQ flags. - */ -static inline void buffer_unlock(struct comp_buffer *buffer, uint32_t flags) -{ - if (!is_coherent_shared(buffer, c)) - return; - - /* wtb and inv to avoid buffer locking in read only situations */ - dcache_writeback_invalidate_region(uncache_to_cache(buffer), sizeof(*buffer)); - - spin_unlock_irq(&buffer->c.lock, flags); -} - __must_check static inline struct comp_buffer *buffer_acquire(struct comp_buffer *buffer) { struct coherent *c = coherent_acquire(&buffer->c, sizeof(*buffer)); From 6b82d009d19075281ed4b3291b5a8ee6d7e2c9a0 Mon Sep 17 00:00:00 2001 From: Ranjani Sridharan Date: Sat, 11 Sep 2021 10:26:51 -0700 Subject: [PATCH 22/22] APL: increase the size of 256 bytes heap With the addition of struct coherent member in struct buffer, the size of the struct exceeds 128 bytes. Increase the 256 block heap size and reduce the 128 block size to fix out of memory issues when running multiple-pipeline-all test. Signed-off-by: Ranjani Sridharan --- src/platform/apollolake/include/platform/lib/memory.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/platform/apollolake/include/platform/lib/memory.h b/src/platform/apollolake/include/platform/lib/memory.h index 396905f3a95a..cad81047e17d 100644 --- a/src/platform/apollolake/include/platform/lib/memory.h +++ b/src/platform/apollolake/include/platform/lib/memory.h @@ -267,8 +267,8 @@ /* Heap section counts base */ #define HEAP_COUNT64 128 -#define HEAP_COUNT128 128 -#define HEAP_COUNT256 96 +#define HEAP_COUNT128 96 +#define HEAP_COUNT256 112 #define HEAP_COUNT512 12 #define HEAP_COUNT1024 3 #define HEAP_COUNT2048 1