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/audio/asrc/asrc.c b/src/audio/asrc/asrc.c index 8d4cf23deb40..870f23a91c66 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); @@ -830,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()"); @@ -844,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. 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/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..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); @@ -703,13 +702,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/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, 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..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]", @@ -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/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. 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..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) { @@ -764,7 +763,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 +1487,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 +1516,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..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,33 +301,33 @@ 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_writeback(sink, sink_bytes); + buffer_stream_writeback(sink, sink_bytes); comp_update_buffer_produce(sink, sink_bytes); } 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. @@ -341,10 +340,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..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++) { @@ -495,10 +494,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 */ @@ -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,17 +579,17 @@ 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]) 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 +598,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/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); 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..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,23 +389,23 @@ 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); /* 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..bea823d6f2f8 100644 --- a/src/audio/smart_amp/smart_amp.c +++ b/src/audio/smart_amp/smart_amp.c @@ -567,78 +567,77 @@ 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); /* 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); 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_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); @@ -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) { diff --git a/src/audio/src/src.c b/src/audio/src/src.c index c6ef3203fa14..fcb898362ca2 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); @@ -760,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()"); @@ -770,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 @@ -779,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."); 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..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. @@ -633,7 +631,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..81e604b038ef 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 */ @@ -171,73 +183,53 @@ 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) + if (!is_coherent_shared(buffer, c)) return; 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) + if (!is_coherent_shared(buffer, c)) return; 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) +__must_check static inline struct comp_buffer *buffer_acquire(struct comp_buffer *buffer) { - if (!buffer->inter_core) { - /* Ignored by buffer_unlock() below, silences "may be - * used uninitialized" warning. - */ - *flags = 0xffffffff; - return; - } + struct coherent *c = coherent_acquire(&buffer->c, sizeof(*buffer)); + + return container_of(c, struct comp_buffer, c); +} - /* Expands to: *flags = ... */ - spin_lock_irq(buffer->lock, *flags); +static inline struct comp_buffer *buffer_release(struct comp_buffer *buffer) +{ + struct coherent *c = coherent_release(&buffer->c, sizeof(*buffer)); - /* invalidate in case something has changed during our wait */ - dcache_invalidate_region(uncache_to_cache(buffer), sizeof(*buffer)); + return container_of(c, struct comp_buffer, c); } -/** - * 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) +__must_check static inline struct comp_buffer *buffer_acquire_irq(struct comp_buffer *buffer) { - if (!buffer->inter_core) - return; + struct coherent *c = coherent_acquire_irq(&buffer->c, sizeof(*buffer)); - /* save lock pointer to avoid memory access after cache flushing */ - spinlock_t *lock = buffer->lock; + return container_of(c, struct comp_buffer, c); +} - /* wtb and inv to avoid buffer locking in read only situations */ - dcache_writeback_invalidate_region(uncache_to_cache(buffer), sizeof(*buffer)); +static inline struct comp_buffer *buffer_release_irq(struct comp_buffer *buffer) +{ + struct coherent *c = coherent_release_irq(&buffer->c, sizeof(*buffer)); - spin_unlock_irq(lock, flags); + return container_of(c, struct comp_buffer, c); } static inline void buffer_reset_pos(struct comp_buffer *buffer, void *data) { - uint32_t flags = 0; - - buffer_lock(buffer, &flags); + buffer = buffer_acquire_irq(buffer); /* reset rw pointers and avail/free bytes counters */ audio_stream_reset(&buffer->stream); @@ -245,11 +237,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 +250,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/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); } /** 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) diff --git a/src/ipc/ipc-helper.c b/src/ipc/ipc-helper.c index f5aa740b1225..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; @@ -180,22 +179,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) 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/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 diff --git a/src/samples/audio/detect_test.c b/src/samples/audio/detect_test.c index 046d8def3b51..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,12 +635,12 @@ 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_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..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,39 +448,39 @@ 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); /* 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); 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_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); @@ -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);